mediasoup 3.19.22 → 3.20.0

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

@@ -1,15 +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 "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 "handles/BackoffTimerHandle.hpp"
-#include <cmath> // std::min()
 #include <string>
 
 namespace RTC
@@ -18,17 +16,16 @@ 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,
-		  // TODO: SCTP: Implement it.
-		  // SendQueue& sendQueue,
 		  uint32_t localVerificationTag,
 		  uint32_t remoteVerificationTag,
 		  uint32_t localInitialTsn,
@@ -36,12 +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),
-		    // TODO: SCTP: Implement it.
-		    // sendQueue(sendQueue),
 		    packetSender(packetSender),
 		    localVerificationTag(localVerificationTag),
 		    remoteVerificationTag(remoteVerificationTag),
@@ -50,10 +46,12 @@ namespace RTC
 		    remoteAdvertisedReceiverWindowCredit(remoteAdvertisedReceiverWindowCredit),
 		    tieTag(tieTag),
 		    negotiatedCapabilities(negotiatedCapabilities),
+		    maxPacketLength(maxPacketLength),
 		    isAssociationEstablished(std::move(isAssociationEstablished)),
 		    t3RtxTimer(this->shared->CreateBackoffTimer(
 		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
 		        .listener            = this,
+		        .label               = "sctp-t3-rtx",
 		        .baseTimeoutMs       = sctpOptions.initialRtoMs,
 		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
 		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
@@ -61,23 +59,22 @@ namespace RTC
 		    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),
-		    // TODO: SCTP: Implement.
-		    // dataTracker(),
-		    // TODO: SCTP: Implement.
-		    // reassemblyQueue(),
+		    dataTracker(this->delayedAckTimer.get(), remoteInitialTsn),
+		    reassemblyQueue(
+		      sctpOptions.maxReceiverWindowBufferSize, negotiatedCapabilities.messageInterleaving),
 		    retransmissionQueue(
 		      this,
 		      this->associationListener,
 		      localInitialTsn,
 		      remoteAdvertisedReceiverWindowCredit,
-		      // TODO: SCTP: Implement
-		      // this->sendQueue,
+		      sendQueue,
 		      this->t3RtxTimer.get(),
 		      sctpOptions,
 		      negotiatedCapabilities.partialReliability,
@@ -86,13 +83,14 @@ namespace RTC
 		      this->associationListener,
 		      this->shared,
 		      this,
-		      // TODO: SCTP: Implement.
-		      // std::addressof(this->dataTracker),
-		      // std::addressof(this->reassemblyQueue),
+		      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()
@@ -163,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);
@@ -172,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);
 		}
@@ -199,22 +197,19 @@ 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::MaybeSendForwardTsnChunk(Packet* packet, uint64_t nowMs)
+		void TransmissionControlBlock::MayAddForwardTsnChunk(Packet* packet, uint64_t nowMs)
 		{
 			MS_TRACE();
 
@@ -222,11 +217,11 @@ namespace RTC
 			{
 				if (this->negotiatedCapabilities.messageInterleaving)
 				{
-					this->retransmissionQueue.CreateIForwardTsn(packet);
+					this->retransmissionQueue.AddIForwardTsn(packet);
 				}
 				else
 				{
-					this->retransmissionQueue.CreateForwardTsn(packet);
+					this->retransmissionQueue.AddForwardTsn(packet);
 				}
 
 				// https://datatracker.ietf.org/doc/html/rfc3758
@@ -259,19 +254,19 @@ namespace RTC
 			// performed, the sender SHOULD ignore the value of cwnd and SHOULD NOT
 			// delay retransmission for this single packet."
 
-			auto packet = CreatePacket();
-			const auto result =
+			const auto packet = CreatePacket();
+
+			auto result =
 			  this->retransmissionQueue.GetChunksForFastRetransmit(packet->GetAvailableLength());
 
-			for (const auto& [tsn, data] : result)
+			for (auto& [tsn, data] : result)
 			{
 				if (this->negotiatedCapabilities.messageInterleaving)
 				{
 					auto* iDataChunk = packet->BuildChunkInPlace<IDataChunk>();
 
 					iDataChunk->SetTsn(tsn);
-					// TODO: SCTP: Implement.
-					// iDataChunk->SetUserData(data);
+					iDataChunk->SetUserData(std::move(data));
 					iDataChunk->Consolidate();
 				}
 				else
@@ -279,26 +274,142 @@ namespace RTC
 					auto* dataChunk = packet->BuildChunkInPlace<DataChunk>();
 
 					dataChunk->SetTsn(tsn);
-					// TODO: SCTP: Implement.
-					// dataChunk->SetUserData(data);
+					dataChunk->SetUserData(std::move(data));
 					dataChunk->Consolidate();
 				}
 			}
 
-			Send(packet.get());
+			SendPacket(packet.get());
 		}
 
