mediasoup 3.19.21 → 3.20.0

package/worker/include/RTC/SCTP/association/StreamResetHandler.hpp

@@ -2,15 +2,19 @@
 #define MS_RTC_SCTP_STREAM_RESET_HANDLER_HPP
 
 #include "common.hpp"
-#include "RTC/SCTP/association/TCBContext.hpp"
-#include "RTC/SCTP/common/UnwrappedSequenceNumber.hpp"
+#include "Utils/UnwrappedSequenceNumber.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
+#include "RTC/SCTP/association/TransmissionControlBlockContextInterface.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
 #include "RTC/SCTP/packet/chunks/ReConfigChunk.hpp"
 #include "RTC/SCTP/packet/parameters/IncomingSsnResetRequestParameter.hpp"
 #include "RTC/SCTP/packet/parameters/OutgoingSsnResetRequestParameter.hpp"
 #include "RTC/SCTP/packet/parameters/ReconfigurationResponseParameter.hpp"
-#include "RTC/SCTP/public/AssociationListener.hpp"
-#include "handles/BackoffTimerHandle.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
+#include "RTC/SCTP/rx/DataTracker.hpp"
+#include "RTC/SCTP/rx/ReassemblyQueue.hpp"
+#include "RTC/SCTP/tx/RetransmissionQueue.hpp"
+#include "SharedInterface.hpp"
 #include <span>
 #include <vector>
 
@@ -49,7 +53,7 @@ namespace RTC
 		 * not-yet-sent messages will be discarded, but that may change in the future.
 		 * RFC8831 allows both behaviors.
 		 */
-		class StreamResetHandler : public TCBContext, public BackoffTimerHandle::Listener
+		class StreamResetHandler : public BackoffTimerHandleInterface::Listener
 		{
 		private:
 			enum class ReqSeqNbrValidationResult : uint8_t
@@ -160,16 +164,16 @@ namespace RTC
 			};
 
 		private:
-			using UnwrappedReConfigRequestSn = UnwrappedSequenceNumber<uint32_t>;
+			using UnwrappedReConfigRequestSn = Utils::UnwrappedSequenceNumber<uint32_t>;
 
 		public:
 			StreamResetHandler(
-			  AssociationListener& associationListener, TCBContext* tcbContext
-			  // TODO: SCTP: Implement
-			  // DataTracker* dataTracker,
-			  // ReassemblyQueue* reassemblyQueue,
-			  // RetransmissionQueue* retransmissionQueue
-			);
+			  AssociationListenerInterface& associationListener,
+			  SharedInterface* shared,
+			  TransmissionControlBlockContextInterface* tcbContext,
+			  DataTracker* dataTracker,
+			  ReassemblyQueue* reassemblyQueue,
+			  RetransmissionQueue* retransmissionQueue);
 
 			~StreamResetHandler() override;
 
@@ -183,6 +187,23 @@ namespace RTC
 			 */
 			void ResetStreams(std::span<const uint16_t> outgoingStreamIds);
 
+			/**
+			 * Whether a Reset Streams request should be send. Will return `false` if
+			 * there is no need to create a request (no streams to reset) or if there
+			 * already is an ongoing stream reset request that hasn't completed yet.
+			 */
+			bool ShouldSendStreamResetRequest() const;
+
+			/**
+			 * Adds a Reset Streams request to the given Packet. Will start the
+			 * reconfig timer.
+			 *
+			 * @remarks
+			 * - The caller must check `ShouldCreateStreamResetRequest()` first and
+			 *   only invoke this method if the former returns `true`.
+			 */
+			void AddStreamResetRequest(Packet* packet);
+
 			/**
 			 * Called when handling and incoming RE-CONFIG chunk. Processes a stream
 			 * reconfiguration chunk and may send a RE-CONFIG back to the peer with
@@ -197,18 +218,10 @@ namespace RTC
 			bool ValidateReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk);
 
 			/**
-			 * Creates a Reset Streams request that must be sent if returned. Will
-			 * start the reconfig timer. Will return `nullptr` if there is no need
-			 * to create a request (no streams to reset) or if there already is an
-			 * ongoing stream reset request that hasn't completed yet.
+			 * Adds the actual RE-CONFIG chunk to the given Packet. A request (which
+			 * set `this->currentRequest`) must have been created prior.
 			 */
