mediasoup 3.21.0 → 3.21.2

package/worker/test/src/RTC/NEW_RTCP/rtcpCommon.cpp

@@ -0,0 +1,29 @@
+#include "test/include/RTC/RTCP/rtcpCommon.hpp" // in worker/test/include/
+#include <cstring>                              // std::memset
+
+namespace rtcpCommon
+{
+	// NOTE: Buffers must be 4-byte aligned since RTP packet parsing casts them
+	// to structs (e.g. FixedHeader, HeaderExtension) that require 4-byte
+	// alignment. Without this, accessing multi-byte fields would be undefined
+	// behavior on strict-alignment architectures.
+	alignas(4) thread_local uint8_t FactoryBuffer[];
+	alignas(4) thread_local uint8_t SerializeBuffer[];
+	alignas(4) thread_local uint8_t CloneBuffer[];
+	alignas(4) thread_local uint8_t DataBuffer[];
+	alignas(4) thread_local uint8_t ThrowBuffer[];
+
+	void ResetBuffers()
+	{
+		std::memset(FactoryBuffer, 0xAA, sizeof(FactoryBuffer));
+		std::memset(SerializeBuffer, 0xBB, sizeof(SerializeBuffer));
+		std::memset(CloneBuffer, 0xCC, sizeof(CloneBuffer));
+		std::memset(DataBuffer, 0xDD, sizeof(DataBuffer));
+		std::memset(ThrowBuffer, 0xEE, sizeof(ThrowBuffer));
+
+		for (size_t i = 0; i < 256; ++i)
+		{
+			DataBuffer[i] = static_cast<uint8_t>(i);
+		}
+	}
+} // namespace rtcpCommon

package/worker/test/src/RTC/RTP/TestPacket.cpp

@@ -57,7 +57,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet->Serialize(rtpCommon::SerializeBuffer, sizeof(rtpCommon::SerializeBuffer));
 
