mediasoup 3.19.21 → 3.20.0

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

@@ -1,12 +1,13 @@
 #define MS_CLASS "RTC::SCTP::TransmissionControlBlock"
-// TODO: SCTP: COMMENT
-#define MS_LOG_DEV_LEVEL 3
+// #define MS_LOG_DEV_LEVEL 3
 
 #include "RTC/SCTP/association/TransmissionControlBlock.hpp"
-#include "DepLibUV.hpp"
 #include "Logger.hpp"
-#include "RTC/Consts.hpp"
-#include <cmath> // std::min()
+#include "MediaSoupErrors.hpp"
+#include "RTC/SCTP/packet/chunks/CookieAckChunk.hpp"
+#include "RTC/SCTP/packet/chunks/CookieEchoChunk.hpp"
+#include "RTC/SCTP/packet/chunks/DataChunk.hpp"
+#include "RTC/SCTP/packet/chunks/IDataChunk.hpp"
 #include <string>
 
 namespace RTC
@@ -15,13 +16,15 @@ namespace RTC
 	{
 		/* Static. */
 
-		alignas(4) thread_local static uint8_t PacketFactoryBuffer[RTC::Consts::MaxSafeMtuSizeForSctp];
+		alignas(4) static thread_local uint8_t PacketFactoryBuffer[65536];
 
 		/* Instance methods. */
 
 		TransmissionControlBlock::TransmissionControlBlock(
-		  AssociationListener& associationListener,
+		  AssociationListenerInterface& associationListener,
 		  const SctpOptions& sctpOptions,
+		  SharedInterface* shared,
+		  SendQueueInterface& sendQueue,
 		  PacketSender& packetSender,
 		  uint32_t localVerificationTag,
 		  uint32_t remoteVerificationTag,
@@ -30,9 +33,11 @@ namespace RTC
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
 		  const NegotiatedCapabilities& negotiatedCapabilities,
+		  size_t maxPacketLength,
 		  std::function<bool()> isAssociationEstablished)
 		  : associationListener(associationListener),
 		    sctpOptions(sctpOptions),
+		    shared(shared),
 		    packetSender(packetSender),
 		    localVerificationTag(localVerificationTag),
 		    remoteVerificationTag(remoteVerificationTag),
@@ -41,26 +46,51 @@ namespace RTC
 		    remoteAdvertisedReceiverWindowCredit(remoteAdvertisedReceiverWindowCredit),
 		    tieTag(tieTag),
 		    negotiatedCapabilities(negotiatedCapabilities),
+		    maxPacketLength(maxPacketLength),
 		    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,
+		        .label               = "sctp-t3-rtx",
+		        .baseTimeoutMs       = sctpOptions.initialRtoMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
+		        .maxRestarts         = std::nullopt })),
+		    delayedAckTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .label               = "sctp-delayed-ack",
+		        .baseTimeoutMs       = sctpOptions.delayedAckMaxTimeoutMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = std::nullopt,
+		        .maxRestarts         = 0 })),
 		    rto(sctpOptions),
 		    txErrorCounter(sctpOptions),
-		    heartbeatHandler(this->associationListener, sctpOptions, this)
+		    dataTracker(this->delayedAckTimer.get(), remoteInitialTsn),
+		    reassemblyQueue(
+		      sctpOptions.maxReceiverWindowBufferSize, negotiatedCapabilities.messageInterleaving),
+		    retransmissionQueue(
+		      this,
+		      this->associationListener,
+		      localInitialTsn,
+		      remoteAdvertisedReceiverWindowCredit,
+		      sendQueue,
+		      this->t3RtxTimer.get(),
+		      sctpOptions,
+		      negotiatedCapabilities.partialReliability,
+		      negotiatedCapabilities.messageInterleaving),
+		    streamResetHandler(
+		      this->associationListener,
+		      this->shared,
+		      this,
+		      std::addressof(this->dataTracker),
+		      std::addressof(this->reassemblyQueue),
+		      std::addressof(this->retransmissionQueue)),
+		    heartbeatHandler(this->associationListener, sctpOptions, this->shared, this)
 		{
 			MS_TRACE();
+
+			sendQueue.EnableMessageInterleaving(this->negotiatedCapabilities.messageInterleaving);
 		}
 
 		TransmissionControlBlock::~TransmissionControlBlock()
@@ -93,7 +123,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 +131,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());
@@ -131,7 +161,7 @@ namespace RTC
 			MS_TRACE();
 
 			auto packet =
