mediasoup 3.19.19 → 3.19.21

package/worker/src/RTC/SCTP/association/{AssociationDeferredListener.cpp → AssociationListenerDeferrer.cpp}

@@ -1,30 +1,31 @@
-#define MS_CLASS "RTC::SCTP::AssociationDeferredListener"
+#define MS_CLASS "RTC::SCTP::AssociationListenerDeferrer"
 // #define MS_LOG_DEV_LEVEL 3
 
-#include "RTC/SCTP/association/AssociationDeferredListener.hpp"
+#include "RTC/SCTP/association/AssociationListenerDeferrer.hpp"
 #include "Logger.hpp"
 
 namespace RTC
 {
 	namespace SCTP
 	{
-		AssociationDeferredListener::ScopedDeferred::ScopedDeferred(
-		  AssociationDeferredListener& deferredListener)
-		  : deferredListener(deferredListener)
+		AssociationListenerDeferrer::ScopedDeferrer::ScopedDeferrer(
+		  AssociationListenerDeferrer& listenerDeferrer)
+		  : listenerDeferrer(listenerDeferrer)
 		{
 			MS_TRACE();
 
-			this->deferredListener.SetReady();
+			this->listenerDeferrer.SetReady();
 		}
 
-		AssociationDeferredListener::ScopedDeferred::~ScopedDeferred()
+		// NOLINTNEXTLINE(bugprone-exception-escape)
+		AssociationListenerDeferrer::ScopedDeferrer::~ScopedDeferrer()
 		{
 			MS_TRACE();
 
-			this->deferredListener.TriggerDeferredCallbacks();
+			this->listenerDeferrer.TriggerDeferredCallbacks();
 		}
 
-		AssociationDeferredListener::AssociationDeferredListener(AssociationListener* innerListener)
+		AssociationListenerDeferrer::AssociationListenerDeferrer(AssociationListener* innerListener)
 		  : innerListener(innerListener)
 		{
 			MS_TRACE();
@@ -32,21 +33,20 @@ namespace RTC
 			this->deferredCallbacks.reserve(8);
 		}
 
-		void AssociationDeferredListener::SetReady()
+		void AssociationListenerDeferrer::SetReady()
 		{
 			MS_TRACE();
 
+			MS_ASSERT(!this->ready, "already ready");
+
 			this->ready = true;
 		}
 
-		void AssociationDeferredListener::TriggerDeferredCallbacks()
+		void AssociationListenerDeferrer::TriggerDeferredCallbacks()
 		{
 			MS_TRACE();
 
-			if (!this->ready)
-			{
-				return;
-			}
+			MS_ASSERT(this->ready, "not ready");
 
 			this->ready = false;
 
@@ -72,17 +72,15 @@ namespace RTC
 			}
 		}
 
-		bool AssociationDeferredListener::OnAssociationSendData(const uint8_t* data, size_t len)
+		bool AssociationListenerDeferrer::OnAssociationSendData(const uint8_t* data, size_t len)
 		{
 			MS_TRACE();
 
-			MS_ASSERT(this->ready, "not ready");
-
 			// Will not be deferred but called directly.
 			return this->innerListener->OnAssociationSendData(data, len);
 		}
 
-		void AssociationDeferredListener::OnAssociationConnecting()
+		void AssociationListenerDeferrer::OnAssociationConnecting()
 		{
 			MS_TRACE();
 
@@ -96,7 +94,7 @@ namespace RTC
 			  std::monostate{});
 		}
 
-		void AssociationDeferredListener::OnAssociationConnected()
+		void AssociationListenerDeferrer::OnAssociationConnected()
 		{
 			MS_TRACE();
 
@@ -110,7 +108,7 @@ namespace RTC
 			  std::monostate{});
 		}
 
-		void AssociationDeferredListener::OnAssociationFailed(
+		void AssociationListenerDeferrer::OnAssociationFailed(
 		  Types::ErrorKind errorKind, std::string_view errorMessage)
 		{
 			MS_TRACE();
@@ -126,7 +124,7 @@ namespace RTC
 			  Error{ .errorKind = errorKind, .message = std::string(errorMessage) });
 		}
 
-		void AssociationDeferredListener::OnAssociationClosed(
+		void AssociationListenerDeferrer::OnAssociationClosed(
 		  Types::ErrorKind errorKind, std::string_view errorMessage)
 		{
 			MS_TRACE();
@@ -142,7 +140,7 @@ namespace RTC
 			  Error{ .errorKind = errorKind, .message = std::string(errorMessage) });
 		}
 
