mediasoup 3.21.0 → 3.21.2

package/worker/src/RTC/Transport.cpp

@@ -1401,6 +1401,10 @@ namespace RTC
 
 				if (this->sctpAssociation)
 				{
+					// NOTE: This must be called after removing data consumers from the maps,
+					// otherwise if `OnAssociationStreamBufferedAmountLow()` was triggered it
+					// would end up emitting an event associated to an already closed data
+					// consumer.
 					this->sctpAssociation->ResetStreams(
 					  std::array<uint16_t, 1>{ dataConsumer->GetSctpStreamParameters().streamId });
 				}
@@ -1760,30 +1764,30 @@ namespace RTC
 	}
 
 	RTC::Producer* Transport::AssertAndGetProducerById(
-	  const std::string& producerId, const std::string& message) const
+	  const std::string& producerId, const std::string& method) const
 	{
 		MS_TRACE();
 
-		auto it = this->mapProducers.find(producerId);
+		const auto it = this->mapProducers.find(producerId);
 
 		if (it == this->mapProducers.end())
 		{
-			MS_THROW_NOT_FOUND_ERROR("Producer not found [method:%s]", message.c_str());
+			MS_THROW_NOT_FOUND_ERROR("Producer not found [method:%s]", method.c_str());
 		}
 
 		return it->second;
 	}
 
 	RTC::Consumer* Transport::AssertAndGetConsumerById(
-	  const std::string& consumerId, const std::string& message) const
+	  const std::string& consumerId, const std::string& method) const
 	{
 		MS_TRACE();
 
-		auto it = this->mapConsumers.find(consumerId);
+		const auto it = this->mapConsumers.find(consumerId);
 
 		if (it == this->mapConsumers.end())
 		{
-			MS_THROW_NOT_FOUND_ERROR("Consumer not found [method:%s]", message.c_str());
+			MS_THROW_NOT_FOUND_ERROR("Consumer not found [method:%s]", method.c_str());
 		}
 
 		return it->second;
@@ -1793,7 +1797,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		auto mapSsrcConsumerIt = this->mapSsrcConsumer.find(ssrc);
+		const auto mapSsrcConsumerIt = this->mapSsrcConsumer.find(ssrc);
 
 		if (mapSsrcConsumerIt == this->mapSsrcConsumer.end())
 		{
@@ -1809,7 +1813,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		auto mapRtxSsrcConsumerIt = this->mapRtxSsrcConsumer.find(ssrc);
+		const auto mapRtxSsrcConsumerIt = this->mapRtxSsrcConsumer.find(ssrc);
 
 		if (mapRtxSsrcConsumerIt == this->mapRtxSsrcConsumer.end())
 		{
@@ -1822,92 +1826,92 @@ namespace RTC
 	}
 
 	RTC::DataProducer* Transport::AssertAndGetDataProducerById(
-	  const std::string& dataProducerId, const std::string& message) const
+	  const std::string& dataProducerId, const std::string& method) const
 	{
 		MS_TRACE();
 
-		auto it = this->mapDataProducers.find(dataProducerId);
+		const auto it = this->mapDataProducers.find(dataProducerId);
 
 		if (it == this->mapDataProducers.end())
 		{
-			MS_THROW_NOT_FOUND_ERROR("DataProducer not found [method:%s]", message.c_str());
+			MS_THROW_NOT_FOUND_ERROR("DataProducer not found [method:%s]", method.c_str());
 		}
 
 		return it->second;
 	}
 
 	RTC::DataConsumer* Transport::AssertAndGetDataConsumerById(
-	  const std::string& dataConsumerId, const std::string& message) const
+	  const std::string& dataConsumerId, const std::string& method) const
 	{
 		MS_TRACE();
 
-		auto it = this->mapDataConsumers.find(dataConsumerId);
+		const auto it = this->mapDataConsumers.find(dataConsumerId);
 
 		if (it == this->mapDataConsumers.end())
 		{
-			MS_THROW_NOT_FOUND_ERROR("DataConsumer not found [method:%s]", message.c_str());
+			MS_THROW_NOT_FOUND_ERROR("DataConsumer not found [method:%s]", method.c_str());
 		}
 
 		return it->second;
 	}
 