-			  std::unique_ptr<Packet>(Packet::Factory(PacketFactoryBuffer, sizeof(PacketFactoryBuffer)));
+			  std::unique_ptr<Packet>{ Packet::Factory(PacketFactoryBuffer, this->maxPacketLength) };
 
 			packet->SetSourcePort(this->sctpOptions.sourcePort);
 			packet->SetDestinationPort(this->sctpOptions.destinationPort);
@@ -140,11 +170,11 @@ namespace RTC
 			return packet;
 		}
 
-		void TransmissionControlBlock::Send(Packet* packet)
+		bool TransmissionControlBlock::SendPacket(Packet* packet)
 		{
 			MS_TRACE();
 
-			this->packetSender.SendPacket(
+			return this->packetSender.SendPacket(
 			  packet,
 			  /*writeChecksum*/ !this->negotiatedCapabilities.zeroChecksum);
 		}
@@ -167,32 +197,219 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			// TODO: SCTP: Implement it.
-			// if (!this->dataTracker.ShouldSendAckChunk(/*alsoIfDelayed*/ false))
-			// {
-			// 	return;
-			// }
+			if (!this->dataTracker.ShouldSendAck(/*alsoIfDelayed*/ false))
+			{
+				return;
+			}
 
-			// auto packet = CreatePacket();
+			const auto packet = CreatePacket();
 
-			// TODO: SCTP: Here we must create a SackChunk in the Packet, however the
-			// SackChunk is in theory generated by this->dataTracker... Let's see.
-			// builder.Add(this->dataTracker.CreateSelectiveAck(this->reassemblyQueue.GetRemainingBytes()));
+			this->dataTracker.AddSackSelectiveAck(packet.get(), this->reassemblyQueue.GetRemainingBytes());
 
-			// Send(packet.get());
+			SendPacket(packet.get());
 		}
 
