mediasoup 3.19.21 → 3.20.0

package/worker/include/RTC/SCTP/public/SctpTypes.hpp

@@ -2,6 +2,8 @@
 #define MS_RTC_SCTP_TYPES_HPP
 
 #include "common.hpp"
+#include "Utils/UnwrappedSequenceNumber.hpp"
+#include <limits>
 #include <string_view>
 
 namespace RTC
@@ -331,6 +333,25 @@ namespace RTC
 					}
 				}
 			}
+
+			constexpr uint16_t MaxRetransmitsNoLimit{ std::numeric_limits<uint16_t>::max() };
+
+			constexpr uint64_t ExpiresAtMsInfinite{ std::numeric_limits<uint64_t>::max() };
+
+			/**
+			 * Unwrapped Transmission Sequence Numbers (TSN).
+			 */
+			using UnwrappedTsn = Utils::UnwrappedSequenceNumber<uint32_t>;
+
+			/**
+			 * Unwrapped Stream Sequence Numbers (SSN).
+			 */
+			using UnwrappedSsn = Utils::UnwrappedSequenceNumber<uint16_t>;
+
+			/**
+			 * Unwrapped Message Identifier (MID).
+			 */
+			using UnwrappedMid = Utils::UnwrappedSequenceNumber<uint32_t>;
 		} // namespace Types
 	} // namespace SCTP
 } // namespace RTC

package/worker/include/RTC/SCTP/rx/DataTracker.hpp