-			ReConfigChunk* CreateStreamResetRequest();
-
-			/**
-			 * Creates the actual RE-CONFIG chunk. A request (which set
-			 * `currentRequest`) must have been created prior.
-			 */
-			ReConfigChunk* CreateReconfigChunk();
+			void AddReConfigChunk(Packet* packet);
 
 			/**
 			 * Called to validate the `reqSeqNbr`, that it's the next in sequence.
@@ -244,27 +257,28 @@ namespace RTC
 
 			void OnReConfigTimer(uint64_t& baseTimeoutMs, bool& stop);
 
-			/* Pure virtual methods inherited from BackoffTimerHandle::Listener. */
+			/* Pure virtual methods inherited from BackoffTimerHandleInterface::Listener. */
 		public:
-			void OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
+			void OnBackoffTimer(
+			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
-			AssociationListener& associationListener;
-			TCBContext* tcbContext{ nullptr };
-			// TODO: SCTP: Implement
-			// DataTracker* dataTracker{ nullptr };,
-			// ReassemblyQueue* reassemblyQueue{ nullptr };,
-			// RetransmissionQueue* retransmissionQueue{ nullptr };
+			AssociationListenerInterface& associationListener;
+			SharedInterface* shared;
+			TransmissionControlBlockContextInterface* tcbContext;
+			DataTracker* dataTracker;
+			ReassemblyQueue* reassemblyQueue;
+			RetransmissionQueue* retransmissionQueue;
 			UnwrappedReConfigRequestSn::Unwrapper incomingReConfigRequestSnUnwrapper;
-			const std::unique_ptr<BackoffTimerHandle> reConfigTimer;
+			const std::unique_ptr<BackoffTimerHandleInterface> reConfigTimer;
 			// The next sequence number for outgoing stream requests.
-			uint32_t nextOutgoingReqSeqNbr{ 0 };
-			// The current stream request operation.
-			std::optional<CurrentRequest> currentRequest;
+			uint32_t nextOutgoingReqSeqNbr;
 			// For incoming requests. Last processed request sequence number.
 			UnwrappedReConfigRequestSn lastProcessedReqSeqNbr;
 			// The result from last processed incoming request.
 			ReconfigurationResponseParameter::Result lastProcessedReqResult;
+			// The current stream request operation.
+			std::optional<CurrentRequest> currentRequest;
 		};
 	} // namespace SCTP
 } // namespace RTC

package/worker/include/RTC/SCTP/association/TransmissionControlBlock.hpp

@@ -2,16 +2,22 @@
 #define MS_RTC_SCTP_TRANSMISSION_CONTROL_BLOCK_HPP
 
 #include "common.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
 #include "RTC/SCTP/association/HeartbeatHandler.hpp"
 #include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
 #include "RTC/SCTP/association/PacketSender.hpp"
-#include "RTC/SCTP/association/TCBContext.hpp"
+#include "RTC/SCTP/association/StreamResetHandler.hpp"
+#include "RTC/SCTP/association/TransmissionControlBlockContextInterface.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
-#include "RTC/SCTP/public/AssociationListener.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
+#include "RTC/SCTP/rx/DataTracker.hpp"
+#include "RTC/SCTP/rx/ReassemblyQueue.hpp"
 #include "RTC/SCTP/tx/RetransmissionErrorCounter.hpp"
+#include "RTC/SCTP/tx/RetransmissionQueue.hpp"
 #include "RTC/SCTP/tx/RetransmissionTimeout.hpp"
-#include "handles/BackoffTimerHandle.hpp"
+#include "RTC/SCTP/tx/SendQueueInterface.hpp"
+#include "SharedInterface.hpp"
 #include <string_view>
 #include <vector>
 
@@ -25,12 +31,16 @@ namespace RTC
 		 *
 		 * @see https://datatracker.ietf.org/doc/html/rfc9260#section-14
 		 */