-		void TransmissionControlBlock::OnT3RtxTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
+		void TransmissionControlBlock::MayAddForwardTsnChunk(Packet* packet, uint64_t nowMs)
 		{
 			MS_TRACE();
 
-			const auto maxRestarts = this->t3RtxTimer->GetMaxRestarts();
+			if (nowMs >= this->limitForwardTsnUntilMs && this->retransmissionQueue.ShouldSendForwardTsn(nowMs))
+			{
+				if (this->negotiatedCapabilities.messageInterleaving)
+				{
+					this->retransmissionQueue.AddIForwardTsn(packet);
+				}
+				else
+				{
+					this->retransmissionQueue.AddForwardTsn(packet);
+				}
 
-			MS_DEBUG_TAG(
-			  sctp,
-			  "T3-rtx timer has expired %zu/%s]",
-			  this->t3RtxTimer->GetExpirationCount(),
-			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+				// 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."
+
+			const auto packet = CreatePacket();
+
+			auto result =
+			  this->retransmissionQueue.GetChunksForFastRetransmit(packet->GetAvailableLength());
+
+			for (auto& [tsn, data] : result)
+			{
+				if (this->negotiatedCapabilities.messageInterleaving)
+				{
+					auto* iDataChunk = packet->BuildChunkInPlace<IDataChunk>();
+
+					iDataChunk->SetTsn(tsn);
+					iDataChunk->SetUserData(std::move(data));
+					iDataChunk->Consolidate();
+				}
+				else
+				{
+					auto* dataChunk = packet->BuildChunkInPlace<DataChunk>();
+
+					dataChunk->SetTsn(tsn);
+					dataChunk->SetUserData(std::move(data));
+					dataChunk->Consolidate();
+				}
+			}
+
+			SendPacket(packet.get());
+		}
+
+		void TransmissionControlBlock::SendBufferedPackets(uint64_t nowMs, bool addCookieAckChunk)
+		{
+			MS_TRACE();
+
+			for (size_t packetIdx{ 0 }; packetIdx < this->sctpOptions.maxBurst; ++packetIdx)
+			{
+				const auto packet = CreatePacket();
+
+				// Only add control Chunks to the first Packet that is sent, if sending
+				// multiple Packets in one go (as allowed by the congestion window).
+				if (packetIdx == 0)
+				{
+					if (addCookieAckChunk)
+					{
+						MS_DEBUG_DEV("adding COOKIE_ACK Chunk to the Packet");
+
+						const auto* cookieAckChunk = packet->BuildChunkInPlace<CookieAckChunk>();
+
+						cookieAckChunk->Consolidate();
+					}
+
+					if (this->remoteStateCookie.has_value())
+					{
+						// https://datatracker.ietf.org/doc/html/rfc9260#section-5.1
+						//
+						// "The COOKIE ECHO chunk can be bundled with any pending outbound
+						// DATA chunks, but it MUST be the first chunk in the packet..."
+						if (packet->GetChunksCount() > 0)
+						{
+							MS_THROW_ERROR(
+							  "Packet must have no Chunks [addCookieAckChunk:%s]",
+							  addCookieAckChunk ? "true" : "no");
+						}
+
+						auto* cookieEchoChunk = packet->BuildChunkInPlace<CookieEchoChunk>();
+
+						cookieEchoChunk->SetCookie(
+						  remoteStateCookie->data(), static_cast<uint16_t>(remoteStateCookie->size()));
+						cookieEchoChunk->Consolidate();
+					}
+
+					// https://datatracker.ietf.org/doc/html/rfc9260#section-6
+					//
+					// "Before an endpoint transmits a DATA chunk, if any received DATA
+					// chunks have not been acknowledged (e.g., due to delayed ack), the
+					// sender should create a SACK and bundle it with the outbound DATA
+					// chunk, as long as the size of the final SCTP packet does not exceed
+					// the current MTU."
+					if (this->dataTracker.ShouldSendAck(/*alsoIfDelayed*/ true))
+					{
+						this->dataTracker.AddSackSelectiveAck(
+						  packet.get(), this->reassemblyQueue.GetRemainingBytes());
+					}
+
+					const uint64_t nowMs = this->shared->GetTimeMs();
+
+					MayAddForwardTsnChunk(packet.get(), nowMs);
+
+					if (this->streamResetHandler.ShouldSendStreamResetRequest())
+					{
+						this->streamResetHandler.AddStreamResetRequest(packet.get());
+					}
+				}
+
+				auto chunksToSend =
+				  this->retransmissionQueue.GetChunksToSend(nowMs, packet->GetAvailableLength());
+
+				if (!chunksToSend.empty())
+				{
+					// https://datatracker.ietf.org/doc/html/rfc9260#section-8.3
+					//
+					// Sending DATA means that the path is not idle, restart heartbeat
+					// timer.
+					this->heartbeatHandler.RestartTimer();
+				}
+
+				const bool immediateAck =
+				  GetCwnd() < (this->sctpOptions.immediateSackUnderCwndMtus * this->sctpOptions.mtu);
+
+				for (auto& [tsn, data] : chunksToSend)
+				{
+					if (this->negotiatedCapabilities.messageInterleaving)
+					{
+						auto* iDataChunk = packet->BuildChunkInPlace<IDataChunk>();
+
+						iDataChunk->SetTsn(tsn);
+						iDataChunk->SetI(immediateAck);
+						iDataChunk->SetUserData(std::move(data));
+						iDataChunk->Consolidate();
+					}
+					else
+					{
+						auto* dataChunk = packet->BuildChunkInPlace<DataChunk>();
+
+						dataChunk->SetTsn(tsn);
+						dataChunk->SetI(immediateAck);
+						dataChunk->SetUserData(std::move(data));
+						dataChunk->Consolidate();
+					}
+				}
+
+				// https://datatracker.ietf.org/doc/html/rfc9653#section-5.2
+				//
+				// "When an end point sends a packet containing a COOKIE ECHO chunk, it
+				// MUST include a correct CRC32c checksum in the packet containing the
+				// COOKIE ECHO chunk."
+				if (!this->packetSender.SendPacket(
+				      packet.get(),
+				      /*writeChecksum*/ !negotiatedCapabilities.zeroChecksum ||
+				        this->remoteStateCookie.has_value()))
+				{
+					break;
+				}
+
+				// https://datatracker.ietf.org/doc/html/rfc9260#section-5.1
+				//
+				// "until the COOKIE ACK is returned the sender MUST NOT send any
+				// other packets to the peer."
+				if (this->remoteStateCookie.has_value())
+				{
+					break;
+				}
+			}
+		}
+
+		void TransmissionControlBlock::OnT3RtxTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
+		{
+			MS_TRACE();
 
 			// In the COOKIE_ECHO state, let the T1-COOKIE timer trigger
 			// retransmissions, to avoid having two timers doing that.
@@ -204,13 +421,11 @@ 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 = this->shared->GetTimeMs();
 
-					// TODO: SCTP: Implement
-					// SendBufferedPackets(now);
+					SendBufferedPackets(nowMs);
 				}
 			}
 		}
@@ -219,25 +434,25 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			const auto maxRestarts = this->delayedAckTimer->GetMaxRestarts();
-
-			MS_DEBUG_TAG(
-			  sctp,
-			  "delayer ack timer has expired %zu/%s]",
-			  this->delayedAckTimer->GetExpirationCount(),
-			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
-
-			// TODO: SCTP: Implement it.
-			// this->dataTracker.HandleDelayedAckTimerExpiry();
+			this->dataTracker.HandleDelayedAckTimerExpiry();
 
 			MaySendSackChunk();
 		}
 
