mediasoup 3.19.21 → 3.20.0

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

@@ -0,0 +1,327 @@
+#define MS_CLASS "RTC::SCTP::InterleavedReassemblyStreams"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/SCTP/rx/InterleavedReassemblyStreams.hpp"
+#include "Logger.hpp"
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		InterleavedReassemblyStreams::InterleavedReassemblyStreams(
+		  ReassemblyStreamsInterface::OnAssembledMessage onAssembledMessage)
+		  : onAssembledMessage(std::move(onAssembledMessage))
+		{
+			MS_TRACE();
+		}
+
+		int32_t InterleavedReassemblyStreams::AddData(Types::UnwrappedTsn tsn, UserData data)
+		{
+			MS_TRACE();
+
+			return GetOrCreateStream(FullStreamId(data.IsUnordered(), data.GetStreamId()))
+			  .AddData(tsn, std::move(data));
+		}
+
+		size_t InterleavedReassemblyStreams::HandleForwardTsn(
+		  Types::UnwrappedTsn /*newCumulativeTsn*/,
+		  std::span<const AnyForwardTsnChunk::SkippedStream> skippedStreams)
+		{
+			MS_TRACE();
+
+			size_t bytesRemoved = 0;
+
+			for (const auto& skippedStream : skippedStreams)
+			{
+				bytesRemoved +=
+				  GetOrCreateStream(FullStreamId(skippedStream.unordered, skippedStream.streamId))
+				    .EraseTo(skippedStream.mid);
+			}
+
+			return bytesRemoved;
+		}
+
+		void InterleavedReassemblyStreams::ResetStreams(std::span<const uint16_t> streamIds)
+		{
+			MS_TRACE();
+
+			if (streamIds.empty())
+			{
+				for (auto& [fullStreamId, stream] : this->streams)
+				{
+					MS_DEBUG_DEV("resetting implicit stream [streamId:%" PRIu16 "]", fullStreamId.streamId);
+
+					stream.Reset();
+				}
+			}
+			else
+			{
+				for (const auto streamId : streamIds)
+				{
+					MS_DEBUG_DEV("resetting explicit stream [streamId:%" PRIu16 "]", streamId);
+
+					GetOrCreateStream(FullStreamId(/*unordered*/ true, streamId)).Reset();
+					GetOrCreateStream(FullStreamId(/*unordered*/ false, streamId)).Reset();
+				}
+			}
+		}
+
+		InterleavedReassemblyStreams::Stream& InterleavedReassemblyStreams::GetOrCreateStream(
+		  const FullStreamId& streamId)
+		{
+			MS_TRACE();
+
+			auto it = this->streams.find(streamId);
+
+			if (it == this->streams.end())
+			{
+				it = this->streams
+				       .emplace(
+				         std::piecewise_construct,
+				         std::forward_as_tuple(streamId),
+				         std::forward_as_tuple(streamId, this))
+				       .first;
+			}
+
+			auto& stream = it->second;
+
+			return stream;
+		}
+
+		int32_t InterleavedReassemblyStreams::Stream::AddData(Types::UnwrappedTsn tsn, UserData data)
+		{
+			MS_TRACE();
+
+			MS_ASSERT(
+			  data.IsUnordered() == this->fullStreamId.unordered,
+			  "data.IsUnordered() != this->streamId.unordered");
+			MS_ASSERT(
+			  data.GetStreamId() == this->fullStreamId.streamId,
+			  "data.GetStreamId() != this->fullStreamId.streamId");
+
+			auto queuedBytes = static_cast<int32_t>(data.GetPayloadLength());
+
+			const Types::UnwrappedMid mid = this->midUnwrapper.Unwrap(data.GetMessageId());
+			const uint32_t fsn            = data.GetFragmentSequenceNumber();
+
+			// Avoid inserting it into any map if it can be delivered directly.
+			if (this->fullStreamId.unordered && data.IsBeginning() && data.IsEnd())
+			{
+				AssembleMessage(tsn, std::move(data));
+				return 0;
+			}
+			else if (!this->fullStreamId.unordered && mid == this->nextMid && data.IsBeginning() && data.IsEnd())
+			{
+				AssembleMessage(tsn, std::move(data));
+
+				this->nextMid.Increment();
+
+				// This might unblock assembling more messages.
+				return -TryToAssembleMessages();
+			}
+
+			// Slow path.
+			const auto [unused, inserted] =
+			  this->chunksByMid[mid].emplace(fsn, std::make_pair(tsn, std::move(data)));
+
+			if (!inserted)
+			{
+				return 0;
+			}
+
+			if (this->fullStreamId.unordered)
+			{
+				queuedBytes -= TryToAssembleMessage(mid);
+			}
+			else
+			{
+				if (mid == this->nextMid)
+				{
+					queuedBytes -= TryToAssembleMessages();
+				}
+			}
+
+			return queuedBytes;
+		}
+
+		size_t InterleavedReassemblyStreams::Stream::EraseTo(uint32_t mid)
+		{
+			MS_TRACE();
+
+			const Types::UnwrappedMid unwrappedMid = this->midUnwrapper.Unwrap(mid);
+			size_t removedBytes                    = 0;
+
+			auto it = this->chunksByMid.begin();
+
+			while (it != this->chunksByMid.end() && it->first <= unwrappedMid)
+			{
+				removedBytes += std::accumulate(
+				  it->second.begin(),
+				  it->second.end(),
+				  0,
+				  [](size_t acc, const auto& i)
+				  {
+					  const auto& data = i.second.second;
+
+					  return acc + data.GetPayloadLength();
+				  });
+
+				it = this->chunksByMid.erase(it);
+			}
+
+			if (!this->fullStreamId.unordered)
+			{
+				// For ordered streams, erasing a message might suddenly unblock that
+				// queue and allow it to deliver any following received messages.
+				if (unwrappedMid >= this->nextMid)
+				{
+					this->nextMid = unwrappedMid.GetNextValue();
+				}
+
+				removedBytes += TryToAssembleMessages();
+			}
+
+			return removedBytes;
+		}
+
+		size_t InterleavedReassemblyStreams::Stream::TryToAssembleMessage(Types::UnwrappedMid mid)
+		{
+			MS_TRACE();
+
+			const auto it = this->chunksByMid.find(mid);
+
+			if (it == this->chunksByMid.end())
+			{
+				MS_DEBUG_DEV("trying to assemble message [mid:%" PRIu32 "]", mid.Wrap());
+
+				return 0;
+			}
+
+			ChunkMap& chunks = it->second;
+
+			if (!chunks.begin()->second.second.IsBeginning() || !chunks.rbegin()->second.second.IsEnd())
+			{
+				MS_DEBUG_DEV(
+				  "cannot assemble message, missing beggining or end [mid:%" PRIu32 "]", mid.Wrap());
+
+				return 0;
+			}
+
+			// NOTE: This is uint32_t - uint32_t casted to uint64_t. Not very nice but
+			// it works.
+			const int64_t fnsDiff = chunks.rbegin()->first - chunks.begin()->first;
+
+			if (fnsDiff != (static_cast<int64_t>(chunks.size()) - 1))
+			{
+				MS_DEBUG_DEV(
+				  "cannot assemble message, not all chunks exist [has:%zu, expected:%" PRIi64 "]",
+				  chunks.size(),
+				  fnsDiff + 1);
+
+				return 0;
+			}
+
+			const size_t removedBytes = AssembleMessage(chunks);
+
+			MS_DEBUG_DEV("message assembled [mid:%" PRIu32 ", removedBytes:%zu]", mid.Wrap(), removedBytes);
+
+			this->chunksByMid.erase(mid);
+
+			return removedBytes;
+		}
+
+		size_t InterleavedReassemblyStreams::Stream::TryToAssembleMessages()
+		{
+			MS_TRACE();
+
+			size_t removedBytes = 0;
+
+			for (;;)
+			{
+				const size_t removedBytesThisIt = TryToAssembleMessage(this->nextMid);
+
+				if (removedBytesThisIt == 0)
+				{
+					break;
+				}
+
+				removedBytes += removedBytesThisIt;
+
+				this->nextMid.Increment();
+			}
+
+			return removedBytes;
+		}
+
+		size_t InterleavedReassemblyStreams::Stream::AssembleMessage(Types::UnwrappedTsn tsn, UserData data)
+		{
+			MS_TRACE();
+
+			const size_t payloadLength        = data.GetPayloadLength();
+			const auto streamId               = data.GetStreamId();
+			const auto pip                    = data.GetPayloadProtocolId();
+			const Types::UnwrappedTsn tsns[1] = { tsn };
+
+			Message message(
+			  streamId,
+			  pip,
+			  // NOTE: clang-tidy doesn't understand that this is fine.
+			  // NOLINTNEXTLINE(bugprone-use-after-move, hicpp-invalid-access-moved)
+			  std::move(data).ReleasePayload());
+
+			this->parent.onAssembledMessage(tsns, std::move(message));
+
+			return payloadLength;
+		}
+
+		size_t InterleavedReassemblyStreams::Stream::AssembleMessage(ChunkMap& tsnChunks)
+		{
+			MS_TRACE();
+
+			const size_t count = tsnChunks.size();
+
+			// Fast path - zero-copy.
+			if (count == 1)
+			{
+				return AssembleMessage(
+				  tsnChunks.begin()->second.first, std::move(tsnChunks.begin()->second.second));
+			}
+
+			// Slow path - will need to concatenate the payload.
+			std::vector<Types::UnwrappedTsn> tsns;
+			std::vector<uint8_t> payload;
+
+			const size_t payloadLength = std::accumulate(
+			  tsnChunks.begin(),
+			  tsnChunks.end(),
+			  0,
+			  [](size_t acc, const auto& i)
+			  {
+				  const auto& data = i.second.second;
+
+				  return acc + data.GetPayloadLength();
+			  });
+
+			payload.reserve(payloadLength);
+			tsns.reserve(count);
+
+			for (auto& item : tsnChunks)
+			{
+				const Types::UnwrappedTsn tsn = item.second.first;
+
+				UserData& data = item.second.second;
+
+				tsns.push_back(tsn);
+				payload.insert(payload.end(), data.GetPayload().begin(), data.GetPayload().end());
+			}
+
+			const UserData& data = tsnChunks.begin()->second.second;
+
+			Message message(data.GetStreamId(), data.GetPayloadProtocolId(), std::move(payload));
+
+			this->parent.onAssembledMessage(tsns, std::move(message));
+
+			return payloadLength;
+		}
+	} // namespace SCTP
+} // namespace RTC

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