-		void AssociationDeferredListener::OnAssociationRestarted()
+		void AssociationListenerDeferrer::OnAssociationRestarted()
 		{
 			MS_TRACE();
 
@@ -156,7 +154,7 @@ namespace RTC
 			  std::monostate{});
 		}
 
-		void AssociationDeferredListener::OnAssociationError(
+		void AssociationListenerDeferrer::OnAssociationError(
 		  Types::ErrorKind errorKind, std::string_view errorMessage)
 		{
 			MS_TRACE();
@@ -172,7 +170,7 @@ namespace RTC
 			  Error{ .errorKind = errorKind, .message = std::string(errorMessage) });
 		}
 
-		void AssociationDeferredListener::OnAssociationMessageReceived(Message message)
+		void AssociationListenerDeferrer::OnAssociationMessageReceived(Message message)
 		{
 			MS_TRACE();
 
@@ -186,7 +184,7 @@ namespace RTC
 			  std::move(message));
 		}
 
-		void AssociationDeferredListener::OnAssociationStreamsResetPerformed(
+		void AssociationListenerDeferrer::OnAssociationStreamsResetPerformed(
 		  std::span<const uint16_t> outboundStreamIds)
 		{
 			MS_TRACE();
@@ -202,7 +200,7 @@ namespace RTC
 			  StreamReset{ .streamIds = { outboundStreamIds.begin(), outboundStreamIds.end() } });
 		}
 
-		void AssociationDeferredListener::OnAssociationStreamsResetFailed(
+		void AssociationListenerDeferrer::OnAssociationStreamsResetFailed(
 		  std::span<const uint16_t> outboundStreamIds, std::string_view errorMessage)
 		{
 			MS_TRACE();
@@ -219,7 +217,7 @@ namespace RTC
 			               .errorMessage = std::string(errorMessage) });
 		}
 
-		void AssociationDeferredListener::OnAssociationInboundStreamsReset(
+		void AssociationListenerDeferrer::OnAssociationInboundStreamsReset(
 		  std::span<const uint16_t> inboundStreamIds)
 		{
 			MS_TRACE();
@@ -235,9 +233,10 @@ namespace RTC
 			  StreamReset{ .streamIds = { inboundStreamIds.begin(), inboundStreamIds.end() } });
 		}
 
-		void AssociationDeferredListener::OnAssociationStreamBufferedAmountLow(uint16_t streamId)
+		void AssociationListenerDeferrer::OnAssociationStreamBufferedAmountLow(uint16_t streamId)
 		{
 			MS_TRACE();
+			;
 
 			MS_ASSERT(this->ready, "not ready");
 
@@ -249,7 +248,7 @@ namespace RTC
 			  streamId);
 		}
 
-		void AssociationDeferredListener::OnAssociationTotalBufferedAmountLow()
+		void AssociationListenerDeferrer::OnAssociationTotalBufferedAmountLow()
 		{
 			MS_TRACE();
 
@@ -262,5 +261,14 @@ namespace RTC
 			  },
 			  std::monostate{});
 		}
+
+		bool AssociationListenerDeferrer::OnAssociationIsTransportReadyForSctp()
+		{
+			MS_TRACE();
+			;
+
+			// Will not be deferred but called directly.
+			return this->innerListener->OnAssociationIsTransportReadyForSctp();
+		}
 	} // namespace SCTP
 } // namespace RTC

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