@@ -0,0 +1,277 @@
+#ifndef MS_RTC_SCTP_DATA_TRACKER_HPP
+#define MS_RTC_SCTP_DATA_TRACKER_HPP
+
+#include "common.hpp"
+#include "Utils/UnwrappedSequenceNumber.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include "RTC/SCTP/packet/UserData.hpp"
+#include "RTC/SCTP/packet/chunks/SackChunk.hpp"
+#include "RTC/SCTP/public/SctpTypes.hpp"
+#include <set>
+#include <string_view>
+#include <vector>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * Keeps track of received DATA and I-DATA chunks and handles all logic for
+		 * when_to create SACKs and also how_to generate them.
+		 *
+		 * It only uses TSNs to track delivery and doesn't need to be aware of
+		 * streams.
+		 *
+		 * SACKs are optimally sent every second packet on association with no packet
+		 * loss. When packet loss is detected, it's sent for every packet. When SACKs
+		 * are not sent directly, a timer is used to send a SACK delayed (by RTO/2,
+		 * or 200ms, whatever is smallest).
+		 */
+		class DataTracker
+		{
+		public:
+			/**
+			 * The maximum number of duplicate TSNs that will be reported in a SACK.
+			 */
+			static constexpr size_t MaxDuplicateTsnReported{ 20 };
+
+			/**
+			 * The maximum number of gap-ack-blocks that will be reported in a SACK.
+			 */
+			static constexpr size_t MaxGapAckBlocksReported{ 20 };
+
+			/**
+			 * The maximum number of accepted in-flight DATA / I-DATA chunks. This
+			 * indicates the maximum difference from this buffer's last cumulative ack
+			 * TSN, and any received data. Data received beyond this limit will be
+			 * dropped, which will force the transmitter to send data that actually
+			 * increases the last cumulative acked TSN.
+			 */
+			static constexpr uint32_t MaxAcceptedOutstandingFragments{ 100000 };
+
+		private:
+			enum class AckState : uint8_t
+			{
+				/**
+				 * No need to send an ACK.
+				 */
+				IDLE,
+
+				/**
+				 * Has received data chunks (but not yet end of packet).
+				 */
+				BECOMING_DELAYED,
+
+				/**
+				 * Has received data chunks and the end of a packet. Delayed ack timer is
+				 * running and a SACK will be sent on expiry, or if DATA / I-DATA is sent,
+				 * or after next packet with data.
+				 */
+				DELAYED,
+
+				/**
+				 * Send a SACK immediately after handling this packet.
+				 */
+				IMMEDIATE,
+			};
+
+		private:
+			static constexpr std::string_view AckStateToString(AckState ackState)
+			{
+				// NOTE: We cannot use MS_TRACE() here because clang in Linux will
+				// complain about "read of non-constexpr variable 'configuration' is not
+				// allowed in a constant expression".
+
+				switch (ackState)
+				{
+					case AckState::IDLE:
+					{
+						return "IDLE";
+					}
+
+					case AckState::BECOMING_DELAYED:
+					{
+						return "BECOMING_DELAYED";
+					}
+
+					case AckState::DELAYED:
+					{
+						return "DELAYED";
+					}
+
+					case AckState::IMMEDIATE:
+					{
+						return "IMMEDIATE";
+					}
+
+						NO_DEFAULT_GCC();
+				}
+			}
+
+		private:
+			/**
+			 * Represents ranges of TSNs that have been received that are not directly
+			 * following the last cumulative acked TSN. This information is returned
+			 * to the sender in the "gap-ack-blocks" in the SACK chunk. The blocks are
+			 * always non-overlapping and non-adjacent.
+			 */
+			class AdditionalTsnBlocks
+			{
+			public:
+				/**
+				 * Represents an inclusive range of received TSNs, i.e. [firstTsn, lastTsn].
+				 */
+				struct TsnRange
+				{
+					TsnRange(Types::UnwrappedTsn firstTsn, Types::UnwrappedTsn lastTsn)
+					  : firstTsn(firstTsn), lastTsn(lastTsn)
+					{
+					}
+
+					Types::UnwrappedTsn firstTsn;
+					Types::UnwrappedTsn lastTsn;
+				};
+
+				/**
+				 * Adds a TSN to the set. This will try to expand any existing block and
+				 * might merge blocks to ensure that all blocks are non-adjacent. If a
+				 * current block can't be expanded, a new block is created.
+				 *
+				 * The return value indicates if `tsn` was added. If false is returned,
+				 * the `tsn` was already represented in one of the blocks.
+				 */
+				bool Add(Types::UnwrappedTsn tsn);
+
+				/**
+				 * Erases all TSNs up to, and including `tsn`. This will remove all
+				 * blocks that are completely below `tsn` and may truncate a block where
+				 * `tsn` is within that block. In that case, the frontmost block's start
+				 * TSN will be the next following tsn after `tsn`.
+				 */
+				void EraseTo(Types::UnwrappedTsn tsn);
+
+				/**
+				 * Removes the first block. Must not be called on an empty set.
+				 */
+				void PopFront();
+
+				const std::vector<TsnRange>& GetBlocks() const
+				{
+					return this->blocks;
+				}
+
+				bool IsEmpty() const
+				{
+					return this->blocks.empty();
+				}
+
+				const TsnRange& Front() const
+				{
+					return this->blocks.front();
+				}
+
+			private:
+				// A sorted vector of non-overlapping and non-adjacent blocks.
+				std::vector<TsnRange> blocks;
+			};
+
+		public:
+			DataTracker(BackoffTimerHandleInterface* delayedAckTimer, uint32_t remoteInitialTsn);
+
+		public:
+			/**
+			 * Indicates if the provided TSN is valid. If this return false, the data
+			 * should be dropped and not added to any other buffers, which essentially
+			 * means that there is intentional packet loss.
+			 */
+			bool IsTsnValid(uint32_t tsn) const;
+
+			/**
+			 * Called for every incoming data chunk. Returns `true` if `tsn` was seen
+			 * for the first time, and `false` if it has been seen before (a duplicate
+			 * `tsn`).
+			 *
+			 * @remarks
+			 * - `IsTsnValid()` must be called prior to calling this method.
+			 */
+			bool Observe(uint32_t tsn, bool immediateAck = false);
+
+			/**
+			 * Called at the end of processing an SCTP packet.
+			 */
+			void ObservePacketEnd();
+
+			/**
+			 * Called for incoming FORWARD-TSN/I-FORWARD-TSN chunks. Indicates if the
+			 * chunk had any effect.
+			 */
+			bool HandleForwardTsn(uint32_t newCumulativeTsn);
+
+			/**
+			 * Indicates if a SACK should be sent. There may be other reasons to send
+			 * a SACK, but if this function indicates so, it should be sent as soon as
+			 * possible. Calling this function will make it clear a flag so that if
+			 * it's called again, it will probably return `false`.
+			 *
+			 * If the delayed ack timer is running, this method will return `false`
+			 * unless `alsoIfDelayed` is set to `true`. Then it will return true as
+			 * well.
+			 */
+			bool ShouldSendAck(bool alsoIfDelayed = false);
+
+			/**
+			 * Forces `ShouldSendSack()` to return `true`.
+			 */
+			void ForceImmediateSack();
+
+			/**
+			 * Returns the last cumulative ack TSN - the last seen data chunk's TSN
+			 * value before any packet loss was detected.
+			 */
+			uint32_t GetLastCumulativeAckedTsn() const
+			{
+				return this->lastCumulativeAckedTsn.Wrap();
+			}
+
+			bool IsLaterThanCumulativeAckedTsn(uint32_t tsn) const
+			{
+				return this->tsnUnwrapper.PeekUnwrap(tsn) > this->lastCumulativeAckedTsn;
+			}
+
+			/**
+			 * Returns `true` if the received `tsn` would increase the cumulative ack
+			 * TSN.
+			 */
+			bool WillIncreaseCumAckTsn(uint32_t tsn) const;
+
+			/**
+			 * Adds a SACK chunk with selective ack to the given Packet.
+			 *
+			 * @remarks
+			 * - It will clear `this->duplicates`, so every SACK chunk that is
+			 *   consumed must be sent.
+			 */
+			void AddSackSelectiveAck(Packet* packet, size_t aRwnd);
+
+			void HandleDelayedAckTimerExpiry();
+
+		private:
+			void UpdateAckState(AckState newAckState, std::string_view reason);
+
+		private:
+			// If a packet has ever been seen.
+			BackoffTimerHandleInterface* delayedAckTimer;
+			bool packetSeen{ false };
+			AckState ackState{ AckState::IDLE };
+			Types::UnwrappedTsn::Unwrapper tsnUnwrapper;
+			// All TSNs up until (and including) this value have been seen.
+			Types::UnwrappedTsn lastCumulativeAckedTsn;
+			// Received TSNs that are not directly following `lastCumulativeAckedTsn`.
+			AdditionalTsnBlocks additionalTsnBlocks;
+			std::set<uint32_t> duplicateTsns;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SCTP/rx/InterleavedReassemblyStreams.hpp

@@ -0,0 +1,116 @@
+#ifndef MS_RTC_SCTP_INTERLEAVED_REASSEMBLY_STREAMS_HPP
+#define MS_RTC_SCTP_INTERLEAVED_REASSEMBLY_STREAMS_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/rx/ReassemblyStreamsInterface.hpp"
+#include <map>
+#include <span>
+#include <tuple> // std::tie()
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * Handles reassembly of incoming data when interleaved message sending is
+		 * enabled on the association, i.e. when RFC 8260 is in use.
+		 *
+		 * In other words, this class handles data received via I-DATA chunks.
+		 */
+		class InterleavedReassemblyStreams : public ReassemblyStreamsInterface
+		{
+		private:
+			struct FullStreamId
+			{
+				FullStreamId(bool unordered, uint16_t streamId) : unordered(unordered), streamId(streamId)
+				{
+				}
+
+				friend bool operator<(FullStreamId a, FullStreamId b)
+				{
+					return std::tie(a.unordered, a.streamId) < std::tie(b.unordered, b.streamId);
+				}
+
+				const bool unordered;
+				const uint16_t streamId;
+			};
+
+		private:
+			class Stream
+			{
+			private:
+				using ChunkMap = std::map<uint32_t /*fsn*/, std::pair<Types::UnwrappedTsn, UserData>>;
+
+			public:
+				Stream(FullStreamId fullStreamId, InterleavedReassemblyStreams* parent, uint32_t nextMid = 0)
+				  : fullStreamId(fullStreamId), parent(*parent), nextMid(midUnwrapper.Unwrap(nextMid))
+				{
+				}
+
+			public:
+				int32_t AddData(Types::UnwrappedTsn tsn, UserData data);
+
+				size_t EraseTo(uint32_t mid);
+
+				void Reset()
+				{
+					this->midUnwrapper.Reset();
+					this->nextMid = this->midUnwrapper.Unwrap(0);
+				}
+
+				bool HasUnassembledChunks() const
+				{
+					return !this->chunksByMid.empty();
+				}
+
+			private:
+				/**
+				 * Try to assemble one message identified by `mid`. Returns the number
+				 * of bytes assembled if a message was assembled.
+				 */
+				size_t TryToAssembleMessage(Types::UnwrappedMid mid);
+
+				/**
+				 * Try to assemble several messages in order from the stream. Returns
+				 * the number of bytes assembled if a message was assembled.
+				 */
+				size_t TryToAssembleMessages();
+
+				size_t AssembleMessage(ChunkMap& tsnChunks);
+
+				size_t AssembleMessage(Types::UnwrappedTsn tsn, UserData data);
+
+			private:
+				const FullStreamId fullStreamId;
+				InterleavedReassemblyStreams& parent;
+				std::map<Types::UnwrappedMid, ChunkMap> chunksByMid;
+				Types::UnwrappedMid::Unwrapper midUnwrapper;
+				Types::UnwrappedMid nextMid;
+			};
+
+		public:
+			explicit InterleavedReassemblyStreams(
+			  ReassemblyStreamsInterface::OnAssembledMessage onAssembledMessage);
+
+		public:
+			int32_t AddData(Types::UnwrappedTsn tsn, UserData data) override;
+
+			size_t HandleForwardTsn(
+			  Types::UnwrappedTsn newCumulativeTsn,
+			  std::span<const AnyForwardTsnChunk::SkippedStream> skippedStreams) override;
+
+			void ResetStreams(std::span<const uint16_t> streamIds) override;
+
+		private:
+			Stream& GetOrCreateStream(const FullStreamId& streamId);
+
+		private:
+			// Callback for when a message has been assembled.
+			const OnAssembledMessage onAssembledMessage;
+			// All unordered and ordered streams, managing not-yet-assembled data.
+			std::map<FullStreamId, Stream> streams;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SCTP/rx/ReassemblyQueue.hpp

@@ -0,0 +1,202 @@
+#ifndef MS_RTC_SCTP_REASSEMBLY_QUEUE_HPP
+#define MS_RTC_SCTP_REASSEMBLY_QUEUE_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/packet/UserData.hpp"
+#include "RTC/SCTP/packet/chunks/AnyForwardTsnChunk.hpp"
+#include "RTC/SCTP/public/Message.hpp"
+#include "RTC/SCTP/public/SctpTypes.hpp"
+#include "RTC/SCTP/rx/ReassemblyStreamsInterface.hpp"
+#include <deque>
+#include <set>
+#include <span>
+#include <vector>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * Contains the received DATA / I-DATA chunks that haven't yet been
+		 * reassembled, and reassembles chunks when possible.
+		 *
+		 * The actual assembly is handled by an implementation of the
+		 * `ReassemblyStreamsInterface` interface.
+		 *
+		 * Except for reassembling fragmented messages, this class will also handle
+		 * two less common operations. To handle the receiver-side of partial
+		 * reliability (limited number of retransmissions or limited message
+		 * lifetime) as well as stream resetting, which is used when a sender wishes
+		 * to close SCTP streams.
+		 *
+		 * Partial reliability is handled when a FORWARD-TSN or I-FORWARD-TSN chunk
+		 * is received, and it will simply delete any chunks matching the parameters
+		 * in that chunk. This is mainly implemented in ReassemblyStreams classes.
+		 *
+		 * Resetting streams is handled when a RECONFIG chunks is received with an
+		 * "Outgoing SSN Reset Request" parameter. That parameter will contain a list
+		 * of streams to reset, and a `senderLastAssignedTsn`. If this TSN is not yet
+		 * seen, the stream cannot be directly reset, and this class will respond
+		 * that the reset is "deferred". But if this TSN provided is known, the
+		 * stream can be immediately be reset.
+		 *
+		 * The reassembly queue has a maximum size, as it would otherwise be an DoS
+		 * attack vector where a peer could consume all memory of the other peer by
+		 * sending a lot of ordered chunks, but carefully withholding an early one.
+		 * It also has a watermark limit, which the caller can query is the number
+		 * of bytes is above that limit. This is used by the caller to be selective
+		 * in what to add to the reassembly queue, so that it's not exhausted. The
+		 * caller is expected to call `IsFull()` prior to adding data to the queue
+		 * and to act accordingly if the queue is full.
+		 */
+		class ReassemblyQueue
+		{
+		public:
+			/**
+			 * When the queue is filled over this fraction (of its maximum size), the
+			 * SCTP association should restrict incoming data to avoid filling up the
+			 * queue.
+			 */
+			static constexpr float HighWatermarkLimit{ 0.9 };
+
+		private:
+			struct DeferredResetStreams
+			{
+				DeferredResetStreams(Types::UnwrappedTsn senderLastAssignedTsn, std::set<uint16_t> streamIds)
+				  : senderLastAssignedTsn(senderLastAssignedTsn), streamIds(std::move(streamIds))
+				{
+				}
+
+				Types::UnwrappedTsn senderLastAssignedTsn;
+				std::set<uint16_t> streamIds;
+				std::vector<std::function<void()>> deferredActions;
+				// TODO: SCTP: Once we upgrade to C++23, replace with:
+				// std::vector<std::move_only_function<void()>> deferredActions;
+			};
+
+		public:
+			explicit ReassemblyQueue(size_t maxLengthBytes, bool useMessageInterleaving = false);
+
+			~ReassemblyQueue();
+
+		public:
+			/**
+			 * Adds a data chunk to the queue, with a `tsn` and other parameters in
+			 * `data`.
+			 */
+			void AddData(uint32_t tsn, UserData data);
+
+			/**
+			 * Indicates if the reassembly queue has any reassembled messages that can
+			 * be retrieved by calling `GetNextMessage()`.
+			 */
+			bool HasMessages() const
+			{
+				return !this->reassembledMessages.empty();
+			}
+
+			/**
+			 * Returns the number of reassembled messages that are ready to be
+			 * retrieved by calling `GetNextMessage()`.
+			 */
+			size_t GetMessagesReadyCount() const
+			{
+				return this->reassembledMessages.size();
+			}
+
+			/**
+			 * Returns the next reassembled message or `std::nullopt` if there are no
+			 * messages ready.
+			 */
+			std::optional<Message> GetNextMessage();
+
+			/**
+			 * Handles a FORWARD-TSN/I-FORWARD-TSN chunk, when the sender has indicated
+			 * that the received (this class) should forget about some chunks. This is
+			 * used to implement partial reliability.
+			 */
+			void HandleForwardTsn(
+			  uint32_t newCumulativeTsn, std::span<const AnyForwardTsnChunk::SkippedStream> skippedStreams);
+
+			/**
+			 * Resets the provided streams and leaves deferred reset processing, if
+			 * enabled.
+			 */
+			void ResetStreamsAndLeaveDeferredReset(std::span<const uint16_t> streamIds);
+
+			/**
+			 * Enters deferred reset processing.
+			 */
+			void EnterDeferredReset(uint32_t senderLastAssignedTsn, std::span<const uint16_t> streamIds);
+
+			/**
+			 * The number of payload bytes that have been queued. Note that the actual
+			 * memory usage is higher due to additional overhead of tracking received
+			 * data.
+			 */
+			size_t GetQueuedBytes() const
+			{
+				return this->queuedBytes;
+			}
+
+			/**
+			 * The remaining bytes until the queue has reached the watermark limit.
+			 */
+			size_t GetRemainingBytes() const
+			{
+				return this->watermarkBytes - this->queuedBytes;
+			}
+
+			/**
+			 * Indicates if the queue is full. Data should not be added to the queue
+			 * when it's full.
+			 */
+			bool IsFull() const
+			{
+				return this->queuedBytes >= this->maxLengthBytes;
+			}
+
+			/**
+			 * Indicates if the queue is above the watermark limit, which is a certain
+			 * percentage of its size.
+			 */
+			bool IsAboveWatermark() const
+			{
+				return this->queuedBytes >= this->watermarkBytes;
+			}
+
+			/**
+			 * Returns the watermark limit, in bytes.
+			 */
+			size_t GetWatermarkBytes() const
+			{
+				return this->watermarkBytes;
+			}
+
+		private:
+			std::unique_ptr<ReassemblyStreamsInterface> CreateReassemblyStreams(
+			  ReassemblyStreamsInterface::OnAssembledMessage onAssembledMessage,
+			  bool useMessageInterleaving);
+
+			void AddReassembledMessage(std::span<const Types::UnwrappedTsn> tsns, Message message);
+
+			void AssertIsConsistent() const;
+
+		private:
+			const size_t maxLengthBytes;
+			const size_t watermarkBytes;
+			Types::UnwrappedTsn::Unwrapper tsnUnwrapper;
+			// Messages that have been reassembled, and will be consumed from by
+			// `GetNextMessage()`.
+			std::deque<Message> reassembledMessages;
+			// If present, "deferred reset processing" mode is active.
+			std::optional<DeferredResetStreams> deferredResetStreams;
+			// The number of "payload bytes" that are in this queue, in total.
+			size_t queuedBytes = 0;
+			// The actual implementation of ReassemblyStreams.
+			std::unique_ptr<ReassemblyStreamsInterface> reassemblyStreams;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SCTP/rx/ReassemblyStreamsInterface.hpp

@@ -0,0 +1,83 @@
+#ifndef MS_RTC_SCTP_REASSEMBLY_STREAMS_INTERFACE_HPP
+#define MS_RTC_SCTP_REASSEMBLY_STREAMS_INTERFACE_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/packet/UserData.hpp"
+#include "RTC/SCTP/packet/chunks/AnyForwardTsnChunk.hpp"
+#include "RTC/SCTP/public/Message.hpp"
+#include "RTC/SCTP/public/SctpTypes.hpp"
+#include <span>
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * Implementations of this interface will be called when data is received,
+		 * when data should be skipped/forgotten or when sequence number should be
+		 * reset.
+		 *
+		 * As a result of these operations - mainly when data is received - the
+		 * implementations of this interface should notify when a message has been
+		 * assembled, by calling the provided callback of type `OnAssembledMessage()`.
+		 * How it assembles messages will depend on e.g. if a message was sent on an
+		 * ordered or unordered stream.
+		 *
+		 * Implementations will - for each operation - indicate how much additional
+		 * memory that has been used as a result of performing the operation. This
+		 * is used to limit the maximum amount of memory used, to prevent
+		 * out-of-memory situations.
+		 */
+		class ReassemblyStreamsInterface
+		{
+		public:
+			/**
+			 * This callback will be provided as an argument to the constructor of the
+			 * concrete class implementing this interface and should be called when a
+			 * message has been assembled as well as indicating from which TSNs this
+			 * message was assembled from.
+			 */
+			using OnAssembledMessage =
+			  std::function<void(std::span<const Types::UnwrappedTsn> tsns, Message message)>;
+
+		public:
+			virtual ~ReassemblyStreamsInterface() = default;
+
+		public:
+			/**
+			 * Adds a data chunk to a stream as identified in `data`. If it was the
+			 * last remaining chunk in a message, reassemble one (or several, in case
+			 * of ordered chunks) messages.
+			 *
+			 * Returns the additional number of bytes added to the queue as a result
+			 * of performing this operation. If this addition resulted in messages
+			 * being assembled and delivered, this may be negative.
+			 */
+			virtual int32_t AddData(Types::UnwrappedTsn tsn, UserData data) = 0;
+
+			/**
+			 * Called for incoming FORWARD-TSN/I-FORWARD-TSN chunks - when the sender
+			 * wishes the received to skip/forget about data up until the provided
+			 * TSN. This is used to implement partial reliability, such as limiting
+			 * the number of retransmissions or the an expiration duration. As a
+			 * result of skipping data, this may result in the implementation being
+			 * able to assemble messages in ordered streams.
+			 *
+			 * Returns the number of bytes removed from the queue as a result of this
+			 * operation.
+			 */
+			virtual size_t HandleForwardTsn(
+			  Types::UnwrappedTsn newCumulativeTsn,
+			  std::span<const AnyForwardTsnChunk::SkippedStream> skippedStreams) = 0;
+
+			/**
+			 * Called for incoming (possibly deferred) RE-CONFIG chunks asking for
+			 * either a few streams, or all streams (when the list is empty) to be
+			 * reset - to have their next SSN or Message ID to be zero.
+			 */
+			virtual void ResetStreams(std::span<const uint16_t> streamIds) = 0;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif