mediasoup 3.20.2 → 3.20.4

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

@@ -19,11 +19,11 @@ namespace RTC
 		/* Instance methods. */
 
 		HeartbeatHandler::HeartbeatHandler(
-		  AssociationListenerInterface& associationListener,
+		  AssociationListenerDeferrer& associationListenerDeferrer,
 		  const SctpOptions& sctpOptions,
 		  SharedInterface* shared,
 		  TransmissionControlBlockContextInterface* tcbContext)
-		  : associationListener(associationListener),
+		  : associationListenerDeferrer(associationListenerDeferrer),
 		    sctpOptions(sctpOptions),
 		    shared(shared),
 		    tcbContext(tcbContext),
@@ -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 }))
 		{
@@ -124,7 +124,7 @@ namespace RTC
 
 			if (!heartbeatInfoParameter)
 			{
-				this->associationListener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED,
 				  "ignoring HEARTBEAT-ACK chunk without Heartbeat Info parameter");
 
@@ -136,14 +136,14 @@ namespace RTC
 
 			if (!info)
 			{
-				this->associationListener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "ignoring Heartbeat Info parameter without info field");
 
 				return;
 			}
 			else if (infoLen != HeartbeatInfoLength)
 			{
-				this->associationListener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "ignoring Heartbeat Info parameter with wrong length");
 
 				return;
@@ -180,6 +180,23 @@ 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.
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
+
 			if (!this->tcbContext->IsAssociationEstablished())
 			{
 				MS_DEBUG_DEV("won't send HEARTBEAT-REQUEST when SCTP association is not established");
@@ -210,15 +227,37 @@ 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.
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
+
 			// Note that the timeout timer is not restarted. It will be started again when
 			// 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(
@@ -226,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

@@ -13,13 +13,13 @@ namespace RTC
 		/* Instance methods. */
 
 		StreamResetHandler::StreamResetHandler(
-		  AssociationListenerInterface& associationListener,
+		  AssociationListenerDeferrer& associationListenerDeferrer,
 		  SharedInterface* shared,
 		  TransmissionControlBlockContextInterface* tcbContext,
 		  DataTracker* dataTracker,
 		  ReassemblyQueue* reassemblyQueue,
 		  RetransmissionQueue* retransmissionQueue)
-		  : associationListener(associationListener),
+		  : associationListenerDeferrer(associationListenerDeferrer),
 		    shared(shared),
 		    tcbContext(tcbContext),
 		    dataTracker(dataTracker),
@@ -89,7 +89,7 @@ namespace RTC
 
 			if (!ValidateReceivedReConfigChunk(receivedReConfigChunk))
 			{
-				this->associationListener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "invalid RE-CONFIG command received");
 
 				return;
@@ -334,7 +334,7 @@ namespace RTC
 				this->reassemblyQueue->ResetStreamsAndLeaveDeferredReset(
 				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
 
-				this->associationListener.OnAssociationInboundStreamsReset(
+				this->associationListenerDeferrer.OnAssociationInboundStreamsReset(
 				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
 
 				this->lastProcessedReqResult = ReconfigurationResponseParameter::Result::SUCCESS_PERFORMED;
@@ -412,7 +412,7 @@ namespace RTC
 						MS_DEBUG_DEV(
 						  "reset stream success [reqSeqNbr:%" PRIu32 "]", this->currentRequest->GetReqSeqNbr());
 
-						this->associationListener.OnAssociationStreamsResetPerformed(
+						this->associationListenerDeferrer.OnAssociationStreamsResetPerformed(
 						  this->currentRequest->GetStreamIds());
 
 						this->currentRequest = std::nullopt;
@@ -450,7 +450,7 @@ namespace RTC
 						    receivedReconfigurationResponseParameter->GetResult())
 						    .c_str());
 
-						this->associationListener.OnAssociationStreamsResetFailed(
+						this->associationListenerDeferrer.OnAssociationStreamsResetFailed(
 						  this->currentRequest->GetStreamIds(),
 						  ReconfigurationResponseParameter::ResultToString(
 						    receivedReconfigurationResponseParameter->GetResult()));
@@ -465,10 +465,24 @@ 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.
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
+
 			if (this->currentRequest && this->currentRequest->HasBeenSent())
 			{
 				// The request was deferred (received "In Progress"). This is not a
@@ -481,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;
 				}
 			}
@@ -506,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);

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

@@ -21,7 +21,8 @@ namespace RTC
 		/* Instance methods. */
 
 		TransmissionControlBlock::TransmissionControlBlock(
-		  AssociationListenerInterface& associationListener,
+		  TransmissionControlBlockContextInterface::Listener* listener,
+		  AssociationListenerDeferrer& associationListenerDeferrer,
 		  const SctpOptions& sctpOptions,
 		  SharedInterface* shared,
 		  SendQueueInterface& sendQueue,
@@ -35,7 +36,8 @@ namespace RTC
 		  const NegotiatedCapabilities& negotiatedCapabilities,
 		  size_t maxPacketLength,
 		  std::function<bool()> isAssociationEstablished)
-		  : associationListener(associationListener),
+		  : listener(listener),
+		    associationListenerDeferrer(associationListenerDeferrer),
 		    sctpOptions(sctpOptions),
 		    shared(shared),
 		    packetSender(packetSender),
@@ -71,7 +73,7 @@ namespace RTC
 		      sctpOptions.maxReceiverWindowBufferSize, negotiatedCapabilities.messageInterleaving),
 		    retransmissionQueue(
 		      this,
-		      this->associationListener,
+		      this->associationListenerDeferrer,
 		      localInitialTsn,
 		      remoteAdvertisedReceiverWindowCredit,
 		      sendQueue,
@@ -80,13 +82,13 @@ namespace RTC
 		      negotiatedCapabilities.partialReliability,
 		      negotiatedCapabilities.messageInterleaving),
 		    streamResetHandler(
-		      this->associationListener,
+		      this->associationListenerDeferrer,
 		      this->shared,
 		      this,
 		      std::addressof(this->dataTracker),
 		      std::addressof(this->reassemblyQueue),
 		      std::addressof(this->retransmissionQueue)),
-		    heartbeatHandler(this->associationListener, sctpOptions, this->shared, this)
+		    heartbeatHandler(this->associationListenerDeferrer, sctpOptions, this->shared, this)
 		{
 			MS_TRACE();
 
@@ -407,10 +409,24 @@ namespace RTC
 			}
 		}
 
