mediasoup 3.19.21 → 3.19.22

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

@@ -6,6 +6,9 @@
 #include "DepLibUV.hpp"
 #include "Logger.hpp"
 #include "RTC/Consts.hpp"
+#include "RTC/SCTP/packet/chunks/DataChunk.hpp"
+#include "RTC/SCTP/packet/chunks/IDataChunk.hpp"
+#include "handles/BackoffTimerHandle.hpp"
 #include <cmath> // std::min()
 #include <string>
 
@@ -22,7 +25,10 @@ namespace RTC
 		TransmissionControlBlock::TransmissionControlBlock(
 		  AssociationListener& associationListener,
 		  const SctpOptions& sctpOptions,
+		  SharedInterface* shared,
 		  PacketSender& packetSender,
+		  // TODO: SCTP: Implement it.
+		  // SendQueue& sendQueue,
 		  uint32_t localVerificationTag,
 		  uint32_t remoteVerificationTag,
 		  uint32_t localInitialTsn,
@@ -33,6 +39,9 @@ namespace RTC
 		  std::function<bool()> isAssociationEstablished)
 		  : associationListener(associationListener),
 		    sctpOptions(sctpOptions),
+		    shared(shared),
+		    // TODO: SCTP: Implement it.
+		    // sendQueue(sendQueue),
 		    packetSender(packetSender),
 		    localVerificationTag(localVerificationTag),
 		    remoteVerificationTag(remoteVerificationTag),
@@ -42,23 +51,46 @@ namespace RTC
 		    tieTag(tieTag),
 		    negotiatedCapabilities(negotiatedCapabilities),
 		    isAssociationEstablished(std::move(isAssociationEstablished)),
-		    t3RtxTimer(
-		      std::make_unique<BackoffTimerHandle>(
-		        /*listener*/ this,
-		        /*baseTimeoutMs*/ sctpOptions.initialRtoMs,
-		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::EXPONENTIAL,
-		        /*maxBackoffTimeoutMs*/ sctpOptions.timerMaxBackoffTimeoutMs,
-		        /*maxRestarts*/ std::nullopt)),
-		    delayedAckTimer(
-		      std::make_unique<BackoffTimerHandle>(
-		        /*listener*/ this,
-		        /*baseTimeoutMs*/ sctpOptions.delayedAckMaxTimeoutMs,
-		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::EXPONENTIAL,
-		        /*maxBackoffTimeoutMs*/ std::nullopt,
-		        /*maxRestarts*/ 0)),
+		    t3RtxTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .baseTimeoutMs       = sctpOptions.initialRtoMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
+		        .maxRestarts         = std::nullopt })),
+		    delayedAckTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .baseTimeoutMs       = sctpOptions.delayedAckMaxTimeoutMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = std::nullopt,
+		        .maxRestarts         = 0 })),
 		    rto(sctpOptions),
 		    txErrorCounter(sctpOptions),
-		    heartbeatHandler(this->associationListener, sctpOptions, this)
+		    // TODO: SCTP: Implement.
+		    // dataTracker(),
+		    // TODO: SCTP: Implement.
+		    // reassemblyQueue(),
+		    retransmissionQueue(
+		      this,
+		      this->associationListener,
+		      localInitialTsn,
+		      remoteAdvertisedReceiverWindowCredit,
+		      // TODO: SCTP: Implement
+		      // this->sendQueue,
+		      this->t3RtxTimer.get(),
+		      sctpOptions,
+		      negotiatedCapabilities.partialReliability,
+		      negotiatedCapabilities.messageInterleaving),
+		    streamResetHandler(
+		      this->associationListener,
+		      this->shared,
+		      this,
+		      // TODO: SCTP: Implement.
+		      // std::addressof(this->dataTracker),
+		      // std::addressof(this->reassemblyQueue),
+		      std::addressof(this->retransmissionQueue)),
+		    heartbeatHandler(this->associationListener, sctpOptions, this->shared, this)
 		{
 			MS_TRACE();
 		}