-		void TransmissionControlBlock::OnTimer(
-		  BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		void TransmissionControlBlock::OnBackoffTimer(
+		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
 		{
 			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);
@@ -247,5 +462,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/Chunk.cpp

@@ -4,7 +4,6 @@
 #include "RTC/SCTP/packet/Chunk.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
-#include "Utils.hpp"
 #include "RTC/SCTP/packet/errorCauses/CookieReceivedWhileShuttingDownErrorCause.hpp"
 #include "RTC/SCTP/packet/errorCauses/InvalidMandatoryParameterErrorCause.hpp"
 #include "RTC/SCTP/packet/errorCauses/InvalidStreamIdentifierErrorCause.hpp"
@@ -36,6 +35,7 @@
 #include "RTC/SCTP/packet/parameters/UnknownParameter.hpp"
 #include "RTC/SCTP/packet/parameters/UnrecognizedParameterParameter.hpp"
 #include "RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp"
+#include "Utils.hpp"
 
 namespace RTC
 {
@@ -215,6 +215,10 @@ namespace RTC
 			MS_DUMP_CLEAN(
 			  indentation, "  flags: " MS_UINT8_TO_BINARY_PATTERN, MS_UINT8_TO_BINARY(GetFlags()));
 			TLV::DumpCommon(indentation);
+			MS_DUMP_CLEAN(
+			  indentation,
+			  "  needs consolidation of parameters or error causes: %s",
+			  NeedsConsolidation() ? "yes" : "no");
 		}
 
 		void Chunk::DumpParameters(int indentation) const

package/worker/src/RTC/SCTP/packet/Packet.cpp

@@ -4,7 +4,6 @@
 #include "RTC/SCTP/packet/Packet.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
-#include "Utils.hpp"
 #include "RTC/SCTP/packet/chunks/AbortAssociationChunk.hpp"
 #include "RTC/SCTP/packet/chunks/CookieAckChunk.hpp"
 #include "RTC/SCTP/packet/chunks/CookieEchoChunk.hpp"
@@ -23,6 +22,7 @@
 #include "RTC/SCTP/packet/chunks/ShutdownChunk.hpp"
 #include "RTC/SCTP/packet/chunks/ShutdownCompleteChunk.hpp"
 #include "RTC/SCTP/packet/chunks/UnknownChunk.hpp"
+#include "Utils.hpp"
 
 namespace RTC
 {
@@ -300,6 +300,8 @@ namespace RTC
 			MS_DUMP_CLEAN(indentation, "  verification tag: %" PRIu32, GetVerificationTag());
 			MS_DUMP_CLEAN(indentation, "  checksum: %" PRIu32, GetChecksum());
 			MS_DUMP_CLEAN(indentation, "  chunks count: %zu", GetChunksCount());
+			MS_DUMP_CLEAN(
+			  indentation, "  needs consolidation of chunks: %s", NeedsConsolidation() ? "yes" : "no");
 			for (const auto* chunk : this->chunks)
 			{
 				chunk->Dump(indentation + 1);
@@ -440,6 +442,11 @@ namespace RTC
 			  {
 				  try
 				  {
+					  if (chunk->NeedsConsolidation())
+					  {
+						  MS_THROW_ERROR("ongoing Chunk needs consolidation");
+					  }
+
 					  // Fix buffer length assigned to the Chunk.
 					  chunk->SetBufferLength(chunk->GetLength());
 

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

@@ -195,6 +195,23 @@ namespace RTC
 			SetVariableLengthValue(userDataPayload, userDataPayloadLength);
 		}
 
+		void DataChunk::SetUserData(UserData userData)
+		{
+			MS_TRACE();
+
+			SetStreamId(userData.GetStreamId());
+			SetStreamSequenceNumber(userData.GetStreamSequenceNumber());
+			SetPayloadProtocolId(userData.GetPayloadProtocolId());
+
+			SetB(userData.IsBeginning());
+			SetE(userData.IsEnd());
+			SetU(userData.IsUnordered());
+
+			const auto payload = std::move(userData).ReleasePayload();
+
+			SetUserDataPayload(payload.data(), payload.size());
+		}
+
 		DataChunk* DataChunk::SoftClone(const uint8_t* buffer) const
 		{
 			MS_TRACE();

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

@@ -155,13 +155,13 @@ namespace RTC
 
 			for (uint16_t idx{ 0 }; idx < numSkippedStreams; ++idx)
 			{
-				skippedStreams.emplace_back(GetStreamIdAt(idx), GetStreamSequenceAt(idx));
+				skippedStreams.emplace_back(GetSkippedStreamIdAt(idx), GetStreamSequenceAt(idx));
 			}
 
 			return skippedStreams;
 		}
 
-		void ForwardTsnChunk::AddStream(uint16_t stream, uint16_t streamSequence)
+		void ForwardTsnChunk::AddSkippedStream(const AnyForwardTsnChunk::SkippedStream& skippedStream)
 		{
 			MS_TRACE();
 
@@ -172,9 +172,9 @@ namespace RTC
 
 			// Add the new stream and stream sequence.
 			Utils::Byte::Set2Bytes(
-			  GetVariableLengthValuePointer(), previousVariableLengthValueLength, stream);
+			  GetVariableLengthValuePointer(), previousVariableLengthValueLength, skippedStream.streamId);
 			Utils::Byte::Set2Bytes(
-			  GetVariableLengthValuePointer(), previousVariableLengthValueLength + 2, streamSequence);
+			  GetVariableLengthValuePointer(), previousVariableLengthValueLength + 2, skippedStream.ssn);
 		}
 
 		ForwardTsnChunk* ForwardTsnChunk::SoftClone(const uint8_t* buffer) const

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

@@ -223,6 +223,31 @@ namespace RTC
 			SetVariableLengthValue(userDataPayload, userDataPayloadLength);
 		}
 
+		void IDataChunk::SetUserData(UserData userData)
+		{
+			MS_TRACE();
+
+			SetStreamId(userData.GetStreamId());
+			SetMessageId(userData.GetMessageId());
+
+			SetB(userData.IsBeginning());
+			SetE(userData.IsEnd());
+			SetU(userData.IsUnordered());
+
+			if (GetB())
+			{
+				SetPayloadProtocolId(userData.GetPayloadProtocolId());
+			}
+			else
+			{
+				SetFragmentSequenceNumber(userData.GetFragmentSequenceNumber());
+			}
+
+			const auto payload = std::move(userData).ReleasePayload();
+
+			SetUserDataPayload(payload.data(), payload.size());
+		}
+
 		IDataChunk* IDataChunk::SoftClone(const uint8_t* buffer) const
 		{
 			MS_TRACE();

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

@@ -118,9 +118,9 @@ namespace RTC
 			{
 				MS_DUMP_CLEAN(
 				  indentation,
-				  "  - stream id: %" PRIu16 ", unordered:%s, mid:%" PRIu32,
-				  skippedStream.streamId,
+				  "  - unordered:%s, stream id: %" PRIu16 ", mid:%" PRIu32,
 				  skippedStream.unordered ? "yes" : "no",
+				  skippedStream.streamId,
 				  skippedStream.mid);
 			}
 			MS_DUMP_CLEAN(indentation, "</SCTP::IForwardTsnChunk>");
@@ -156,13 +156,14 @@ namespace RTC
 
 			for (uint16_t idx{ 0 }; idx < numSkippedStreams; ++idx)
 			{
-				skippedStreams.emplace_back(GetStreamIdAt(idx), GetUFlagAt(idx), GetMessageIdentifierAt(idx));
+				skippedStreams.emplace_back(
+				  GetUFlagAt(idx), GetSkippedStreamIdAt(idx), GetMessageIdentifierAt(idx));
 			}
 
 			return skippedStreams;
 		}
 
-		void IForwardTsnChunk::AddStream(uint16_t stream, bool uFlag, uint32_t messageIdentifier)
+		void IForwardTsnChunk::AddSkippedStream(const AnyForwardTsnChunk::SkippedStream& skippedStream)
 		{
 			MS_TRACE();
 
@@ -173,11 +174,13 @@ namespace RTC
 
 			// Add the new stream, flag U and message identifier.
 			Utils::Byte::Set2Bytes(
-			  GetVariableLengthValuePointer(), previousVariableLengthValueLength, stream);
+			  GetVariableLengthValuePointer(), previousVariableLengthValueLength, skippedStream.streamId);
 			Utils::Byte::Set2Bytes(
-			  GetVariableLengthValuePointer(), previousVariableLengthValueLength + 2, uFlag);
+			  GetVariableLengthValuePointer(),
+			  previousVariableLengthValueLength + 2,
+			  skippedStream.unordered);
 			Utils::Byte::Set4Bytes(
-			  GetVariableLengthValuePointer(), previousVariableLengthValueLength + 4, messageIdentifier);
+			  GetVariableLengthValuePointer(), previousVariableLengthValueLength + 4, skippedStream.mid);
 		}
 
 		IForwardTsnChunk* IForwardTsnChunk::SoftClone(const uint8_t* buffer) const