-	RTC::DataConsumer* Transport::AssertAndGetSctpDataConsumerByStreamId(uint16_t streamId) const
+	RTC::DataConsumer* Transport::GetSctpDataConsumerByStreamId(uint16_t streamId) const
 	{
 		MS_TRACE();
 
-		auto it = this->mapSctpStreamIdDataConsumers.find(streamId);
+		const auto it = this->mapSctpStreamIdDataConsumers.find(streamId);
 
 		if (it == this->mapSctpStreamIdDataConsumers.end())
 		{
-			MS_THROW_NOT_FOUND_ERROR("SCTP DataConsumer with streamId %" PRIu16 " not found", streamId);
+			return nullptr;
 		}
 
 		return it->second;
 	}
 
-	void Transport::CheckNoProducer(const std::string& producerId, const std::string& message) const
+	void Transport::CheckNoProducer(const std::string& producerId, const std::string& method) const
 	{
 		MS_TRACE();
 
 		if (this->mapProducers.contains(producerId))
 		{
-			MS_THROW_ERROR("a Producer with same producerId already exists [method:%s]", message.c_str());
+			MS_THROW_ERROR("a Producer with same producerId already exists [method:%s]", method.c_str());
 		}
 	}
 
-	void Transport::CheckNoConsumer(const std::string& dataConsumerId, const std::string& message) const
+	void Transport::CheckNoConsumer(const std::string& dataConsumerId, const std::string& method) const
 	{
 		MS_TRACE();
 
 		if (this->mapConsumers.contains(dataConsumerId))
 		{
-			MS_THROW_ERROR("a Consumer with same consumerId already exists [method:%s]", message.c_str());
+			MS_THROW_ERROR("a Consumer with same consumerId already exists [method:%s]", method.c_str());
 		}
 	}
 
-	void Transport::CheckNoDataProducer(const std::string& dataProducerId, const std::string& message) const
+	void Transport::CheckNoDataProducer(const std::string& dataProducerId, const std::string& method) const
 	{
 		MS_TRACE();
 
 		if (this->mapDataProducers.contains(dataProducerId))
 		{
 			MS_THROW_ERROR(
-			  "a DataProducer with same dataProducerId already exists [method:%s]", message.c_str());
+			  "a DataProducer with same dataProducerId already exists [method:%s]", method.c_str());
 		}
 	}
 
-	void Transport::CheckNoDataConsumer(const std::string& dataConsumerId, const std::string& message) const
+	void Transport::CheckNoDataConsumer(const std::string& dataConsumerId, const std::string& method) const
 	{
 		MS_TRACE();
 
 		if (this->mapDataConsumers.contains(dataConsumerId))
 		{
 			MS_THROW_ERROR(
-			  "a DataConsumer with same dataConsumerId already exists [method:%s]", message.c_str());
+			  "a DataConsumer with same dataConsumerId already exists [method:%s]", method.c_str());
 		}
 	}
 
-	void Transport::CheckNoSctpDataConsumer(uint16_t streamId, const std::string& message) const
+	void Transport::CheckNoSctpDataConsumer(uint16_t streamId, const std::string& method) const
 	{
 		MS_TRACE();
 
@@ -1916,7 +1920,7 @@ namespace RTC
 			MS_THROW_ERROR(
 			  "an SCTP DataConsumer with same streamId %" PRIu16 " already exists [method:%s]",
 			  streamId,
-			  message.c_str());
+			  method.c_str());
 		}
 	}
 
@@ -2938,6 +2942,10 @@ namespace RTC
 			this->mapSctpStreamIdDataConsumers.erase(dataConsumer->GetSctpStreamParameters().streamId);
 		}
 