@@ -0,0 +1,244 @@
+#define MS_CLASS "RTC::SCTP::HeartbeatHandler"
+// TODO: SCTP: COMMENT
+#define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/SCTP/association/HeartbeatHandler.hpp"
+#include "DepLibUV.hpp"
+#include "Logger.hpp"
+#include "Utils.hpp"
+#include "RTC/SCTP/packet/parameters/HeartbeatInfoParameter.hpp"
+#include "RTC/SCTP/public/SctpTypes.hpp"
+#include <string>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/* Static. */
+
+		static constexpr int HeartbeatInfoLength{ 8 };
+
+		/* Instance methods. */
+
+		HeartbeatHandler::HeartbeatHandler(
+		  AssociationListener& associationListener, const SctpOptions& sctpOptions, TCBContext* tcbContext)
+		  : associationListener(associationListener),
+		    sctpOptions(sctpOptions),
+		    tcbContext(tcbContext),
+		    intervalDurationMs(sctpOptions.heartbeatIntervalMs),
+		    intervalDurationShouldIncludeRtt(sctpOptions.heartbeatIntervalIncludeRtt),
+		    intervalTimer(
+		      std::make_unique<BackoffTimerHandle>(
+		        /*listener*/ this,
+		        /*baseTimeoutMs*/ sctpOptions.initialRtoMs,
+		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::EXPONENTIAL,
+		        /*maxBackoffTimeoutMs*/ sctpOptions.timerMaxBackoffTimeoutMs,
+		        /*maxRestarts*/ std::nullopt)),
+		    timeoutTimer(
+		      std::make_unique<BackoffTimerHandle>(
+		        /*listener*/ this,
+		        /*baseTimeoutMs*/ sctpOptions.initialRtoMs,
+		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::FIXED,
+		        /*maxBackoffTimeoutMs*/ std::nullopt,
+		        /*maxRestarts*/ 0))
+		{
+			MS_TRACE();
+		}
+
+		HeartbeatHandler::~HeartbeatHandler()
+		{
+			MS_TRACE();
+		}
+
+		void HeartbeatHandler::RestartTimer()
+		{
+			MS_TRACE();
+
+			// Heartbeating has been disabled.
+			if (this->intervalDurationMs == 0)
+			{
+				return;
+			}
+
+			if (intervalDurationShouldIncludeRtt)
+			{
+				this->intervalTimer->SetBaseTimeoutMs(
+				  this->intervalDurationMs + this->tcbContext->GetCurrentRtoMs());
+			}
+			else
+			{
+				this->intervalTimer->SetBaseTimeoutMs(this->intervalDurationMs);
+			}
+
+			this->intervalTimer->Start();
+		}
+
+		void HeartbeatHandler::HandleReceivedHeartbeatRequestChunk(
+		  const HeartbeatRequestChunk* receivedHeartbeatRequestChunk)
+		{
+			MS_TRACE();
+
+			// https://datatracker.ietf.org/doc/html/rfc9260#section-8.3
+			//
+			// "The receiver of the HEARTBEAT chunk SHOULD immediately respond with a
+			// HEARTBEAT ACK chunk that contains the Heartbeat Information TLV,
+			// together with any other received TLVs, copied unchanged from the
+			// received HEARTBEAT chunk."
+			auto packet             = this->tcbContext->CreatePacket();
+			auto* heartbeatAckChunk = packet->BuildChunkInPlace<HeartbeatAckChunk>();
+
+			// Here we have to extract all Parameters from receivedHeartbeatRequestChunk
+			// and add them into heartbeatAckChunk.
+			for (auto it = receivedHeartbeatRequestChunk->ParametersBegin();
+			     it != receivedHeartbeatRequestChunk->ParametersEnd();
+			     ++it)
+			{
+				const auto* parameter = *it;
+
+				heartbeatAckChunk->AddParameter(parameter);
+			}
+
+			heartbeatAckChunk->Consolidate();
+
+			this->tcbContext->Send(packet.get());
+		}
+
+		void HeartbeatHandler::HandleReceivedHeartbeatAckChunk(
+		  const HeartbeatAckChunk* receivedHeartbeatAckChunk)
+		{
+			MS_TRACE();
+
+			this->timeoutTimer->Stop();
+
+			const auto* heartbeatInfoParameter =
+			  receivedHeartbeatAckChunk->GetFirstParameterOfType<HeartbeatInfoParameter>();
+
+			if (!heartbeatInfoParameter)
+			{
+				this->associationListener.OnAssociationError(
+				  Types::ErrorKind::PARSE_FAILED,
+				  "ignoring HEARTBEAT_ACK chunk without Heartbeat Info parameter");
+
+				return;
+			}
+
+			const auto* info       = heartbeatInfoParameter->GetInfo();
+			const uint16_t infoLen = heartbeatInfoParameter->GetInfoLength();
+
+			if (!info)
+			{
+				this->associationListener.OnAssociationError(
+				  Types::ErrorKind::PARSE_FAILED, "ignoring Heartbeat Info parameter without info field");
+
+				return;
+			}
+			else if (infoLen != HeartbeatInfoLength)
+			{
+				this->associationListener.OnAssociationError(
+				  Types::ErrorKind::PARSE_FAILED, "ignoring Heartbeat Info parameter with wrong length");
+
+				return;
+			}
+
+			const uint64_t createdAtMs = Utils::Byte::Get8Bytes(info, 0);
+			const uint64_t nowMs       = DepLibUV::GetTimeMs();
+
+			if (createdAtMs > 0 && createdAtMs <= nowMs)
+			{
+				const uint64_t rtt = nowMs - createdAtMs;
+
+				MS_DEBUG_DEV("valid HEARTBEAT_ACK Chunk received, calling ObserveRtt(%" PRIu64 ")", rtt);
+
+				this->tcbContext->ObserveRtt(rtt);
+			}
+			else
+			{
+				MS_WARN_DEV(
+				  "ignoring received HEARTBEAT_ACK Chunk with invalid info content [createdAtMs:%" PRIu64
+				  ", nowMs:%" PRIu64 "]",
+				  createdAtMs,
+				  nowMs);
+			}
+
+			// https://datatracker.ietf.org/doc/html/rfc9260#section-8.1
+			//
+			// "When a HEARTBEAT ACK chunk is received from the peer endpoint, the
+			// counter SHOULD also be reset."
+			this->tcbContext->ClearTxErrorCounter();
+		}
+
+		void HeartbeatHandler::OnIntervalTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
+		{
+			MS_TRACE();
+
+			if (!this->tcbContext->IsAssociationEstablished())
+			{
+				MS_DEBUG_DEV("won't send HEARTBEAT_REQUEST when SCTP Association is not established");
+
+				return;
+			}
+
+			const auto maxRestarts = this->intervalTimer->GetMaxRestarts();
+
+			MS_DEBUG_TAG(
+			  sctp,
+			  "interval timer has expired %zu/%s]",
+			  this->intervalTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
+			this->timeoutTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoMs());
+			this->timeoutTimer->Start();
+
+			alignas(8) uint8_t info[HeartbeatInfoLength];
+			const uint64_t nowMs = DepLibUV::GetTimeMs();
+
+			Utils::Byte::Set8Bytes(info, 0, nowMs);
+
+			auto packet                 = this->tcbContext->CreatePacket();
+			auto* heartbeatRequestChunk = packet->BuildChunkInPlace<HeartbeatRequestChunk>();
+			auto* heartbeatInfoParameter =
+			  heartbeatRequestChunk->BuildParameterInPlace<HeartbeatInfoParameter>();
+
+			heartbeatInfoParameter->SetInfo(info, HeartbeatInfoLength);
+			heartbeatInfoParameter->Consolidate();
+			heartbeatRequestChunk->Consolidate();
+
+			MS_DEBUG_DEV("sending HEARTBEAT_REQUEST Chunk with info content [nowMs:%" PRIu64 "]", nowMs);
+
+			this->tcbContext->Send(packet.get());
+		}
+
+		void HeartbeatHandler::OnTimeoutTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
+		{
+			MS_TRACE();
+
+			const auto maxRestarts = this->timeoutTimer->GetMaxRestarts();
+
+			MS_DEBUG_TAG(
+			  sctp,
+			  "timeout timer has expired %zu/%s]",
+			  this->timeoutTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
+			// 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");
+		}
+
+		void HeartbeatHandler::OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		{
+			MS_TRACE();
+
+			if (backoffTimer == this->intervalTimer.get())
+			{
+				OnIntervalTimer(baseTimeoutMs, stop);
+			}
+			else if (backoffTimer == this->timeoutTimer.get())
+			{
+				OnTimeoutTimer(baseTimeoutMs, stop);
+			}
+		}
+	} // namespace SCTP
+} // namespace RTC

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