-		class TransmissionControlBlock : public TCBContext, public BackoffTimerHandle::Listener
+		class TransmissionControlBlock : public TransmissionControlBlockContextInterface,
+		                                 public RetransmissionQueue::Listener,
+		                                 public BackoffTimerHandleInterface::Listener
 		{
 		public:
 			TransmissionControlBlock(
-			  AssociationListener& associationListener,
+			  AssociationListenerInterface& associationListener,
 			  const SctpOptions& sctpOptions,
+			  SharedInterface* shared,
+			  SendQueueInterface& sendQueue,
 			  PacketSender& packetSender,
 			  uint32_t localVerificationTag,
 			  uint32_t remoteVerificationTag,
@@ -39,6 +49,7 @@ namespace RTC
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
 			  const NegotiatedCapabilities& negotiatedCapabilities,
+			  size_t maxPacketLength,
 			  std::function<bool()> isAssociationEstablished);
 
 			~TransmissionControlBlock() override;
@@ -48,7 +59,7 @@ namespace RTC
 
 			/**
 			 * @remarks
-			 * - Implements TCBContext interface.
+			 * - Implements TransmissionControlBlockContextInterface.
 			 */
 			bool IsAssociationEstablished() const override
 			{
@@ -80,7 +91,7 @@ namespace RTC
 			 * Chunk.
 			 *
 			 * @remarks
-			 * - Implements TCBContext interface.
+			 * - Implements TransmissionControlBlockContextInterface.
 			 */
 			uint32_t GetLocalInitialTsn() const override
 			{
@@ -92,7 +103,7 @@ namespace RTC
 			 * INIT_ACK Chunk.
 			 *
 			 * @remarks
-			 * - Implements TCBContext interface.
+			 * - Implements TransmissionControlBlockContextInterface.
 			 */
 			uint32_t GetRemoteInitialTsn() const override
 			{
@@ -126,13 +137,18 @@ namespace RTC
 
 			/**
 			 * @remarks
-			 * - Implements TCBContext interface.
+			 * - Implements TransmissionControlBlockContextInterface.
 			 */
-			void ObserveRtt(uint64_t rtt) override;
+			void ObserveRttMs(uint64_t rttMs) override;
+
+			size_t GetCwnd() const
+			{
+				return this->retransmissionQueue.GetCwnd();
+			}
 
 			/**
 			 * @remarks
-			 * - Implements TCBContext interface.
+			 * - Implements TransmissionControlBlockContextInterface.
 			 */
 			uint64_t GetCurrentRtoMs() const override
 			{
@@ -146,7 +162,7 @@ namespace RTC
 
 			/**
 			 * @remarks
-			 * - Implements TCBContext interface.
+			 * - Implements TransmissionControlBlockContextInterface.
 			 */
 			std::unique_ptr<Packet> CreatePacket() const override;
 
@@ -154,17 +170,48 @@ namespace RTC
 
 			/**
 			 * @remarks
-			 * - Implements TCBContext interface.
+			 * - Implements TransmissionControlBlockContextInterface.
 			 */
-			void Send(Packet* packet) override;
+			bool SendPacket(Packet* packet) override;
+
+			DataTracker& GetDataTracker()
+			{
+				return this->dataTracker;
+			}
+
+			ReassemblyQueue& GetReassemblyQueue()
+			{
+				return this->reassemblyQueue;
+			}
+
+			RetransmissionQueue& GetRetransmissionQueue()
+			{
+				return this->retransmissionQueue;
+			}
+
+			StreamResetHandler& GetStreamResetHandler()
+			{
+				return this->streamResetHandler;
+			}
 
 			HeartbeatHandler& GetHeartbeatHandler()
 			{
 				return this->heartbeatHandler;
 			}
 
+			/**
+			 * Will be set while the Association is in COOKIE_ECHOED state. In this
+			 * state, there can only be a single Packet outstanding, and it must
+			 * contain the COOKIE_ECHO Chunk as the first Chunk in that Packet, until
+			 * the COOKIE_ACK has been received, which will make the socket call
+			 * `ClearRemoteStateCookie()`.
+			 */
 			void SetRemoteStateCookie(std::vector<uint8_t> remoteStateCookie);
 
+			/**
+			 * Called when the COOKIE_ACK Chunk has been received, to allow further
+			 * Packets to be sent.
+			 */
 			void ClearRemoteStateCookie();
 
 			bool HasRemoteStateCookie() const
@@ -172,11 +219,34 @@ namespace RTC
 				return this->remoteStateCookie.has_value();
 			}
 
+			/**
+			 * Sends a SACK Chunk, if there is a need to.
+			 */
 			void MaySendSackChunk();
 
+			/**
+			 * May add a FORWARD-TSN or I-FORWARD-TSN Chunk to the given Packet if it
+			 * is needed and allowed (rate-limited).
+			 */
+			void MayAddForwardTsnChunk(Packet* packet, uint64_t nowMs);
+
+			void MaySendFastRetransmit();
+
+			/**
+			 * Create and fill Packets with control and DATA/I-DATA Chunks, and sends
+			 * them as much as can be allowed by the congestion control algorithm.
+			 *
+			 * @remarks
+			 * - If `this->remoteStateCookie` is present, then only one Packet will be
+			 *   sent, with this Chunk as the first Chunk.
+			 * - Cannot pass `addCookieAckChunk=true` if `this->remoteStateCookie` is
+			 *   present (will throw).
+			 */
+			void SendBufferedPackets(uint64_t nowMs, bool addCookieAckChunk = false);
+
 			/**
 			 * @remarks
-			 * - Implements TCBContext interface.
+			 * - Implements TransmissionControlBlockContextInterface.
 			 */
 			bool IncrementTxErrorCounter(std::string_view reason) override
 			{
@@ -185,16 +255,16 @@ namespace RTC
 
 			/**
 			 * @remarks
-			 * - Implements TCBContext interface.
+			 * - Implements TransmissionControlBlockContextInterface.
 			 */
 			void ClearTxErrorCounter() override
 			{
-				return this->txErrorCounter.Clear();
+				this->txErrorCounter.Clear();
 			}
 
 			/**
 			 * @remarks
-			 * - Implements TCBContext interface.
+			 * - Implements TransmissionControlBlockContextInterface.
 			 */
 			bool HasTooManyTxErrors() const override
 			{
@@ -206,35 +276,48 @@ namespace RTC
 
 			void OnDelayedAckTimer(uint64_t& baseTimeoutMs, bool& stop);
 
-			/* Pure virtual methods inherited from BackoffTimerHandle::Listener. */
+			/* Pure virtual methods inherited from RetransmissionQueue::Listener. */
+		public:
+			void OnRetransmissionQueueNewRttMs(uint64_t newRttMs) override;
+			void OnRetransmissionQueueClearRetransmissionCounter() override;
+			;
+
+			/* Pure virtual methods inherited from BackoffTimerHandleInterface::Listener. */
 		public:
-			void OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
+			void OnBackoffTimer(
+			  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
-			AssociationListener& associationListener;
+			AssociationListenerInterface& associationListener;
 			const SctpOptions sctpOptions;
+			SharedInterface* shared;
 			PacketSender& packetSender;
-			uint32_t localVerificationTag{ 0 };
-			uint32_t remoteVerificationTag{ 0 };
-			uint32_t localInitialTsn{ 0 };
-			uint32_t remoteInitialTsn{ 0 };
-			uint32_t remoteAdvertisedReceiverWindowCredit{ 0 };
+			uint32_t localVerificationTag;
+			uint32_t remoteVerificationTag;
+			uint32_t localInitialTsn;
+			uint32_t remoteInitialTsn;
+			uint32_t remoteAdvertisedReceiverWindowCredit;
 			// Nonce, used to detect reconnections.
-			uint64_t tieTag{ 0 };
+			uint64_t tieTag;
 			NegotiatedCapabilities negotiatedCapabilities;
+			// Max SCTP Packet length.
+			const size_t maxPacketLength;
 			std::function<bool()> isAssociationEstablished;
 			// The data retransmission timer.
-			const std::unique_ptr<BackoffTimerHandle> t3RtxTimer;
+			const std::unique_ptr<BackoffTimerHandleInterface> t3RtxTimer;
 			// Delayed ack timer, which triggers when acks should be sent (when
 			// delayed).
-			const std::unique_ptr<BackoffTimerHandle> delayedAckTimer;
+			const std::unique_ptr<BackoffTimerHandleInterface> delayedAckTimer;
 			RetransmissionTimeout rto;
 			RetransmissionErrorCounter txErrorCounter;
+			DataTracker dataTracker;
+			ReassemblyQueue reassemblyQueue;
+			RetransmissionQueue retransmissionQueue;
+			StreamResetHandler streamResetHandler;
 			HeartbeatHandler heartbeatHandler;
 			// Rate limiting of FORWARD_TSN. Next can be sent at or after this
 			// timestamp.
-			// TODO: SCTP: Uncomment.
-			// uint64_t limitForwardTsnUntilMs{ 0 };
+			uint64_t limitForwardTsnUntilMs{ 0 };
 			// Only valid when state is State::COOKIE_ECHOED. In this state, the
 			// Association must wait for COOKIE_ACK to continue sending any packets (not
 			// including a COOKIE_ECHO). So if this state cookie is present, the

package/worker/include/RTC/SCTP/association/{TCBContext.hpp → TransmissionControlBlockContextInterface.hpp}

@@ -1,5 +1,5 @@
-#ifndef MS_RTC_SCTP_TCB_CONTEXT_HPP
-#define MS_RTC_SCTP_TCB_CONTEXT_HPP
+#ifndef MS_RTC_SCTP_TRANSMISSION_CONTROL_BLOCK_CONTEXT_INTERFACE_HPP
+#define MS_RTC_SCTP_TRANSMISSION_CONTROL_BLOCK_CONTEXT_INTERFACE_HPP
 
 #include "common.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
@@ -9,10 +9,10 @@ namespace RTC
 {
 	namespace SCTP
 	{
-		class TCBContext
+		class TransmissionControlBlockContextInterface
 		{
 		public:
-			virtual ~TCBContext() = default;
+			virtual ~TransmissionControlBlockContextInterface() = default;
 
 			/**
 			 * Indicates if the SCTP Association has been established.
@@ -32,9 +32,10 @@ namespace RTC
 			virtual uint32_t GetRemoteInitialTsn() const = 0;
 
 			/**
-			 * To be called when a RTT has been measured, to update the RTO value.
+			 * To be called when a RTT (ms) has been measured, to update the RTO
+			 * value.
 			 */
-			virtual void ObserveRtt(uint64_t rtt) = 0;
+			virtual void ObserveRttMs(uint64_t rttMs) = 0;
 
 			/**
 			 * Returns the Retransmission Timeout (RTO) value.
@@ -43,7 +44,8 @@ namespace RTC
 
 			/**
 			 * Increments the transmission error counter, given a human readable
-			 * reason.
+			 * reason. Returns `true` if the maximum error count has been reached,
+			 * `false` will be returned.
 			 */
 			virtual bool IncrementTxErrorCounter(std::string_view reason) = 0;
 
@@ -59,7 +61,11 @@ namespace RTC
 
 			virtual std::unique_ptr<Packet> CreatePacket() const = 0;
 
-			virtual void Send(Packet* packet) = 0;
+			/**
+			 * Sends a Packet and returns a boolean indicating whether the Packet was
+			 * sent or not.
+			 */
+			virtual bool SendPacket(Packet* packet) = 0;
 		};
 	} // namespace SCTP
 } // namespace RTC

package/worker/include/RTC/SCTP/packet/Chunk.hpp

@@ -47,7 +47,7 @@ namespace RTC
 			friend class Packet;
 
 		public:
-			using parametersIterator  = typename std::vector<Parameter*>::const_iterator;
+			using ParametersIterator  = typename std::vector<Parameter*>::const_iterator;
 			using ErrorCausesIterator = typename std::vector<ErrorCause*>::const_iterator;
 
 		public:
@@ -232,12 +232,12 @@ namespace RTC
 				return this->parameters.size();
 			}
 
-			virtual parametersIterator ParametersBegin() const final
+			virtual ParametersIterator ParametersBegin() const final
 			{
 				return this->parameters.begin();
 			}
 
-			virtual parametersIterator ParametersEnd() const final
+			virtual ParametersIterator ParametersEnd() const final
 			{
 				return this->parameters.end();
 			}

package/worker/include/RTC/SCTP/packet/TLV.hpp

@@ -2,8 +2,8 @@
 #define MS_RTC_SCTP_TLV_HPP
 
 #include "common.hpp"
-#include "Utils.hpp"
 #include "RTC/Serializable.hpp"
+#include "Utils.hpp"
 
 namespace RTC
 {

package/worker/include/RTC/SCTP/packet/UserData.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_SCTP_USER_DATA_HPP
 
 #include "common.hpp"
+#include <ostream>
 #include <vector>
 
 namespace RTC
@@ -25,20 +26,37 @@ namespace RTC
 			  bool isEnd,
 			  bool isUnordered);
 
-			// Move constructor. No need to do anything special since std::vector
-			// already implements move.
+			/**
+			 * Move constructor. No need to do anything special since std::vector
+			 * already implements move.
+			 */
 			UserData(UserData&& other) = default;
 
-			// Move assignment. No need to do anything special since std::vector
-			// already implements move.
+			/**
+			 * Move assignment. No need to do anything special since std::vector
+			 * already implements move.
+			 */
 			UserData& operator=(UserData&& other) = default;
 
-			// Disable copy constructor.
+			/**
+			 * Copy constructor disabled.
+			 */
 			UserData(const UserData&) = delete;
 
-			// Disable copy assignment.
+			/**
+			 * Copy assignment disabled.
+			 */
 			UserData& operator=(const UserData&) = delete;
 
+			bool operator==(const UserData& other) const
+			{
+				return (
+				  this->streamId == other.streamId && this->ssn == other.ssn && this->mid == other.mid &&
+				  this->fsn == other.fsn && this->ppid == other.ppid && this->payload == other.payload &&
+				  this->isBeginning == other.isBeginning && this->isEnd == other.isEnd &&
+				  this->isUnordered == other.isUnordered);
+			}
+
 			~UserData();
 
 		public:
@@ -81,9 +99,9 @@ namespace RTC
 				return this->ppid;
 			}
 
-			const uint8_t* GetPayload() const
+			std::vector<uint8_t>& GetPayload()
 			{
-				return this->payload.data();
+				return this->payload;
 			}
 
 			size_t GetPayloadLength() const
@@ -93,7 +111,7 @@ namespace RTC
 
 			/**
 			 * Useful to extract the payload and its ownership when destructing the
-			 * Message.
+			 * UserData.
 			 *
 			 * @remarks
 			 * - && at the end means that it can only be called from a rvalue.
@@ -109,6 +127,20 @@ namespace RTC
 				return std::move(this->payload);
 			}
 
+			UserData Clone() const
+			{
+				return UserData(
+				  this->streamId,
+				  this->ssn,
+				  this->mid,
+				  this->fsn,
+				  this->ppid,
+				  this->payload,
+				  this->isBeginning,
+				  this->isEnd,
+				  this->isUnordered);
+			}
+
 			bool IsBeginning() const
 			{
 				return this->isBeginning;
@@ -125,16 +157,28 @@ namespace RTC
 			}
 
 		private:
-			uint16_t streamId{ 0 };
-			uint16_t ssn{ 0 };
-			uint32_t mid{ 0 };
-			uint32_t fsn{ 0 };
-			uint32_t ppid{ 0 };
+			uint16_t streamId;
+			uint16_t ssn;
+			uint32_t mid;
+			uint32_t fsn;
+			uint32_t ppid;
 			std::vector<uint8_t> payload;
-			bool isBeginning{ false };
-			bool isEnd{ false };
-			bool isUnordered{ false };
+			bool isBeginning;
+			bool isEnd;
+			bool isUnordered;
 		};
+
+		/**
+		 * For Catch2 to print it nicely.
+		 */
+		inline std::ostream& operator<<(std::ostream& os, const UserData& d)
+		{
+			return os << "{streamId:" << d.GetStreamId() << ", ssn:" << d.GetStreamSequenceNumber()
+			          << ", mid:" << d.GetMessageId() << ", fsn:" << d.GetFragmentSequenceNumber()
+			          << ", ppid:" << d.GetPayloadProtocolId() << ", payloadLen:" << d.GetPayloadLength()
+			          << ", B:" << d.IsBeginning() << ", E:" << d.IsEnd() << ", U:" << d.IsUnordered()
+			          << "}";
+		}
 	} // namespace SCTP
 } // namespace RTC
 

package/worker/include/RTC/SCTP/packet/chunks/AnyDataChunk.hpp

@@ -77,7 +77,7 @@ namespace RTC
 
 			virtual uint16_t GetUserDataPayloadLength() const = 0;
 
-			virtual UserData GetUserData() const = 0;
+			virtual UserData MakeUserData() const = 0;
 		};
 	} // namespace SCTP
 } // namespace RTC