+		// NOTE: This must be called after removing the data consumer from the maps,
+		// otherwise if `OnAssociationStreamBufferedAmountLow()` was triggered it
+		// would end up emitting an event associated to an already closed data
+		// consumer.
 		if (this->sctpAssociation)
 		{
 			this->sctpAssociation->ResetStreams(
@@ -3247,8 +3255,6 @@ namespace RTC
 
 			if (!dataConsumersToClose.empty())
 			{
-				this->sctpAssociation->ResetStreams(streamsToReset);
-
 				for (auto* dataConsumer : dataConsumersToClose)
 				{
 					// Remove it from the maps.
@@ -3271,6 +3277,12 @@ namespace RTC
 					// Delete it.
 					delete dataConsumer;
 				}
+
+				// NOTE: This must be called after removing data consumers from the maps,
+				// otherwise if `OnAssociationStreamBufferedAmountLow()` was triggered it
+				// would end up emitting an event associated to an already closed data
+				// consumer.
+				this->sctpAssociation->ResetStreams(streamsToReset);
 			}
 		}
 	}
@@ -3279,7 +3291,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		const auto* dataConsumer = AssertAndGetSctpDataConsumerByStreamId(streamId);
+		const auto* dataConsumer = GetSctpDataConsumerByStreamId(streamId);
 
 		if (!dataConsumer)
 		{

package/worker/src/Worker.cpp

@@ -184,52 +184,52 @@ flatbuffers::Offset<FBS::Worker::ResourceUsageResponse> Worker::FillBufferResour
 }
 
 RTC::WebRtcServer* Worker::AssertAndGetWebRtcServerById(
-  const std::string& webRtcServerId, const std::string& message) const
+  const std::string& webRtcServerId, const std::string& method) const
 {
 	MS_TRACE();
 
-	auto it = this->mapWebRtcServers.find(webRtcServerId);
+	const auto it = this->mapWebRtcServers.find(webRtcServerId);
 
 	if (it == this->mapWebRtcServers.end())
 	{
-		MS_THROW_NOT_FOUND_ERROR("WebRtcServer not found [method:%s]", message.c_str());
+		MS_THROW_NOT_FOUND_ERROR("WebRtcServer not found [method:%s]", method.c_str());
 	}
 
 	return it->second;
 }
 
-RTC::Router* Worker::AssertAndGetRouterById(const std::string& routerId, const std::string& message) const
+RTC::Router* Worker::AssertAndGetRouterById(const std::string& routerId, const std::string& method) const
 {
 	MS_TRACE();
 
-	auto it = this->mapRouters.find(routerId);
+	const auto it = this->mapRouters.find(routerId);
 
 	if (it == this->mapRouters.end())
 	{
-		MS_THROW_NOT_FOUND_ERROR("Router not found [method:%s]", message.c_str());
+		MS_THROW_NOT_FOUND_ERROR("Router not found [method:%s]", method.c_str());
 	}
 
 	return it->second;
 }
 
-void Worker::CheckNoWebRtcServer(const std::string& webRtcServerId, const std::string& message) const
+void Worker::CheckNoWebRtcServer(const std::string& webRtcServerId, const std::string& method) const
 {
 	MS_TRACE();
 
 	if (this->mapWebRtcServers.find(webRtcServerId) != this->mapWebRtcServers.end())
 	{
 		MS_THROW_ERROR(
-		  "a WebRtcServer with same webRtcServerId already exists [method:%s]", message.c_str());
+		  "a WebRtcServer with same webRtcServerId already exists [method:%s]", method.c_str());
 	}
 }
 
-void Worker::CheckNoRouter(const std::string& routerId, const std::string& message) const
+void Worker::CheckNoRouter(const std::string& routerId, const std::string& method) const
 {
 	MS_TRACE();
 
 	if (this->mapRouters.find(routerId) != this->mapRouters.end())
 	{
-		MS_THROW_ERROR("a Router with same routerId already exists [method:%s]", message.c_str());
+		MS_THROW_ERROR("a Router with same routerId already exists [method:%s]", method.c_str());
 	}
 }
 