@@ -27,11 +27,11 @@ namespace RTC
 			const auto* remoteZeroChecksumAcceptableParameter =
 			  remoteChunk->template GetFirstParameterOfType<ZeroChecksumAcceptableParameter>();
 
-			negotiatedCapabilities.maxOutboundStreams =
-			  std::min(sctpOptions.maxOutboundStreams, remoteChunk->GetNumberOfInboundStreams());
+			negotiatedCapabilities.negotiatedMaxOutboundStreams =
+			  std::min(sctpOptions.announcedMaxOutboundStreams, remoteChunk->GetNumberOfInboundStreams());
 
-			negotiatedCapabilities.maxInboundStreams =
-			  std::min(sctpOptions.maxInboundStreams, remoteChunk->GetNumberOfOutboundStreams());
+			negotiatedCapabilities.negotiatedMaxInboundStreams =
+			  std::min(sctpOptions.announcedMaxInboundStreams, remoteChunk->GetNumberOfOutboundStreams());
 
 			// Partial Reliability Extension is negotiated if we desire it and
 			// peer announces support via Forward-TSN-Supported Parameter or via
@@ -75,8 +75,10 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP_CLEAN(indentation, "<SCTP::NegotiatedCapabilities>");
-			MS_DUMP_CLEAN(indentation, "  max outbound streams: %" PRIu16, this->maxOutboundStreams);
-			MS_DUMP_CLEAN(indentation, "  max inbound streams: %" PRIu16, this->maxInboundStreams);
+			MS_DUMP_CLEAN(
+			  indentation, "  negotiated max outbound streams: %" PRIu16, this->negotiatedMaxOutboundStreams);
+			MS_DUMP_CLEAN(
+			  indentation, "  negotiated max inbound streams: %" PRIu16, this->negotiatedMaxInboundStreams);
 			MS_DUMP_CLEAN(indentation, "  partial reliability: %s", this->partialReliability ? "yes" : "no");
 			MS_DUMP_CLEAN(
 			  indentation, "  message interleaving: %s", this->messageInterleaving ? "yes" : "no");

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