-		std::memset(buffer, 0x00, sizeof(buffer));
+		std::memset(buffer, 0xAA, sizeof(buffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -83,7 +83,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet.reset(packet->Clone(rtpCommon::CloneBuffer, sizeof(rtpCommon::CloneBuffer)));
 
-		std::memset(rtpCommon::SerializeBuffer, 0x00, sizeof(rtpCommon::SerializeBuffer));
+		std::memset(rtpCommon::SerializeBuffer, 0xAA, sizeof(rtpCommon::SerializeBuffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -170,7 +170,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet->Serialize(rtpCommon::SerializeBuffer, sizeof(rtpCommon::SerializeBuffer));
 
-		std::memset(buffer, 0x00, sizeof(buffer));
+		std::memset(buffer, 0xAA, sizeof(buffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -196,7 +196,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet.reset(packet->Clone(rtpCommon::CloneBuffer, sizeof(rtpCommon::CloneBuffer)));
 
-		std::memset(rtpCommon::SerializeBuffer, 0x00, sizeof(rtpCommon::SerializeBuffer));
+		std::memset(rtpCommon::SerializeBuffer, 0xAA, sizeof(rtpCommon::SerializeBuffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -283,7 +283,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet->Serialize(rtpCommon::SerializeBuffer, sizeof(rtpCommon::SerializeBuffer));
 
-		std::memset(buffer, 0x00, sizeof(buffer));
+		std::memset(buffer, 0xAA, sizeof(buffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -309,7 +309,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet.reset(packet->Clone(rtpCommon::CloneBuffer, sizeof(rtpCommon::CloneBuffer)));
 
-		std::memset(rtpCommon::SerializeBuffer, 0x00, sizeof(rtpCommon::SerializeBuffer));
+		std::memset(rtpCommon::SerializeBuffer, 0xAA, sizeof(rtpCommon::SerializeBuffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -399,7 +399,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet->Serialize(rtpCommon::SerializeBuffer, sizeof(rtpCommon::SerializeBuffer));
 
-		std::memset(buffer, 0x00, sizeof(buffer));
+		std::memset(buffer, 0xAA, sizeof(buffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -427,7 +427,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet.reset(packet->Clone(rtpCommon::CloneBuffer, sizeof(rtpCommon::CloneBuffer)));
 
-		std::memset(rtpCommon::SerializeBuffer, 0x00, sizeof(rtpCommon::SerializeBuffer));
+		std::memset(rtpCommon::SerializeBuffer, 0xAA, sizeof(rtpCommon::SerializeBuffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -546,7 +546,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet->Serialize(rtpCommon::SerializeBuffer, sizeof(rtpCommon::SerializeBuffer));
 
-		std::memset(buffer, 0x00, sizeof(buffer));
+		std::memset(buffer, 0xAA, sizeof(buffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -592,7 +592,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet.reset(packet->Clone(rtpCommon::CloneBuffer, sizeof(rtpCommon::CloneBuffer)));
 
-		std::memset(rtpCommon::SerializeBuffer, 0x00, sizeof(rtpCommon::SerializeBuffer));
+		std::memset(rtpCommon::SerializeBuffer, 0xAA, sizeof(rtpCommon::SerializeBuffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -732,7 +732,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet->Serialize(rtpCommon::SerializeBuffer, sizeof(rtpCommon::SerializeBuffer));
 
-		std::memset(buffer, 0x00, sizeof(buffer));
+		std::memset(buffer, 0xAA, sizeof(buffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -781,7 +781,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet.reset(packet->Clone(rtpCommon::CloneBuffer, sizeof(rtpCommon::CloneBuffer)));
 
-		std::memset(rtpCommon::SerializeBuffer, 0x00, sizeof(rtpCommon::SerializeBuffer));
+		std::memset(rtpCommon::SerializeBuffer, 0xAA, sizeof(rtpCommon::SerializeBuffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -897,7 +897,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet->Serialize(rtpCommon::SerializeBuffer, sizeof(rtpCommon::SerializeBuffer));
 
-		std::memset(buffer, 0x00, sizeof(buffer));
+		std::memset(buffer, 0xAA, sizeof(buffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -925,7 +925,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet.reset(packet->Clone(rtpCommon::CloneBuffer, sizeof(rtpCommon::CloneBuffer)));
 
-		std::memset(rtpCommon::SerializeBuffer, 0x00, sizeof(rtpCommon::SerializeBuffer));
+		std::memset(rtpCommon::SerializeBuffer, 0xAA, sizeof(rtpCommon::SerializeBuffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
@@ -1161,6 +1161,8 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet->Serialize(rtpCommon::SerializeBuffer, sizeof(rtpCommon::SerializeBuffer));
 
+		std::memset(rtpCommon::FactoryBuffer, 0xAA, sizeof(rtpCommon::FactoryBuffer));
+
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),
 		  /*buffer*/ rtpCommon::SerializeBuffer,
@@ -1207,7 +1209,7 @@ SCENARIO("RTP Packet", "[serializable][rtp][packet]")
 
 		packet.reset(packet->Clone(rtpCommon::CloneBuffer, sizeof(rtpCommon::CloneBuffer)));
 
-		std::memset(rtpCommon::SerializeBuffer, 0x00, sizeof(rtpCommon::SerializeBuffer));
+		std::memset(rtpCommon::SerializeBuffer, 0xAA, sizeof(rtpCommon::SerializeBuffer));
 
 		CHECK_RTP_PACKET(
 		  /*packet*/ packet.get(),

package/worker/test/src/RTC/SCTP/association/TestAssociation.cpp

@@ -1,6 +1,6 @@
 #include "common.hpp"
 #include "RTC/SCTP/association/Association.hpp"
-#include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
+#include "RTC/SCTP/association/Capabilities.hpp"
 #include "RTC/SCTP/association/StateCookie.hpp"
 #include "RTC/SCTP/packet/ErrorCause.hpp"
 #include "RTC/SCTP/packet/Packet.hpp"
@@ -1774,7 +1774,7 @@ SCENARIO("SCTP Association", "[sctp][association]")
 		// Forge a plain (unauthenticated) State Cookie with attacker-chosen values,
 		// as in the published PoC. It passes the magic checks but carries no MAC.
 		const uint32_t forgedTag = 0xDEADBEEF;
-		const RTC::SCTP::NegotiatedCapabilities negotiatedCapabilities;
+		const RTC::SCTP::Capabilities remoteCapabilities;
 
 		std::vector<uint8_t> cookieBuffer(RTC::SCTP::StateCookie::StateCookieLength);
 
@@ -1787,7 +1787,7 @@ SCENARIO("SCTP Association", "[sctp][association]")
 		  /*remoteInitialTsn*/ 2000,
 		  /*remoteAdvertisedReceiverWindowCredit*/ 65535,
 		  /*tieTag*/ 0,
-		  negotiatedCapabilities);
+		  remoteCapabilities);
 
 		// Builds a COOKIE-ECHO packet carrying the forged cookie. `buffers` must
 		// outlive the returned packet.

package/worker/test/src/RTC/SCTP/association/TestCapabilities.cpp

@@ -0,0 +1,99 @@
+#include "common.hpp"
+#include "RTC/SCTP/association/Capabilities.hpp"
+#include "RTC/SCTP/packet/Chunk.hpp"
+#include "RTC/SCTP/packet/chunks/InitChunk.hpp"
+#include "RTC/SCTP/packet/parameters/ForwardTsnSupportedParameter.hpp"
+#include "RTC/SCTP/packet/parameters/SupportedExtensionsParameter.hpp"
+#include "RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp"
+#include "test/include/RTC/SCTP/sctpCommon.hpp"
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("SCTP Capabilities", "[sctp][capabilities]")
+{
+	sctpCommon::ResetBuffers();
+
+	SECTION("Capabilities::Factory() succeeds (1)")
+	{
+		const std::unique_ptr<RTC::SCTP::InitChunk> remoteChunk{ RTC::SCTP::InitChunk::Factory(
+			sctpCommon::FactoryBuffer, sizeof(sctpCommon::FactoryBuffer)) };
+
+		remoteChunk->SetNumberOfOutboundStreams(4096);
+		remoteChunk->SetNumberOfInboundStreams(1024);
+
+		auto* remoteSupportedExtensionsParameter =
+		  remoteChunk->BuildParameterInPlace<RTC::SCTP::SupportedExtensionsParameter>();
+
+		remoteSupportedExtensionsParameter->AddChunkType(RTC::SCTP::Chunk::ChunkType::FORWARD_TSN);
+		remoteSupportedExtensionsParameter->AddChunkType(RTC::SCTP::Chunk::ChunkType::RE_CONFIG);
+		remoteSupportedExtensionsParameter->AddChunkType(RTC::SCTP::Chunk::ChunkType::I_DATA);
+		remoteSupportedExtensionsParameter->AddChunkType(RTC::SCTP::Chunk::ChunkType::I_FORWARD_TSN);
+		remoteSupportedExtensionsParameter->Consolidate();
+
+		auto* remoteZeroChecksumAcceptableParameter =
+		  remoteChunk->BuildParameterInPlace<RTC::SCTP::ZeroChecksumAcceptableParameter>();
+
+		remoteZeroChecksumAcceptableParameter->SetAlternateErrorDetectionMethod(
+		  RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::SCTP_OVER_DTLS);
+		remoteZeroChecksumAcceptableParameter->Consolidate();
+
+		const auto remoteCapabilities = RTC::SCTP::Capabilities::Factory(remoteChunk.get());
+
+		// Raw remote-announced values (no local option is applied).
+		REQUIRE(remoteCapabilities.maxOutboundStreams == 4096);
+		REQUIRE(remoteCapabilities.maxInboundStreams == 1024);
+		REQUIRE(remoteCapabilities.partialReliability == true);
+		REQUIRE(remoteCapabilities.messageInterleaving == true);
+		REQUIRE(remoteCapabilities.reConfig == true);
+		REQUIRE(
+		  remoteCapabilities.zeroChecksumAlternateErrorDetectionMethod ==
+		  RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::SCTP_OVER_DTLS);
+	}
+
+	SECTION("Capabilities::Factory() succeeds (2)")
+	{
+		const std::unique_ptr<RTC::SCTP::InitChunk> remoteChunk{ RTC::SCTP::InitChunk::Factory(
+			sctpCommon::FactoryBuffer, sizeof(sctpCommon::FactoryBuffer)) };
+
+		remoteChunk->SetNumberOfOutboundStreams(4000);
+		remoteChunk->SetNumberOfInboundStreams(3000);
+
+		auto* remoteSupportedExtensionsParameter =
+		  remoteChunk->BuildParameterInPlace<RTC::SCTP::SupportedExtensionsParameter>();
+
+		// NOTE: Missing FORWARD-TSN, but remote announces support for it via
+		// Forward-TSN-Supported parameter.
+		// NOTE: Missing RE-CONFIG (needed for Stream Re-Configuration).
+		// NOTE: Missing I-FORWARD-TSN (needed for Message Interleaving).
+		remoteSupportedExtensionsParameter->AddChunkType(RTC::SCTP::Chunk::ChunkType::I_DATA);
+		remoteSupportedExtensionsParameter->Consolidate();
+
+		auto* remoteForwardTsnSupportedParameter =
+		  remoteChunk->BuildParameterInPlace<RTC::SCTP::ForwardTsnSupportedParameter>();
+
+		remoteForwardTsnSupportedParameter->Consolidate();
+
+		auto* remoteZeroChecksumAcceptableParameter =
+		  remoteChunk->BuildParameterInPlace<RTC::SCTP::ZeroChecksumAcceptableParameter>();
+
+		remoteZeroChecksumAcceptableParameter->SetAlternateErrorDetectionMethod(
+		  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
+		  static_cast<RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod>(666));
+		remoteZeroChecksumAcceptableParameter->Consolidate();
+
+		const auto remoteCapabilities = RTC::SCTP::Capabilities::Factory(remoteChunk.get());
+
+		// Raw remote-announced values (no local option is applied).
+		REQUIRE(remoteCapabilities.maxOutboundStreams == 4000);
+		REQUIRE(remoteCapabilities.maxInboundStreams == 3000);
+		// Announced via Forward-TSN-Supported parameter.
+		REQUIRE(remoteCapabilities.partialReliability == true);
+		// Not announced (missing I-FORWARD-TSN).
+		REQUIRE(remoteCapabilities.messageInterleaving == false);
+		// Not announced (missing RE-CONFIG).
+		REQUIRE(remoteCapabilities.reConfig == false);
+		// Unknown/invalid method is parsed as NONE.
+		REQUIRE(
+		  remoteCapabilities.zeroChecksumAlternateErrorDetectionMethod ==
+		  RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::NONE);
+	}
+}

package/worker/test/src/RTC/SCTP/association/TestNegotiatedCapabilities.cpp

@@ -24,8 +24,8 @@ SCENARIO("SCTP Negotiated Capabilities", "[sctp][negotiatedcapabilities]")
 		sctpOptions.zeroChecksumAlternateErrorDetectionMethod =
 		  RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::SCTP_OVER_DTLS;
 
-		auto* remoteChunk =
-		  RTC::SCTP::InitChunk::Factory(sctpCommon::FactoryBuffer, sizeof(sctpCommon::FactoryBuffer));
+		const std::unique_ptr<RTC::SCTP::InitChunk> remoteChunk{ RTC::SCTP::InitChunk::Factory(
+			sctpCommon::FactoryBuffer, sizeof(sctpCommon::FactoryBuffer)) };
 
 		remoteChunk->SetNumberOfOutboundStreams(4096);
 		remoteChunk->SetNumberOfInboundStreams(1024);
@@ -46,13 +46,12 @@ SCENARIO("SCTP Negotiated Capabilities", "[sctp][negotiatedcapabilities]")
 		  RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::SCTP_OVER_DTLS);
 		remoteZeroChecksumAcceptableParameter->Consolidate();
 
-		auto negotiatedCapabilities =
-		  RTC::SCTP::NegotiatedCapabilities::Factory(sctpOptions, remoteChunk);
+		const auto remoteCapabilities = RTC::SCTP::Capabilities::Factory(remoteChunk.get());
+		const auto negotiatedCapabilities =
+		  RTC::SCTP::NegotiatedCapabilities::Factory(sctpOptions, remoteCapabilities);
 
-		delete remoteChunk;
-
-		REQUIRE(negotiatedCapabilities.negotiatedMaxOutboundStreams == 1024);
-		REQUIRE(negotiatedCapabilities.negotiatedMaxInboundStreams == 2048);
+		REQUIRE(negotiatedCapabilities.maxOutboundStreams == 1024);
+		REQUIRE(negotiatedCapabilities.maxInboundStreams == 2048);
 		REQUIRE(negotiatedCapabilities.partialReliability == true);
 		REQUIRE(negotiatedCapabilities.messageInterleaving == true);
 		REQUIRE(negotiatedCapabilities.reConfig == true);
@@ -70,8 +69,8 @@ SCENARIO("SCTP Negotiated Capabilities", "[sctp][negotiatedcapabilities]")
 		sctpOptions.zeroChecksumAlternateErrorDetectionMethod =
 		  RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::SCTP_OVER_DTLS;
 
-		auto* remoteChunk =
-		  RTC::SCTP::InitChunk::Factory(sctpCommon::FactoryBuffer, sizeof(sctpCommon::FactoryBuffer));
+		const std::unique_ptr<RTC::SCTP::InitChunk> remoteChunk{ RTC::SCTP::InitChunk::Factory(
+			sctpCommon::FactoryBuffer, sizeof(sctpCommon::FactoryBuffer)) };
 
 		remoteChunk->SetNumberOfOutboundStreams(4000);
 		remoteChunk->SetNumberOfInboundStreams(3000);
@@ -100,13 +99,12 @@ SCENARIO("SCTP Negotiated Capabilities", "[sctp][negotiatedcapabilities]")
 		  static_cast<RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod>(666));
 		remoteZeroChecksumAcceptableParameter->Consolidate();
 
-		auto negotiatedCapabilities =
-		  RTC::SCTP::NegotiatedCapabilities::Factory(sctpOptions, remoteChunk);
-
-		delete remoteChunk;
+		const auto remoteCapabilities = RTC::SCTP::Capabilities::Factory(remoteChunk.get());
+		const auto negotiatedCapabilities =
+		  RTC::SCTP::NegotiatedCapabilities::Factory(sctpOptions, remoteCapabilities);
 
-		REQUIRE(negotiatedCapabilities.negotiatedMaxOutboundStreams == 1000);
-		REQUIRE(negotiatedCapabilities.negotiatedMaxInboundStreams == 2000);
+		REQUIRE(negotiatedCapabilities.maxOutboundStreams == 1000);
+		REQUIRE(negotiatedCapabilities.maxInboundStreams == 2000);
 		REQUIRE(negotiatedCapabilities.partialReliability == true);
 		REQUIRE(negotiatedCapabilities.messageInterleaving == false);
 		REQUIRE(negotiatedCapabilities.reConfig == false);