package/worker/test/include/RTC/ICE/iceCommon.hpp

@@ -57,7 +57,7 @@ namespace iceCommon
 	{                                                                                                   \
 		uint8_t* originalBuffer = static_cast<uint8_t*>(std::malloc(bufferLength));                       \
 		std::memcpy(originalBuffer, buffer, bufferLength);                                                \
-		REQUIRE(RTC::ICE::StunPacket::IsStun(buffer, bufferLength) == true);                              \
+		REQUIRE(RTC::ICE::StunPacket::IsStun(buffer, length) == true);                                    \
 		REQUIRE(packet);                                                                                  \
 		REQUIRE(packet->GetBuffer() != nullptr);                                                          \
 		REQUIRE(packet->GetBuffer() == buffer);                                                           \

package/worker/test/include/RTC/RTCP/rtcpCommon.hpp

@@ -0,0 +1,58 @@
+#ifndef MS_TEST_RTC_RTCP_COMMON_HPP
+#define MS_TEST_RTC_RTCP_COMMON_HPP
+
+#include "common.hpp"
+#include "MediaSoupErrors.hpp"
+#include "RTC/NEW_RTCP/packet/Packet.hpp"
+#include "Utils.hpp"
+#include "test/include/testHelpers.hpp"
+#include <catch2/catch_test_macros.hpp>
+#include <cstdlib> // std::malloc(), std::free()
+#include <cstring> // std::memcpy()
+
+namespace rtcpCommon
+{
+	// NOTE: We need to declare them here with `extern` and then define them in
+	// rtcpCommon.cpp.
+	// NOTE: Random size buffers because anyway we use sizeof(XxxxBuffer).
+	extern thread_local uint8_t FactoryBuffer[66661];
+	extern thread_local uint8_t SerializeBuffer[66662];
+	extern thread_local uint8_t CloneBuffer[66663];
+	extern thread_local uint8_t DataBuffer[66664];
+	extern thread_local uint8_t ThrowBuffer[66665];
+
+	void ResetBuffers();
+} // namespace rtcpCommon
+
+// NOLINTNEXTLINE (cppcoreguidelines-macro-usage)
+#define CHECK_RTCP_PACKET(                                                                         \
+  /*const RTC::RTCP::Packet**/ packet,                                                             \
+  /*const uint8_t**/ buffer,                                                                       \
+  /*size_t*/ bufferLength,                                                                         \
+  /*size_t*/ length,                                                                               \
+  /*RTC::RTCP::Packet::PacketType*/ packetType,                                                    \
+  /*bool*/ unknownType)                                                                            \
+	do                                                                                               \
+	{                                                                                                \
+		uint8_t* originalBuffer = static_cast<uint8_t*>(std::malloc(bufferLength));                    \
+		std::memcpy(originalBuffer, buffer, bufferLength);                                             \
+		REQUIRE(RTC::NEW_RTCP::Packet::IsRtcp(buffer, length) == true);                                \
+		REQUIRE(packet);                                                                               \
+		REQUIRE(packet->GetBuffer() != nullptr);                                                       \
+		REQUIRE(packet->GetBuffer() == buffer);                                                        \
+		REQUIRE(packet->GetBufferLength() != 0);                                                       \
+		REQUIRE(packet->GetBufferLength() == bufferLength);                                            \
+		REQUIRE(packet->GetLength() != 0);                                                             \
+		REQUIRE(packet->GetLength() == length);                                                        \
+		REQUIRE(packet->GetAvailableLength() == packet->GetBufferLength() - packet->GetLength());      \
+		REQUIRE(Utils::Byte::IsPaddedTo4Bytes(packet->GetLength()) == true);                           \
+		REQUIRE(static_cast<unsigned>(packet->GetVersion()) == 2);                                     \
+		REQUIRE(packet->GetType() == packetType);                                                      \
+		REQUIRE(packet->HasUnknownType() == unknownType);                                              \
+		REQUIRE(packet->HasPadding() == false);                                                        \
+		REQUIRE_THROWS_AS(packet->Serialize(rtcpCommon::ThrowBuffer, length - 1), MediaSoupError);     \
+		REQUIRE_THROWS_AS(packet->Clone(rtcpCommon::ThrowBuffer, length - 1), MediaSoupError);         \
+		std::free(originalBuffer);                                                                     \
+	} while (false)
+
+#endif