@@ -8,7 +8,7 @@ namespace RTC
 {
 	namespace SCTP
 	{
-		PacketSender::PacketSender(Listener& listener, AssociationListener& associationListener)
+		PacketSender::PacketSender(Listener* listener, AssociationListener& associationListener)
 		  : listener(listener), associationListener(associationListener)
 		{
 			MS_TRACE();
@@ -38,7 +38,12 @@ namespace RTC
 			const bool sent =
 			  this->associationListener.OnAssociationSendData(packet->GetBuffer(), packet->GetLength());
 
-			this->listener.OnPacketSenderPacketSent(this, packet, sent);
+			this->listener->OnPacketSenderPacketSent(this, packet, sent);
+
+			if (!sent)
+			{
+				MS_WARN_TAG(sctp, "coudln't send SCTP Packet");
+			}
 
 			return sent;
 		}

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

@@ -115,10 +115,10 @@ namespace RTC
 			negotiatedCapabilitiesField->bitC     = negotiatedCapabilities.reConfig;
 			negotiatedCapabilitiesField->bitD     = negotiatedCapabilities.zeroChecksum;
 			negotiatedCapabilitiesField->magic2   = htons(StateCookie::Magic2);
-			negotiatedCapabilitiesField->maxOutboundStreams =
-			  htons(negotiatedCapabilities.maxOutboundStreams);
-			negotiatedCapabilitiesField->maxInboundStreams =
-			  htons(negotiatedCapabilities.maxInboundStreams);
+			negotiatedCapabilitiesField->negotiatedMaxOutboundStreams =
+			  htons(negotiatedCapabilities.negotiatedMaxOutboundStreams);
+			negotiatedCapabilitiesField->negotiatedMaxInboundStreams =
+			  htons(negotiatedCapabilities.negotiatedMaxInboundStreams);
 		}
 
 		Types::SctpImplementation StateCookie::DetermineSctpImplementation(
@@ -206,10 +206,10 @@ namespace RTC
 
 			NegotiatedCapabilities negotiatedCapabilities;
 
-			negotiatedCapabilities.maxOutboundStreams =
-			  ntohs(negotiatedCapabilitiesField->maxOutboundStreams);
-			negotiatedCapabilities.maxInboundStreams =
-			  ntohs(negotiatedCapabilitiesField->maxInboundStreams);
+			negotiatedCapabilities.negotiatedMaxOutboundStreams =
+			  ntohs(negotiatedCapabilitiesField->negotiatedMaxOutboundStreams);
+			negotiatedCapabilities.negotiatedMaxInboundStreams =
+			  ntohs(negotiatedCapabilitiesField->negotiatedMaxInboundStreams);
 			negotiatedCapabilities.partialReliability  = negotiatedCapabilitiesField->bitA;
 			negotiatedCapabilities.messageInterleaving = negotiatedCapabilitiesField->bitB;
 			negotiatedCapabilities.reConfig            = negotiatedCapabilitiesField->bitC;