-		void TransmissionControlBlock::OnT3RtxTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
+		void TransmissionControlBlock::SendBufferedPackets(uint64_t nowMs, bool addCookieAckChunk)
 		{
 			MS_TRACE();
 
-			const auto maxRestarts = this->t3RtxTimer->GetMaxRestarts();
+			for (size_t packetIdx{ 0 }; packetIdx < this->sctpOptions.maxBurst; ++packetIdx)
+			{
+				const auto packet = CreatePacket();
 
-			MS_DEBUG_TAG(
-			  sctp,
-			  "T3-rtx timer has expired [%zu/%s]",
-			  this->t3RtxTimer->GetExpirationCount(),
-			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+				// 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.
@@ -312,10 +423,9 @@ namespace RTC
 				{
 					this->retransmissionQueue.HandleT3RtxTimerExpiry();
 
-					// const uint64_t nowMs = DepLibUV::GetTimeMs();
+					const uint64_t nowMs = this->shared->GetTimeMs();
 
-					// TODO: SCTP: Implement
-					// SendBufferedPackets(nowMs);
+					SendBufferedPackets(nowMs);
 				}
 			}
 		}
@@ -324,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(
+		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);

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 streamId, 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, streamId);
+			  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 streamId, 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, streamId);
+			  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

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

@@ -148,18 +148,35 @@ namespace RTC
 			return clonedChunk;
 		}
 
-		void SackChunk::SetCumulativeTsnAck(uint32_t value)
+		void SackChunk::SetCumulativeTsnAck(uint32_t tsn)
 		{
 			MS_TRACE();
 
-			Utils::Byte::Set4Bytes(const_cast<uint8_t*>(GetBuffer()), 4, value);
+			Utils::Byte::Set4Bytes(const_cast<uint8_t*>(GetBuffer()), 4, tsn);
 		}
 
-		void SackChunk::SetAdvertisedReceiverWindowCredit(uint32_t value)
+		void SackChunk::SetAdvertisedReceiverWindowCredit(uint32_t aRwnd)
 		{
 			MS_TRACE();
 
-			Utils::Byte::Set4Bytes(const_cast<uint8_t*>(GetBuffer()), 8, value);
+			Utils::Byte::Set4Bytes(const_cast<uint8_t*>(GetBuffer()), 8, aRwnd);
+		}
+
+		std::vector<SackChunk::GapAckBlock> SackChunk::GetGapAckBlocks() const
+		{
+			MS_TRACE();
+
+			const uint16_t numberOfGapAckBlocks = GetNumberOfGapAckBlocks();
+			std::vector<SackChunk::GapAckBlock> gapAckBlocks;
+
+			gapAckBlocks.reserve(numberOfGapAckBlocks);
+
+			for (uint16_t idx{ 0 }; idx < numberOfGapAckBlocks; ++idx)
+			{
+				gapAckBlocks.emplace_back(GetAckBlockStartAt(idx), GetAckBlockEndAt(idx));
+			}
+
+			return gapAckBlocks;
 		}
 
 		std::vector<SackChunk::GapAckBlock> SackChunk::GetValidatedGapAckBlocks() const

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

@@ -1,5 +1,5 @@
 #define MS_CLASS "RTC::SCTP::ShutdownCompleteChunk"
-#define MS_LOG_DEV_LEVEL 3
+// #define MS_LOG_DEV_LEVEL 3
 
 #include "RTC/SCTP/packet/chunks/ShutdownCompleteChunk.hpp"
 #include "Logger.hpp"

package/worker/src/RTC/SCTP/packet/errorCauses/NoUserDataErrorCause.cpp

@@ -137,7 +137,7 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			return "tsn:[" + std::to_string(GetTsn()) + "]";
+			return "tsn:\"" + std::to_string(GetTsn()) + "\"";
 		}
 	} // namespace SCTP
 } // namespace RTC

package/worker/src/RTC/SCTP/packet/errorCauses/ProtocolViolationErrorCause.cpp

@@ -141,11 +141,11 @@ namespace RTC
 
 			if (HasAdditionalInformation())
 			{
-				return "info:[" +
+				return "info::\"" +
 				       std::string(
 				         reinterpret_cast<const char*>(GetAdditionalInformation()),
 				         GetAdditionalInformationLength()) +
-				       "]";
+				       "\"";
 			}
 			else
 			{