mediasoup 3.19.21 → 3.19.22

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

@@ -2,16 +2,19 @@
 #define MS_RTC_SCTP_TRANSMISSION_CONTROL_BLOCK_HPP
 
 #include "common.hpp"
+#include "SharedInterface.hpp"
 #include "RTC/SCTP/association/HeartbeatHandler.hpp"
 #include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
 #include "RTC/SCTP/association/PacketSender.hpp"
+#include "RTC/SCTP/association/StreamResetHandler.hpp"
 #include "RTC/SCTP/association/TCBContext.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
 #include "RTC/SCTP/public/AssociationListener.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
 #include "RTC/SCTP/tx/RetransmissionErrorCounter.hpp"
+#include "RTC/SCTP/tx/RetransmissionQueue.hpp"
 #include "RTC/SCTP/tx/RetransmissionTimeout.hpp"
-#include "handles/BackoffTimerHandle.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
 #include <string_view>
 #include <vector>
 
@@ -25,12 +28,17 @@ namespace RTC
 		 *
 		 * @see https://datatracker.ietf.org/doc/html/rfc9260#section-14
 		 */
-		class TransmissionControlBlock : public TCBContext, public BackoffTimerHandle::Listener
+		class TransmissionControlBlock : public TCBContext,
+		                                 public RetransmissionQueue::Listener,
+		                                 public BackoffTimerHandleInterface::Listener
 		{
 		public:
 			TransmissionControlBlock(
 			  AssociationListener& associationListener,
 			  const SctpOptions& sctpOptions,
+			  SharedInterface* shared,
+			  // TODO: SCTP: Implement it.
+			  // SendQueue& sendQueue,
 			  PacketSender& packetSender,
 			  uint32_t localVerificationTag,
 			  uint32_t remoteVerificationTag,
@@ -128,7 +136,12 @@ namespace RTC
 			 * @remarks
 			 * - Implements TCBContext interface.
 			 */
-			void ObserveRtt(uint64_t rtt) override;
+			void ObserveRttMs(uint64_t rttMs) override;
+
+			size_t GetCwnd() const
+			{
+				return this->retransmissionQueue.GetCwnd();
+			}
 
 			/**
 			 * @remarks
@@ -158,13 +171,46 @@ namespace RTC
 			 */
 			void Send(Packet* packet) override;
 
+			// TODO: SCTP: Implement it.
+			// DataTracker& GetDataTracker()
+			// {
+			// 	return this->dataTracker;
+			// }
+
+			// TODO: SCTP: Implement it.
+			// 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,8 +218,21 @@ namespace RTC
 				return this->remoteStateCookie.has_value();
 			}
 
+			/**
+			 * Sends a SACK Chunk, if there is a need to.
+			 */
 			void MaySendSackChunk();
 
+			/**
+			 * Sends a FORWARD-TSN or I-FORWARD-TSN Chunk if it is needed and allowed
+			 * (rate-limited).
+			 */
+			void MaybeSendForwardTsnChunk(Packet* packet, uint64_t nowMs);
+
+			void MaySendFastRetransmit();
+
+			// TODO: SCTP: Mamy more methods.
+
 			/**
 			 * @remarks
 			 * - Implements TCBContext interface.
@@ -206,13 +265,20 @@ 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 OnTimer(BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) override;
 
 		private:
 			AssociationListener& associationListener;
 			const SctpOptions sctpOptions;
+			SharedInterface* shared;
 			PacketSender& packetSender;
 			uint32_t localVerificationTag{ 0 };
 			uint32_t remoteVerificationTag{ 0 };
@@ -224,17 +290,24 @@ namespace RTC
 			NegotiatedCapabilities negotiatedCapabilities;
 			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;
+			// TODO: SCTP: Implement.
+			// DataTracker dataTracker;
+			// TODO: SCTP: Implement.
+			// ReassemblyQueue reassemblyQueue;
+			// TODO: SCTP: Implement.
+			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/packet/UserData.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_SCTP_USER_DATA_HPP
 
 #include "common.hpp"
+#include <ostream>
 #include <vector>
 
 namespace RTC
@@ -39,6 +40,15 @@ namespace RTC
 			// Disable copy assignment.
 			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:
@@ -91,6 +101,20 @@ namespace RTC
 				return this->payload.size();
 			}
 
+			UserData Clone() const
+			{
+				return UserData(
+				  this->streamId,
+				  this->ssn,
+				  this->mid,
+				  this->fsn,
+				  this->ppid,
+				  this->payload,
+				  this->isBeginning,
+				  this->isEnd,
+				  this->isUnordered);
+			}
+
 			/**
 			 * Useful to extract the payload and its ownership when destructing the
 			 * Message.
@@ -135,6 +159,18 @@ namespace RTC
 			bool isEnd{ false };
 			bool isUnordered{ false };
 		};
+
+		/**
+		 * 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/ForwardTsnChunk.hpp

@@ -114,7 +114,7 @@ namespace RTC
 
 			std::vector<AnyForwardTsnChunk::SkippedStream> GetSkippedStreams() const final;
 
-			void AddStream(uint16_t stream, uint16_t streamSequence);
+			void AddStream(uint16_t streamId, uint16_t streamSequence);
 
 		protected:
 			ForwardTsnChunk* SoftClone(const uint8_t* buffer) const final;

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

@@ -126,7 +126,7 @@ namespace RTC
 
 			std::vector<AnyForwardTsnChunk::SkippedStream> GetSkippedStreams() const final;
 
-			void AddStream(uint16_t stream, bool uFlag, uint32_t messageIdentifier);
+			void AddStream(uint16_t streamId, bool uFlag, uint32_t messageIdentifier);
 
 		protected:
 			IForwardTsnChunk* SoftClone(const uint8_t* buffer) const final;

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

@@ -2,6 +2,7 @@
 #define MS_RTC_SCTP_OPTIONS_HPP
 
 #include "common.hpp"
+#include "Utils.hpp"
 #include "RTC/Consts.hpp"
 #include "RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp"
 
@@ -44,7 +45,7 @@ namespace RTC
 			 * Maximum size of an SCTP Packet. It doesn't include any overhead of
 			 * DTLS, TURN, UDP or IP headers.
 			 */
-			size_t mtu{ RTC::Consts::MaxSafeMtuSizeForSctp };
+			size_t mtu{ Utils::Byte::PadDownTo4Bytes(RTC::Consts::MaxSafeMtuSizeForSctp) };
 
 			/**
 			 * The largest allowed message payload to be sent. Messages will be rejected