package/worker/test/include/RTC/RTP/rtpCommon.hpp

@@ -47,7 +47,7 @@ namespace rtpCommon
 	{                                                                                                  \
 		uint8_t* originalBuffer = static_cast<uint8_t*>(std::malloc(bufferLength));                      \
 		std::memcpy(originalBuffer, buffer, bufferLength);                                               \
-		REQUIRE(RTC::RTP::Packet::IsRtp(buffer, bufferLength) == true);                                  \
+		REQUIRE(RTC::RTP::Packet::IsRtp(buffer, length) == true);                                        \
 		REQUIRE(packet);                                                                                 \
 		REQUIRE(packet->GetBuffer() != nullptr);                                                         \
 		REQUIRE(packet->GetBuffer() == buffer);                                                          \

package/worker/test/src/RTC/NEW_RTCP/packet/TestByePacket.cpp

@@ -0,0 +1,302 @@
+#include "common.hpp"
+#include "MediaSoupErrors.hpp"
+#include "RTC/NEW_RTCP/packet/ByePacket.hpp"
+#include "test/include/RTC/RTCP/rtcpCommon.hpp"
+#include <catch2/catch_test_macros.hpp>
+#include <cstring> // std::memset()
+#include <vector>
+
+SCENARIO("RTCP Bye Packet (203)", "[serializable][rtcp]")
+{
+	rtcpCommon::ResetBuffers();
+
+	SECTION("ByePacket::Parse() succeeds")
+	{
+		// clang-format off
+		alignas(4) uint8_t buffer[] =
+		{
+			// V=2, P=0, SC=3, PT:203, Length: 5
+			0b10000011, 0xCB, 0x00, 0x05,
+			// SSRC 1: 1111111
+			0x00, 0x10, 0xF4, 0x47,
+			// SSRC 2: 2222222
+			0x00, 0x21, 0xE8, 0x8E,
+			// SSRC 3: 12345678
+			0x00, 0xBC, 0x61, 0x4E,
+			// Reason length: 6, Reason: "foo"
+			0x06, 0x66, 0x6F, 0x6F,
+			// Reason: "bar", 1 byte of padding
+			0x62, 0x61, 0x72, 0x00
+		};
+		// clang-format on
+
+		std::unique_ptr<RTC::NEW_RTCP::ByePacket> packet{ RTC::NEW_RTCP::ByePacket::Parse(
+			buffer, sizeof(buffer)) };
+
+		CHECK_RTCP_PACKET(
+		  /*packet*/ packet.get(),
+		  /*buffer*/ buffer,
+		  /*bufferLength*/ sizeof(buffer),
+		  /*length*/ 24,
+		  /*packetType*/ RTC::NEW_RTCP::Packet::PacketType::BYE,
+		  /*unknownType*/ false);
+
+		REQUIRE(packet->GetSsrcs() == std::vector<uint32_t>{ 1111111, 2222222, 12345678 });
+		REQUIRE(packet->HasReason() == true);
+		REQUIRE(packet->GetReason() == "foobar");
+		// Check padding bytes.
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 1] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 2] == 'r');
+
+		// No space to add more ssrcs.
+		REQUIRE_THROWS_AS(packet->AddSsrc(3333), MediaSoupTypeError);
+		// No space for a reason larger than the current one.
+		REQUIRE_THROWS_AS(packet->SetReason("lolololo"), MediaSoupTypeError);
+
+		/* Serialize it. */
+
+		packet->Serialize(rtcpCommon::SerializeBuffer, sizeof(rtcpCommon::SerializeBuffer));
+
+		std::memset(buffer, 0xFF, sizeof(buffer));
+
+		CHECK_RTCP_PACKET(
+		  /*packet*/ packet.get(),
+		  /*buffer*/ rtcpCommon::SerializeBuffer,
+		  /*bufferLength*/ sizeof(rtcpCommon::SerializeBuffer),
+		  /*length*/ 24,
+		  /*packetType*/ RTC::NEW_RTCP::Packet::PacketType::BYE,
+		  /*unknownType*/ false);
+
+		REQUIRE(packet->GetSsrcs() == std::vector<uint32_t>{ 1111111, 2222222, 12345678 });
+		REQUIRE(packet->HasReason() == true);
+		REQUIRE(packet->GetReason() == "foobar");
+		// Check padding bytes.
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 1] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 2] == 'r');
+
+		/* Clone it. */
+
+		packet.reset(packet->Clone(rtcpCommon::CloneBuffer, sizeof(rtcpCommon::CloneBuffer)));
+
+		std::memset(rtcpCommon::SerializeBuffer, 0xFF, sizeof(rtcpCommon::SerializeBuffer));
+
+		CHECK_RTCP_PACKET(
+		  /*packet*/ packet.get(),
+		  /*buffer*/ rtcpCommon::CloneBuffer,
+		  /*bufferLength*/ sizeof(rtcpCommon::CloneBuffer),
+		  /*length*/ 24,
+		  /*packetType*/ RTC::NEW_RTCP::Packet::PacketType::BYE,
+		  /*unknownType*/ false);
+
+		REQUIRE(packet->GetSsrcs() == std::vector<uint32_t>{ 1111111, 2222222, 12345678 });
+		REQUIRE(packet->HasReason() == true);
+		REQUIRE(packet->GetReason() == "foobar");
+		// Check padding bytes.
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 1] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 2] == 'r');
+
+		/* Modify it. */
+
+		packet->AddSsrc(3333);
+
+		CHECK_RTCP_PACKET(
+		  /*packet*/ packet.get(),
+		  /*buffer*/ rtcpCommon::CloneBuffer,
+		  /*bufferLength*/ sizeof(rtcpCommon::CloneBuffer),
+		  /*length*/ 28,
+		  /*packetType*/ RTC::NEW_RTCP::Packet::PacketType::BYE,
+		  /*unknownType*/ false);
+
+		REQUIRE(packet->GetSsrcs() == std::vector<uint32_t>{ 1111111, 2222222, 12345678, 3333 });
+		REQUIRE(packet->HasReason() == true);
+		REQUIRE(packet->GetReason() == "foobar");
+		// Check padding bytes.
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 1] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 2] == 'r');
+
+		packet->SetReason("");
+
+		CHECK_RTCP_PACKET(
+		  /*packet*/ packet.get(),
+		  /*buffer*/ rtcpCommon::CloneBuffer,
+		  /*bufferLength*/ sizeof(rtcpCommon::CloneBuffer),
+		  /*length*/ 20,
+		  /*packetType*/ RTC::NEW_RTCP::Packet::PacketType::BYE,
+		  /*unknownType*/ false);
+
+		REQUIRE(packet->GetSsrcs() == std::vector<uint32_t>{ 1111111, 2222222, 12345678, 3333 });
+		REQUIRE(packet->HasReason() == false);
+		REQUIRE(packet->GetReason().empty());
+
+		packet->SetReason("abcde");
+
+		CHECK_RTCP_PACKET(
+		  /*packet*/ packet.get(),
+		  /*buffer*/ rtcpCommon::CloneBuffer,
+		  /*bufferLength*/ sizeof(rtcpCommon::CloneBuffer),
+		  /*length*/ 28,
+		  /*packetType*/ RTC::NEW_RTCP::Packet::PacketType::BYE,
+		  /*unknownType*/ false);
+
+		REQUIRE(packet->GetSsrcs() == std::vector<uint32_t>{ 1111111, 2222222, 12345678, 3333 });
+		REQUIRE(packet->HasReason() == true);
+		REQUIRE(packet->GetReason() == "abcde");
+		// Check padding bytes.
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 1] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 2] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 3] == 'e');
+	}
+
+	SECTION("ByePacket::Parse() fails")
+	{
+		// Length field should be 5 (24 bytes).
+		// clang-format off
+		alignas(4) uint8_t buffer1[] =
+		{
+			// V=2, P=0, SC=3, PT:203, Length: 6
+			0b10000011, 0xCB, 0x00, 0x06,
+			// SSRC 1: 1111111
+			0x00, 0x10, 0xF4, 0x47,
+			// SSRC 2: 2222222
+			0x00, 0x21, 0xE8, 0x8E,
+			// SSRC 3: 12345678
+			0x00, 0xBC, 0x61, 0x4E,
+			// Reason length: 6, Reason: "foo"
+			0x06, 0x66, 0x6F, 0x6F,
+			// Reason: "bar", 1 byte of padding
+			0x62, 0x61, 0x72, 0x00
+		};
+		// clang-format on
+
+		REQUIRE(!RTC::NEW_RTCP::ByePacket::Parse(buffer1, sizeof(buffer1)));
+
+		// SC should be 3 instead of 4 (first byte should be 0b10000011). So the parser ends
+		// reading a wrong value of the Reason length field and fails.
+		// clang-format off
+		alignas(4) uint8_t buffer2[] =
+		{
+			// V=2, P=0, SC=3, PT:203, Length: 5
+			0b10000100, 0xCB, 0x00, 0x05,
+			// SSRC 1: 1111111
+			0x00, 0x10, 0xF4, 0x47,
+			// SSRC 2: 2222222
+			0x00, 0x21, 0xE8, 0x8E,
+			// SSRC 3: 12345678
+			0x00, 0xBC, 0x61, 0x4E,
+			// Reason length: 6, Reason: "foo"
+			0x06, 0x66, 0x6F, 0x6F,
+			// Reason: "bar", 1 byte of padding
+			0x62, 0x61, 0x72, 0x00
+		};
+		// clang-format on
+
+		REQUIRE(!RTC::NEW_RTCP::ByePacket::Parse(buffer2, sizeof(buffer2)));
+
+		// Parse() called with less buffer length than needed.
+		// clang-format off
+		alignas(4) uint8_t buffer3[] =
+		{
+			// V=2, P=0, SC=3, PT:203, Length: 5
+			0b10000011, 0xCB, 0x00, 0x05,
+			// SSRC 1: 1111111
+			0x00, 0x10, 0xF4, 0x47,
+			// SSRC 2: 2222222
+			0x00, 0x21, 0xE8, 0x8E,
+			// SSRC 3: 12345678
+			0x00, 0xBC, 0x61, 0x4E,
+			// Reason length: 6, Reason: "foo"
+			0x06, 0x66, 0x6F, 0x6F,
+			// Reason: "bar", 1 byte of padding
+			0x62, 0x61, 0x72, 0x00
+		};
+		// clang-format on
+
+		REQUIRE(!RTC::NEW_RTCP::ByePacket::Parse(buffer3, sizeof(buffer3) - 1));
+	}
+
+	SECTION("ByePacket::Factory() succeeds")
+	{
+		std::unique_ptr<RTC::NEW_RTCP::ByePacket> packet{ RTC::NEW_RTCP::ByePacket::Factory(
+			rtcpCommon::FactoryBuffer, sizeof(rtcpCommon::FactoryBuffer)) };
+
+		CHECK_RTCP_PACKET(
+		  /*packet*/ packet.get(),
+		  /*buffer*/ rtcpCommon::FactoryBuffer,
+		  /*bufferLength*/ sizeof(rtcpCommon::FactoryBuffer),
+		  /*length*/ 4,
+		  /*packetType*/ RTC::NEW_RTCP::Packet::PacketType::BYE,
+		  /*unknownType*/ false);
+
+		REQUIRE(packet->GetSsrcs().empty());
+		REQUIRE(packet->HasReason() == false);
+		REQUIRE(packet->GetReason().empty());
+
+		/* Modify it. */
+
+		packet->AddSsrc(1111);
+		packet->AddSsrc(2222);
+		// Reason string is 25 bytes, so padded(1 + 25) is needed = 28 bytes.
+		packet->SetReason("amazing reason, isn't it?");
+		packet->AddSsrc(3333);
+
+		CHECK_RTCP_PACKET(
+		  /*packet*/ packet.get(),
+		  /*buffer*/ rtcpCommon::FactoryBuffer,
+		  /*bufferLength*/ sizeof(rtcpCommon::FactoryBuffer),
+		  /*length*/ 4 + 4 + 4 + 4 + 28,
+		  /*packetType*/ RTC::NEW_RTCP::Packet::PacketType::BYE,
+		  /*unknownType*/ false);
+
+		REQUIRE(packet->GetSsrcs() == std::vector<uint32_t>{ 1111, 2222, 3333 });
+		REQUIRE(packet->HasReason() == true);
+		REQUIRE(packet->GetReason() == "amazing reason, isn't it?");
+		// Check padding bytes.
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 1] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 2] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 3] == '?');
+
+		/* Serialize it. */
+
+		packet->Serialize(rtcpCommon::SerializeBuffer, sizeof(rtcpCommon::SerializeBuffer));
+
+		std::memset(rtcpCommon::FactoryBuffer, 0xFF, sizeof(rtcpCommon::FactoryBuffer));
+
+		CHECK_RTCP_PACKET(
+		  /*packet*/ packet.get(),
+		  /*buffer*/ rtcpCommon::SerializeBuffer,
+		  /*bufferLength*/ sizeof(rtcpCommon::SerializeBuffer),
+		  /*length*/ 4 + 4 + 4 + 4 + 28,
+		  /*packetType*/ RTC::NEW_RTCP::Packet::PacketType::BYE,
+		  /*unknownType*/ false);
+
+		REQUIRE(packet->GetSsrcs() == std::vector<uint32_t>{ 1111, 2222, 3333 });
+		REQUIRE(packet->HasReason() == true);
+		REQUIRE(packet->GetReason() == "amazing reason, isn't it?");
+		// Check padding bytes.
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 1] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 2] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 3] == '?');
+
+		/* Clone it. */
+
+		packet.reset(packet->Clone(rtcpCommon::CloneBuffer, sizeof(rtcpCommon::CloneBuffer)));
+
+		std::memset(rtcpCommon::SerializeBuffer, 0xFF, sizeof(rtcpCommon::SerializeBuffer));
+
+		CHECK_RTCP_PACKET(
+		  /*packet*/ packet.get(),
+		  /*buffer*/ rtcpCommon::CloneBuffer,
+		  /*bufferLength*/ sizeof(rtcpCommon::CloneBuffer),
+		  /*length*/ 4 + 4 + 4 + 4 + 28,
+		  /*packetType*/ RTC::NEW_RTCP::Packet::PacketType::BYE,
+		  /*unknownType*/ false);
+
+		REQUIRE(packet->GetSsrcs() == std::vector<uint32_t>{ 1111, 2222, 3333 });
+		REQUIRE(packet->HasReason() == true);
+		REQUIRE(packet->GetReason() == "amazing reason, isn't it?");
+		// Check padding bytes.
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 1] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 2] == 0);
+		REQUIRE(packet->GetBuffer()[packet->GetLength() - 3] == '?');
+	}
+}