@@ -93,7 +125,7 @@ namespace RTC
 			MS_DUMP_CLEAN(indentation, "</SCTP::TransmissionControlBlock>");
 		}
 
-		void TransmissionControlBlock::ObserveRtt(uint64_t rtt)
+		void TransmissionControlBlock::ObserveRttMs(uint64_t rttMs)
 		{
 			MS_TRACE();
 
@@ -101,11 +133,11 @@ namespace RTC
 			const auto prevRtoMs = this->rto.GetRtoMs();
 #endif
 
-			this->rto.ObserveRtt(rtt);
+			this->rto.ObserveRttMs(rttMs);
 
 			MS_DEBUG_DEV(
 			  "new rtt:%" PRIu64 ", previous rto:%" PRIu64 ", new rto:%" PRIu64 ", srtt:%" PRIu64,
-			  rtt,
+			  rttMs,
 			  prevRtoMs,
 			  this->rto.GetRtoMs(),
 			  this->rto.GetSrttMs());
@@ -182,6 +214,80 @@ namespace RTC
 			// Send(packet.get());
 		}
 
+		void TransmissionControlBlock::MaybeSendForwardTsnChunk(Packet* packet, uint64_t nowMs)
+		{
+			MS_TRACE();
+
+			if (nowMs >= this->limitForwardTsnUntilMs && this->retransmissionQueue.ShouldSendForwardTsn(nowMs))
+			{
+				if (this->negotiatedCapabilities.messageInterleaving)
+				{
+					this->retransmissionQueue.CreateIForwardTsn(packet);
+				}
+				else
+				{
+					this->retransmissionQueue.CreateForwardTsn(packet);
+				}
+
+				// https://datatracker.ietf.org/doc/html/rfc3758
+				//
+				// "IMPLEMENTATION NOTE: An implementation may wish to limit the number
+				// of duplicate FORWARD TSN chunks it sends by ... waiting a full RTT
+				// before sending a duplicate FORWARD TSN."
+				// "Any delay applied to the sending of FORWARD TSN chunk SHOULD NOT
+				// exceed 200ms and MUST NOT exceed 500ms".
+				this->limitForwardTsnUntilMs = nowMs + std::min(uint64_t{ 200 }, this->rto.GetSrttMs());
+			}
+		}
+
+		void TransmissionControlBlock::MaySendFastRetransmit()
+		{
+			MS_TRACE();
+
+			if (!this->retransmissionQueue.HasDataToBeFastRetransmitted())
+			{
+				return;
+			}
+
+			// https://datatracker.ietf.org/doc/html/rfc9260#section-7.2.4
+			//
+			// "Determine how many of the earliest (i.e., lowest TSN) DATA chunks
+			// marked for retransmission will fit into a single packet, subject to
+			// constraint of the path MTU of the destination transport address to
+			// which the packet is being sent. Call this value K. Retransmit those
+			// K DATA chunks in a single packet.  When a Fast Retransmit is being
+			// performed, the sender SHOULD ignore the value of cwnd and SHOULD NOT
+			// delay retransmission for this single packet."
+
+			auto packet = CreatePacket();
+			const auto result =
+			  this->retransmissionQueue.GetChunksForFastRetransmit(packet->GetAvailableLength());
+
+			for (const auto& [tsn, data] : result)
+			{
+				if (this->negotiatedCapabilities.messageInterleaving)
+				{
+					auto* iDataChunk = packet->BuildChunkInPlace<IDataChunk>();
+
+					iDataChunk->SetTsn(tsn);
+					// TODO: SCTP: Implement.
+					// iDataChunk->SetUserData(data);
+					iDataChunk->Consolidate();
+				}
+				else
+				{
+					auto* dataChunk = packet->BuildChunkInPlace<DataChunk>();
+
+					dataChunk->SetTsn(tsn);
+					// TODO: SCTP: Implement.
+					// dataChunk->SetUserData(data);
+					dataChunk->Consolidate();
+				}
+			}
+
+			Send(packet.get());
+		}
+
 		void TransmissionControlBlock::OnT3RtxTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
 		{
 			MS_TRACE();
@@ -190,7 +296,7 @@ namespace RTC
 
 			MS_DEBUG_TAG(
 			  sctp,
-			  "T3-rtx timer has expired %zu/%s]",
+			  "T3-rtx timer has expired [%zu/%s]",
 			  this->t3RtxTimer->GetExpirationCount(),
 			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
 
@@ -204,13 +310,12 @@ namespace RTC
 			{
 				if (IncrementTxErrorCounter("t3-rtx expired"))
 				{
-					// TODO: SCTP: Implement
-					// this->retransmissionQueue.HandleT3RtxTimerExpiry();
+					this->retransmissionQueue.HandleT3RtxTimerExpiry();
 
-					// const uint64_t now = DepLibUV::GetTimeMs();
+					// const uint64_t nowMs = DepLibUV::GetTimeMs();
 
 					// TODO: SCTP: Implement
-					// SendBufferedPackets(now);
+					// SendBufferedPackets(nowMs);
 				}
 			}
 		}
@@ -223,7 +328,7 @@ namespace RTC
 
 			MS_DEBUG_TAG(
 			  sctp,
-			  "delayer ack timer has expired %zu/%s]",
+			  "delayer ack timer has expired [%zu/%s]",
 			  this->delayedAckTimer->GetExpirationCount(),
 			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
 
@@ -234,7 +339,7 @@ namespace RTC
 		}
 
 		void TransmissionControlBlock::OnTimer(
-		  BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();
 
@@ -247,5 +352,19 @@ namespace RTC
 				OnDelayedAckTimer(baseTimeoutMs, stop);
 			}
 		}