-		void TransmissionControlBlock::OnT3RtxTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
+		void TransmissionControlBlock::OnT3RtxTimer(uint64_t& /*baseTimeoutMs*/, bool& stop)
 		{
 			MS_TRACE();
 
+			const auto maxRestarts = this->t3RtxTimer->GetMaxRestarts();
+
+			MS_DEBUG_TAG(
+			  sctp,
+			  "%s timer has expired [expirations:%zu, maxRestarts:%s]",
+			  this->t3RtxTimer->GetLabel().c_str(),
+			  this->t3RtxTimer->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.
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
+
 			// In the COOKIE-ECHO state, let the T1-COOKIE timer trigger
 			// retransmissions, to avoid having two timers doing that.
 			if (this->remoteStateCookie.has_value())
@@ -427,6 +443,15 @@ namespace RTC
 
 					SendBufferedPackets(nowMs);
 				}
+				else
+				{
+					// `IncrementTxErrorCounter()` has closed (and destroyed) this TCB and
+					// its timers. Signal the firing timer to stop and don't touch any
+					// member afterwards.
+					stop = true;
+
+					return;
+				}
 			}
 		}
 
@@ -434,6 +459,23 @@ namespace RTC
 		{
 			MS_TRACE();
 
+#if MS_LOG_DEV_LEVEL == 3
+			const auto maxRestarts = this->delayedAckTimer->GetMaxRestarts();
+#endif
+
+			// NOTE: This timer expires very frequently (whenever received data is
+			// pending to be acked), so it's logged at dev level to avoid being noisy.
+			MS_DEBUG_DEV(
+			  "%s timer has expired [expirations:%zu, maxRestarts:%s]",
+			  this->delayedAckTimer->GetLabel().c_str(),
+			  this->delayedAckTimer->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.
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
+
 			this->dataTracker.HandleDelayedAckTimerExpiry();
 
 			MaySendSackChunk();
@@ -444,15 +486,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->t3RtxTimer.get())
 			{
 				OnT3RtxTimer(baseTimeoutMs, stop);

package/worker/src/RTC/SCTP/rx/ReassemblyQueue.cpp

@@ -140,12 +140,16 @@ namespace RTC
 			{
 				MS_DEBUG_DEV("forward TSN to %" PRIu32 ", deferring", tsn.Wrap());
 
+				this->queuedBytes += ForwardTsnCost(skippedStreams.size());
+
 				this->deferredResetStreams->deferredActions.emplace_back(
 				  [this,
 				   newCumulativeTsn,
 				   skippedStreams2 = std::vector<AnyForwardTsnChunk::SkippedStream>(
 				     skippedStreams.begin(), skippedStreams.end())]
 				  {
+					  this->queuedBytes -= ForwardTsnCost(skippedStreams2.size());
+
 					  HandleForwardTsn(newCumulativeTsn, skippedStreams2);
 				  });
 
@@ -216,15 +220,13 @@ namespace RTC
 
 			if (!this->deferredResetStreams.has_value())
 			{
-				return;
-			}
-
-			MS_DEBUG_DEV(
-			  "entering deferred reset [senderLastAssignedTsn:%" PRIu32 "]", senderLastAssignedTsn);
+				MS_DEBUG_DEV(
+				  "entering deferred reset [senderLastAssignedTsn:%" PRIu32 "]", senderLastAssignedTsn);
 
-			this->deferredResetStreams = std::make_optional<DeferredResetStreams>(
-			  this->tsnUnwrapper.Unwrap(senderLastAssignedTsn),
-			  std::set<uint16_t>(streamIds.begin(), streamIds.end()));
+				this->deferredResetStreams = std::make_optional<DeferredResetStreams>(
+				  this->tsnUnwrapper.Unwrap(senderLastAssignedTsn),
+				  std::set<uint16_t>(streamIds.begin(), streamIds.end()));
+			}
 
 			AssertIsConsistent();
 		}
@@ -244,6 +246,13 @@ namespace RTC
 			}
 		}
 
+		size_t ReassemblyQueue::ForwardTsnCost(size_t numStreams)
+		{
+			MS_TRACE();
+
+			return (1 + numStreams) * 4;
+		}
+
 		void ReassemblyQueue::AddReassembledMessage(std::span<const Types::UnwrappedTsn> tsns, Message message)
 		{
 			MS_TRACE();

package/worker/src/RTC/Transport.cpp

@@ -91,7 +91,7 @@ namespace RTC
 			};
 
 			this->sctpAssociation = std::make_unique<RTC::SCTP::Association>(
-			  sctpOptions, this, this->shared, options->isDataChannel());
+			  sctpOptions, this, this->shared, options->isDataChannel(), /*mayConnectOnReceivedSctpData*/ true);
 		}
 
 		// Create the RTCP timer.