@@ -0,0 +1,288 @@
+#define MS_CLASS "RTC::SCTP::ReassemblyQueue"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/SCTP/rx/ReassemblyQueue.hpp"
+#include "Logger.hpp"
+#include "RTC/SCTP/rx/InterleavedReassemblyStreams.hpp"
+#include "RTC/SCTP/rx/TraditionalReassemblyStreams.hpp"
+#include <string>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		ReassemblyQueue::ReassemblyQueue(size_t maxLengthBytes, bool useMessageInterleaving)
+		  : maxLengthBytes(maxLengthBytes),
+		    watermarkBytes(this->maxLengthBytes * ReassemblyQueue::HighWatermarkLimit),
+		    reassemblyStreams(CreateReassemblyStreams(
+		      [this](std::span<const Types::UnwrappedTsn> tsns, Message message)
+		      {
+			      AddReassembledMessage(tsns, std::move(message));
+		      },
+		      useMessageInterleaving))
+		{
+			MS_TRACE();
+		}
+
+		ReassemblyQueue::~ReassemblyQueue()
+		{
+			MS_TRACE();
+		}
+
+		void ReassemblyQueue::AddData(uint32_t tsn, UserData data)
+		{
+			MS_TRACE();
+
+			MS_DEBUG_DEV(
+			  "added data [tsn:%" PRIu32 ", streamId:%" PRIu16 ", mid:%" PRIu32 ", fsn:%" PRIu32
+			  ", type:%s]",
+			  tsn,
+			  data.GetStreamId(),
+			  data.GetMessageId(),
+			  data.GetFragmentSequenceNumber(),
+			  (data.IsBeginning() && data.IsEnd() ? "complete"
+			   : data.IsBeginning()               ? "first"
+			   : data.IsEnd()                     ? "last"
+			                                      : "middle"));
+
+			const Types::UnwrappedTsn unwrappedTsn = this->tsnUnwrapper.Unwrap(tsn);
+
+			// If a stream reset has been received with a "sender's last assigned tsn"
+			// in the future, the association is in "deferred reset processing" mode
+			// and must buffer chunks until it's exited.
+			if (
+			  this->deferredResetStreams.has_value() &&
+			  unwrappedTsn > this->deferredResetStreams->senderLastAssignedTsn &&
+			  this->deferredResetStreams->streamIds.contains(data.GetStreamId()))
+			{
+				MS_DEBUG_DEV(
+				  "deferrink chunk [tsn:%" PRIu32 ", streamId:%" PRIu16 "] until tsn %" PRIu32,
+				  tsn,
+				  data.GetStreamId(),
+				  this->deferredResetStreams->senderLastAssignedTsn.Wrap());
+
+				// https://tools.ietf.org/html/rfc6525#section-5.2.2
+				//
+				// "In this mode, any data arriving with a TSN larger than the Sender's
+				// Last Assigned TSN for the affected stream(s) MUST be queued locally
+				// and held until the cumulative acknowledgment point reaches the
+				// Sender's Last Assigned TSN."
+
+				this->queuedBytes += data.GetPayloadLength();
+
+				// NOTE: We use C++20 so we don't support `std::move_only_function` and
+				// hence we need to move UserData to a shared pointer. Otherwise it will
+				// fail to compile because `std::function` doesn't accept move-only
+				// callables and `UserData` has its copy constructor deleted, so the
+				// resulting lambda is not copyable and `std::function` will reject it.
+				auto sharedData = std::make_shared<UserData>(std::move(data));
+
+				this->deferredResetStreams->deferredActions.emplace_back(
+				  [this, tsn, sharedData]() mutable
+				  {
+					  this->queuedBytes -= sharedData->GetPayloadLength();
+
+					  AddData(tsn, std::move(*sharedData));
+				  });
+
+				// TODO: SCTP: Once we upgrade to C++23, replace the above with:
+				// this->deferredResetStreams->deferredActions.emplace_back(
+				//   [this, tsn, data = std::move(data)]() mutable
+				//   {
+				// 	  this->queuedBytes -= data.GetPayloadLength();
+
+				// 	  AddData(tsn, std::move(data));
+				//   });
+			}
+			else
+			{
+				this->queuedBytes += this->reassemblyStreams->AddData(unwrappedTsn, std::move(data));
+			}
+
+			// https://datatracker.ietf.org/doc/html/rfc9260#section-6.9
+			//
+			// "If the data receiver runs out of buffer space while still waiting for
+			// more fragments to complete the reassembly of the message, it SHOULD
+			// dispatch part of its inbound message through a partial delivery API
+			// (see Section 11), freeing some of its receive buffer space so that the
+			// rest of the message can be received."
+
+			// TODO: dcsctp: Support EOR flag and partial delivery?
+
+			AssertIsConsistent();
+		}
+
+		std::optional<Message> ReassemblyQueue::GetNextMessage()
+		{
+			MS_TRACE();
+
+			if (this->reassembledMessages.empty())
+			{
+				return std::nullopt;
+			}
+
+			Message message = std::move(this->reassembledMessages.front());
+
+			this->reassembledMessages.pop_front();
+			this->queuedBytes -= message.GetPayloadLength();
+
+			return message;
+		}
+
+		void ReassemblyQueue::HandleForwardTsn(
+		  uint32_t newCumulativeTsn, std::span<const AnyForwardTsnChunk::SkippedStream> skippedStreams)
+		{
+			MS_TRACE();
+
+			const Types::UnwrappedTsn tsn = this->tsnUnwrapper.Unwrap(newCumulativeTsn);
+
+			if (this->deferredResetStreams.has_value() && tsn > this->deferredResetStreams->senderLastAssignedTsn)
+			{
+				MS_DEBUG_DEV("forward TSN to %" PRIu32 ", deferring", tsn.Wrap());
+
+				this->deferredResetStreams->deferredActions.emplace_back(
+				  [this,
+				   newCumulativeTsn,
+				   skippedStreams2 = std::vector<AnyForwardTsnChunk::SkippedStream>(
+				     skippedStreams.begin(), skippedStreams.end())]
+				  {
+					  HandleForwardTsn(newCumulativeTsn, skippedStreams2);
+				  });
+
+				AssertIsConsistent();
+
+				return;
+			}
+
+			MS_DEBUG_DEV("forward TSN to %" PRIu32 ", performing", tsn.Wrap());
+
+			this->queuedBytes -= this->reassemblyStreams->HandleForwardTsn(tsn, skippedStreams);
+
+			AssertIsConsistent();
+		}
+
+		void ReassemblyQueue::ResetStreamsAndLeaveDeferredReset(std::span<const uint16_t> streamIds)
+		{
+			MS_TRACE();
+
+#if MS_LOG_DEV_LEVEL == 3
+			std::string streamIdList;
+
+			for (const auto streamId : streamIds)
+			{
+				if (!streamIdList.empty())
+				{
+					streamIdList += ',';
+				}
+
+				streamIdList += std::to_string(streamId);
+			}
+
+			MS_DEBUG_DEV("resetting streams [streamIds:%s]", streamIdList.c_str());
+#endif
+
+			// https://tools.ietf.org/html/rfc6525#section-5.2.2
+			//
+			// "streams MUST be reset to 0 as the next expected SSN."
+			this->reassemblyStreams->ResetStreams(streamIds);
+
+			if (this->deferredResetStreams.has_value())
+			{
+				MS_DEBUG_DEV(
+				  "leaving deferred reset processing, feeding back %zu actions",
+				  this->deferredResetStreams->deferredActions.size());
+
+				// https://tools.ietf.org/html/rfc6525#section-5.2.2
+				//
+				// "Any queued TSNs (queued at step E2) MUST now be released and
+				// processed normally."
+				auto deferredActions = std::move(this->deferredResetStreams->deferredActions);
+
+				this->deferredResetStreams = std::nullopt;
+
+				for (auto& action : deferredActions)
+				{
+					action();
+				}
+			}
+
+			AssertIsConsistent();
+		}
+
+		void ReassemblyQueue::EnterDeferredReset(
+		  uint32_t senderLastAssignedTsn, std::span<const uint16_t> streamIds)
+		{
+			MS_TRACE();
+
+			if (!this->deferredResetStreams.has_value())
+			{
+				return;
+			}
+
+			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()));
+
+			AssertIsConsistent();
+		}
+
+		std::unique_ptr<ReassemblyStreamsInterface> ReassemblyQueue::CreateReassemblyStreams(
+		  ReassemblyStreamsInterface::OnAssembledMessage onAssembledMessage, bool useMessageInterleaving)
+		{
+			MS_TRACE();
+
+			if (useMessageInterleaving)
+			{
+				return std::make_unique<InterleavedReassemblyStreams>(std::move(onAssembledMessage));
+			}
+			else
+			{
+				return std::make_unique<TraditionalReassemblyStreams>(std::move(onAssembledMessage));
+			}
+		}
+
+		void ReassemblyQueue::AddReassembledMessage(std::span<const Types::UnwrappedTsn> tsns, Message message)
+		{
+			MS_TRACE();
+
+#if MS_LOG_DEV_LEVEL == 3
+			std::string tsnList;
+
+			for (const auto tsn : tsns)
+			{
+				if (!tsnList.empty())
+				{
+					tsnList += ',';
+				}
+
+				tsnList += std::to_string(tsn.Wrap());
+			}
+
+			MS_DEBUG_DEV(
+			  "resetting streams [ppid:%" PRIu32 ", payloadLength:%zu, tsns:%s]",
+			  message.GetPayloadProtocolId(),
+			  message.GetPayloadLength(),
+			  tsnList.c_str());
+#endif
+
+			this->queuedBytes += message.GetPayloadLength();
+			this->reassembledMessages.emplace_back(std::move(message));
+		}
+
+		void ReassemblyQueue::AssertIsConsistent() const
+		{
+			MS_TRACE();
+
+			// Allow this->queuedBytes to be larger than this->maxLengthBytes, as it's
+			// not actively enforced in this class. But in case it wraps around
+			// (becomes negative, but as it's unsigned, that would wrap to very big),
+			// this would trigger.
+			MS_ASSERT(
+			  this->queuedBytes <= 2 * this->maxLengthBytes,
+			  "this->queuedBytes > 2 * this->maxLengthBytes");
+		}
+	} // namespace SCTP
+} // namespace RTC