+
+		void TransmissionControlBlock::OnRetransmissionQueueNewRttMs(uint64_t newRttMs)
+		{
+			MS_TRACE();
+
+			ObserveRttMs(newRttMs);
+		}
+
+		void TransmissionControlBlock::OnRetransmissionQueueClearRetransmissionCounter()
+		{
+			MS_TRACE();
+
+			this->txErrorCounter.Clear();
+		}
 	} // namespace SCTP
 } // namespace RTC

package/worker/src/RTC/SCTP/packet/chunks/ForwardTsnChunk.cpp

@@ -161,7 +161,7 @@ namespace RTC
 			return skippedStreams;
 		}
 
-		void ForwardTsnChunk::AddStream(uint16_t stream, uint16_t streamSequence)
+		void ForwardTsnChunk::AddStream(uint16_t streamId, uint16_t streamSequence)
 		{
 			MS_TRACE();
 
@@ -172,7 +172,7 @@ namespace RTC
 
 			// Add the new stream and stream sequence.
 			Utils::Byte::Set2Bytes(
-			  GetVariableLengthValuePointer(), previousVariableLengthValueLength, stream);
+			  GetVariableLengthValuePointer(), previousVariableLengthValueLength, streamId);
 			Utils::Byte::Set2Bytes(
 			  GetVariableLengthValuePointer(), previousVariableLengthValueLength + 2, streamSequence);
 		}

package/worker/src/RTC/SCTP/packet/chunks/IForwardTsnChunk.cpp

@@ -162,7 +162,7 @@ namespace RTC
 			return skippedStreams;
 		}
 
-		void IForwardTsnChunk::AddStream(uint16_t stream, bool uFlag, uint32_t messageIdentifier)
+		void IForwardTsnChunk::AddStream(uint16_t streamId, bool uFlag, uint32_t messageIdentifier)
 		{
 			MS_TRACE();
 
@@ -173,7 +173,7 @@ namespace RTC
 
 			// Add the new stream, flag U and message identifier.
 			Utils::Byte::Set2Bytes(
-			  GetVariableLengthValuePointer(), previousVariableLengthValueLength, stream);
+			  GetVariableLengthValuePointer(), previousVariableLengthValueLength, streamId);
 			Utils::Byte::Set2Bytes(
 			  GetVariableLengthValuePointer(), previousVariableLengthValueLength + 2, uFlag);
 			Utils::Byte::Set4Bytes(