mediasoup 3.21.0 → 3.21.2

package/worker/src/RTC/NEW_RTCP/packet/CompoundPacket.cpp

@@ -0,0 +1,219 @@
+#define MS_CLASS "RTC::RTCP::CompoundPacket"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/NEW_RTCP/packet/CompoundPacket.hpp"
+#include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
+#include "Utils.hpp"
+#include <cstring> // std::memmove()
+
+namespace RTC
+{
+	namespace NEW_RTCP
+	{
+		/* Class methods. */
+
+		CompoundPacket* CompoundPacket::Parse(const uint8_t* buffer, size_t bufferLength)
+		{
+			MS_TRACE();
+
+			if (!Packet::IsRtcp(buffer, bufferLength))
+			{
+				MS_WARN_TAG(rtcp, "not an RTCP compound packet");
+
+				return nullptr;
+			}
+
+			auto* compoundPacket = new CompoundPacket(const_cast<uint8_t*>(buffer), bufferLength);
+
+			// Pointer that initially points to the given data buffer and is later
+			// incremented to point to each packet within the compound packet.
+			const auto* ptr = buffer;
+
+			while (ptr < buffer + bufferLength)
+			{
+				// The remaining length in the buffer is the potential buffer length
+				// of the current packet.
+				const size_t packetMaxBufferLength = bufferLength - (ptr - buffer);
+
+				// Here we must anticipate the type of each packet to use its appropriate
+				// parser.
+				Packet::PacketType packetType;
+				size_t packetLength;
+
+				if (!Packet::IsPacket(ptr, packetMaxBufferLength, packetType, packetLength))
+				{
+					MS_WARN_TAG(rtcp, "not an RTCP packet");
+
+					delete compoundPacket;
+					return nullptr;
+				}
+
+				Packet* packet{ nullptr }; // NOLINT(misc-const-correctness)
+
+				MS_DEBUG_DEV("parsing RTCP packet [ptr:%zu, type:%" PRIu8 "]", ptr - buffer, packetType);
+
+				switch (packetType)
+				{
+					case Packet::PacketType::IJ:
+					{
+						// TODO
+						// packet = ExtendedJitterReportPacket::ParseStrict(ptr, packetLength);
+
+						break;
+					}
+
+					default:
+					{
+						// TODO
+						// packet = UnknownPacket::ParseStrict(ptr, packetLength);
+					}
+				}
+
+				if (!packet)
+				{
+					delete compoundPacket;
+					return nullptr;
+				}
+
+				compoundPacket->packets.push_back(packet);
+
+				ptr += packet->GetLength();
+			}
+
+			const size_t computedLength = ptr - buffer;
+
+			// Ensure computed length matches the total given buffer length.
+			if (computedLength != bufferLength)
+			{
+				MS_WARN_TAG(
+				  rtcp,
+				  "computed length (%zu bytes) != buffer length (%zu bytes)",
+				  computedLength,
+				  bufferLength);
+
+				delete compoundPacket;
+				return nullptr;
+			}
+
+			// It's mandatory to call SetLength() once we are done and we know the
+			// exact length of the packet.
+			compoundPacket->SetLength(computedLength);
+
+			return compoundPacket;
+		}
+
+		/* Instance methods. */
+
+		CompoundPacket::CompoundPacket(uint8_t* buffer, size_t bufferLength)
+		  : Serializable(buffer, bufferLength)
+		{
+			MS_TRACE();
+		}
+
+		CompoundPacket::~CompoundPacket()
+		{
+			MS_TRACE();
+		}
+
+		void CompoundPacket::Dump(int indentation) const
+		{
+			MS_TRACE();
+
+			MS_DUMP_CLEAN(indentation, "<RTCP::CompoundPacket>");
+			MS_DUMP_CLEAN(indentation, "  length: %zu (buffer length: %zu)", GetLength(), GetBufferLength());
+			MS_DUMP_CLEAN(indentation, "  packets count: %zu", GetPacketsCount());
+			MS_DUMP_CLEAN(
+			  indentation, "  needs consolidation of packets: %s", NeedsConsolidation() ? "yes" : "no");
+			for (const auto* packet : this->packets)
+			{
+				packet->Dump(indentation + 1);
+			}
+			MS_DUMP_CLEAN(indentation, "</RTCP::CompoundPacket>");
+		}
+
+		void CompoundPacket::Serialize(uint8_t* buffer, size_t bufferLength)
+		{
+			MS_TRACE();
+
+			const auto* previousBuffer = GetBuffer();
+
+			// Invoke the parent method to copy the whole buffer.
+			Serializable::Serialize(buffer, bufferLength);
+
+			for (auto* packet : this->packets)
+			{
+				const size_t offset = packet->GetBuffer() - previousBuffer;
+
+				packet->SoftSerialize(buffer + offset);
+			}
+		}
+
+		CompoundPacket* CompoundPacket::Clone(uint8_t* buffer, size_t bufferLength) const
+		{
+			MS_TRACE();
+
+			auto* clonedCompoundPacket = new CompoundPacket(buffer, bufferLength);
+
+			Serializable::CloneInto(clonedCompoundPacket);
+
+			// Soft clone packets into the given cloned compound packet.
+			for (auto* packet : this->packets)
+			{
+				const size_t offset = packet->GetBuffer() - GetBuffer();
+
+				auto* softClonedPacket = packet->SoftClone(buffer + offset);
+
+				clonedCompoundPacket->packets.push_back(softClonedPacket);
+			}
+
+			return clonedCompoundPacket;
+		}
+
+		void CompoundPacket::HandleInPlacePacket(Packet* packet)
+		{
+			MS_TRACE();
+
+			this->needsConsolidation = true;
+
+			// When the application completes the packet it must call
+			// `packet->Consolidate()` and that will trigger this event.
+			packet->SetConsolidatedListener(
+			  [this, packet]()
+			  {
+				  try
+				  {
+					  // NOTE: Packet class doesn't have `NeedsConsolidation()` method.
+
+					  // Fix buffer length assigned to the packet.
+					  packet->SetBufferLength(packet->GetLength());
+
+					  // Update compound packet length.
+					  // NOTE: This will throw if there is no enough space in the compound
+					  // packet buffer.
+					  SetLength(GetLength() + packet->GetLength());
+
+					  // Add the packet to the list.
+					  this->packets.push_back(packet);
+					  this->needsConsolidation = false;
+				  }
+				  catch (const MediaSoupError& error)
+				  {
+					  this->needsConsolidation = false;
+
+					  throw;
+				  }
+			  });
+		}
+
+		void CompoundPacket::AssertDoesNotNeedConsolidation() const
+		{
+			MS_TRACE();
+
+			if (this->needsConsolidation)
+			{
+				MS_THROW_ERROR("compound packet needs consolidation of some ongoing packet");
+			}
+		}
+	} // namespace NEW_RTCP
+} // namespace RTC

package/worker/src/RTC/NEW_RTCP/packet/Packet.cpp

@@ -0,0 +1,222 @@
+#define MS_CLASS "RTC::RTCP::Packet"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/NEW_RTCP/packet/Packet.hpp"
+#include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
+#include <cstring> // std::memmove()
+#include <limits>  // std::numeric_limits
+
+namespace RTC
+{
+	namespace NEW_RTCP
+	{
+		/* Class variables. */
+
+		// clang-format off
+		const ankerl::unordered_dense::map<Packet::PacketType, std::string> Packet::PacketType2String =
+		{
+			{ Packet::PacketType::IJ,    "IF"    },
+			{ Packet::PacketType::SR,    "SR"    },
+			{ Packet::PacketType::RR,    "RR"    },
+			{ Packet::PacketType::SDES,  "SDES"  },
+			{ Packet::PacketType::BYE,   "BYE"   },
+			{ Packet::PacketType::APP,   "APP"   },
+			{ Packet::PacketType::RTPFB, "RTPFB" },
+			{ Packet::PacketType::PSFB,  "PSFB"  },
+			{ Packet::PacketType::XR,    "XR"    },
+		};
+		// clang-format on
+
+		/* Class methods. */
+
+		bool Packet::IsRtcp(const uint8_t* buffer, size_t bufferLength)
+		{
+			MS_TRACE();
+
+			return (
+			  bufferLength >= Packet::CommonHeaderLength &&
+			  // @see RFC 7983.
+			  (buffer[0] > 127 && buffer[0] < 192) &&
+			  // RTP Version must be 2.
+			  (buffer[0] >> 6) == 2 &&
+			  // RTCP packet types defined by IANA:
+			  // http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml#rtp-parameters-4
+			  // RFC 5761 (RTCP-mux) states this range for secure RTCP/RTP detection.
+			  (buffer[1] >= 192 && buffer[1] <= 223) &&
+			  // RTCP packets must have a length that is a multiple of 4 bytes.
+			  Utils::Byte::IsPaddedTo4Bytes(bufferLength));
+		}
+
+		const std::string& Packet::PacketTypeToString(PacketType packetType)
+		{
+			MS_TRACE();
+
+			static const std::string Unknown("UNKNOWN");
+
+			auto it = Packet::PacketType2String.find(packetType);
+
+			if (it == Packet::PacketType2String.end())
+			{
+				return Unknown;
+			}
+
+			return it->second;
+		}
+
+		bool Packet::IsPacket(
+		  const uint8_t* buffer, size_t bufferLength, PacketType& packetType, size_t& packetLength)
+		{
+			MS_TRACE();
+
+			if (!Packet::IsRtcp(buffer, bufferLength))
+			{
+				return false;
+			}
+
+			// The padding mechanism is not implemented since it's only used when
+			// encrypting the compound packet by following the section 9.1 of RFC
+			// 3550 which absolutely nobody does (SRTCP is used instead). So packets
+			// with Padding bit set to 1 are considered invalid and rejected.
+			if ((buffer[0] >> 5) & 0x01)
+			{
+				MS_WARN_TAG(rtcp, "RTCP packet with Padding bit set to 1 not supported");
+
+				return false;
+			}
+
+			packetType   = static_cast<Packet::PacketType>(buffer[1]);
+			packetLength = (static_cast<size_t>(Utils::Byte::Get2Bytes(buffer, 2)) + 1) * 4;
+
+			if (bufferLength < packetLength)
+			{
+				MS_WARN_TAG(
+				  rtcp,
+				  "no space for announced packet length [packetType:%s, packetLength:%zu, bufferLength:%zu]",
+				  Packet::PacketTypeToString(packetType).c_str(),
+				  packetLength,
+				  bufferLength);
+
+				return false;
+			}
+
+			return true;
+		}
+
+		/* Instance methods. */
+
+		Packet::Packet(uint8_t* buffer, size_t bufferLength) : Serializable(buffer, bufferLength)
+		{
+			MS_TRACE();
+		}
+
+		Packet::~Packet()
+		{
+			MS_TRACE();
+		}
+
+		void Packet::DumpCommon(int indentation) const
+		{
+			MS_TRACE();
+
+			MS_DUMP_CLEAN(
+			  indentation,
+			  "  type: %" PRIu8 " (%s) (unknown: %s)",
+			  static_cast<uint8_t>(GetType()),
+			  Packet::PacketTypeToString(GetType()).c_str(),
+			  HasUnknownType() ? "yes" : "no");
+			MS_DUMP_CLEAN(indentation, "  length: %zu (buffer length: %zu)", GetLength(), GetBufferLength());
+			MS_DUMP_CLEAN(indentation, "  count field: %" PRIu8, GetCount());
+		}
+
+		void Packet::SoftSerialize(const uint8_t* buffer)
+		{
+			MS_TRACE();
+
+			SetBuffer(const_cast<uint8_t*>(buffer));
+		}
+
+		void Packet::SoftCloneInto(Packet* packet) const
+		{
+			MS_TRACE();
+
+			// Need to manually set Serializable length.
+			packet->SetLength(GetLength());
+		}
+
+		void Packet::InitializeHeader(PacketType packetType, uint16_t length)
+		{
+			MS_TRACE();
+
+			auto* commonHeader = GetCommonHeaderPointer();
+
+			commonHeader->version    = 2;
+			commonHeader->padding    = 0;
+			commonHeader->count      = 0;
+			commonHeader->packetType = packetType;
+
+			SetLengthField(length);
+		}
+
+		void Packet::SetLengthField(size_t length)
+		{
+			MS_TRACE();
+
+			// The Length field is the length of the RTCP packet in 32-bit words minus
+			// one, so the maximum representable packet length is (65535 + 1) * 4 bytes.
+			if (length > (std::numeric_limits<uint16_t>::max() + 1) * 4)
+			{
+				MS_THROW_TYPE_ERROR("length (%zu bytes) cannot be greater than 262144", length);
+			}
+
+			Utils::Byte::Set2Bytes(const_cast<uint8_t*>(GetBuffer()), 2, (length / 4) - 1);
+		}
+
+		void Packet::SetVariableLengthValue(const uint8_t* value, size_t valueLength)
+		{
+			MS_TRACE();
+
+			if (value == nullptr && valueLength > 0)
+			{
+				MS_THROW_TYPE_ERROR("value cannot be nullptr if valueLength is > 0");
+			}
+
+			// NOTE: This can throw.
+			SetVariableLengthValueLength(valueLength);
+
+			if (value)
+			{
+				std::memmove(GetVariableLengthValuePointer(), value, valueLength);
+			}
+		}
+
+		void Packet::SetVariableLengthValueLength(size_t valueLength)
+		{
+			MS_TRACE();
+
+			const size_t previousLength      = GetLength();
+			const size_t previousLengthField = GetLengthFieldComputed();
+			const size_t previousValueLength = GetVariableLengthValueLength();
+			const size_t newLength           = previousLengthField - previousValueLength + valueLength;
+
+			try
+			{
+				// Let's call SetLength() on parent with the new computed length.
+				// NOTE: If there is no space in the buffer for it, it will throw.
+				SetLength(newLength);
+
+				// Update length field.
+				// NOTE: This will throw if computed value is too big.
+				SetLengthField(newLength);
+			}
+			catch (const MediaSoupError& error)
+			{
+				// Rollback.
+				SetLength(previousLength);
+				SetLengthField(previousLengthField);
+
+				throw;
+			}
+		}
+	} // namespace NEW_RTCP
+} // namespace RTC

package/worker/src/RTC/RTP/Codecs/H264.cpp

@@ -178,6 +178,9 @@ namespace RTC
 					return false;
 				}
 
+				// H264 always has a single spatial layer (0).
+				context->SetCurrentSpatialLayer(0);
+
 				// Update/fix current temporal layer.
 				if (this->payloadDescriptor->temporalLayer > context->GetCurrentTemporalLayer())
 				{

package/worker/src/RTC/RTP/Codecs/VP8.cpp

@@ -348,6 +348,9 @@ namespace RTC
 					return false;
 				}
 
+				// VP8 always has a single spatial layer (0).
+				context->SetCurrentSpatialLayer(0);
+
 				// Update/fix current temporal layer.
 				if (this->payloadDescriptor->hasTlIndex && this->payloadDescriptor->tlIndex == context->GetTargetTemporalLayer())
 				{

package/worker/src/RTC/Router.cpp

@@ -442,52 +442,52 @@ namespace RTC
 	}
 
 	RTC::Transport* Router::AssertAndGetTransportById(
-	  const std::string& transportId, const std::string& message) const
+	  const std::string& transportId, const std::string& method) const
 	{
 		MS_TRACE();
 
-		auto it = this->mapTransports.find(transportId);
+		const auto it = this->mapTransports.find(transportId);
 
 		if (this->mapTransports.find(transportId) == this->mapTransports.end())
 		{
-			MS_THROW_NOT_FOUND_ERROR("Transport not found [method:%s]", message.c_str());
+			MS_THROW_NOT_FOUND_ERROR("Transport not found [method:%s]", method.c_str());
 		}
 
 		return it->second;
 	}
 
 	RTC::RtpObserver* Router::AssertAndGetRtpObserverById(
-	  const std::string& rtpObserverId, const std::string& message) const
+	  const std::string& rtpObserverId, const std::string& method) const
 	{
 		MS_TRACE();
 
-		auto it = this->mapRtpObservers.find(rtpObserverId);
+		const auto it = this->mapRtpObservers.find(rtpObserverId);
 
 		if (this->mapRtpObservers.find(rtpObserverId) == this->mapRtpObservers.end())
 		{
-			MS_THROW_NOT_FOUND_ERROR("RtpObserver not found [method:%s]", message.c_str());
+			MS_THROW_NOT_FOUND_ERROR("RtpObserver not found [method:%s]", method.c_str());
 		}
 
 		return it->second;
 	}
 
-	void Router::CheckNoTransport(const std::string& transportId, const std::string& message) const
+	void Router::CheckNoTransport(const std::string& transportId, const std::string& method) const
 	{
 		MS_TRACE();
 
 		if (this->mapTransports.contains(transportId))
 		{
-			MS_THROW_ERROR("a Transport with same id already exists [method:%s]", message.c_str());
+			MS_THROW_ERROR("a Transport with same id already exists [method:%s]", method.c_str());
 		}
 	}
 
-	void Router::CheckNoRtpObserver(const std::string& rtpObserverId, const std::string& message) const
+	void Router::CheckNoRtpObserver(const std::string& rtpObserverId, const std::string& method) const
 	{
 		MS_TRACE();
 
 		if (this->mapRtpObservers.contains(rtpObserverId))
 		{
-			MS_THROW_ERROR("an RtpObserver with same id already exists [method:%s]", message.c_str());
+			MS_THROW_ERROR("an RtpObserver with same id already exists [method:%s]", method.c_str());
 		}
 	}
 
@@ -566,7 +566,7 @@ namespace RTC
 			consumer->ProducerPaused();
 		}
 
-		auto it = this->mapProducerRtpObservers.find(producer);
+		const auto it = this->mapProducerRtpObservers.find(producer);
 
 		if (it != this->mapProducerRtpObservers.end())
 		{
@@ -590,7 +590,7 @@ namespace RTC
 			consumer->ProducerResumed();
 		}
 
-		auto it = this->mapProducerRtpObservers.find(producer);
+		const auto it = this->mapProducerRtpObservers.find(producer);
 
 		if (it != this->mapProducerRtpObservers.end())
 		{
@@ -688,7 +688,7 @@ namespace RTC
 			}
 		}
 
-		auto it = this->mapProducerRtpObservers.find(producer);
+		const auto it = this->mapProducerRtpObservers.find(producer);
 
 		if (it != this->mapProducerRtpObservers.end())
 		{
@@ -1076,7 +1076,7 @@ namespace RTC
 	RTC::Producer* Router::RtpObserverGetProducer(
 	  RTC::RtpObserver* /* rtpObserver */, const std::string& id)
 	{
-		auto it = this->mapProducers.find(id);
+		const auto it = this->mapProducers.find(id);
 
 		if (it == this->mapProducers.end())
 		{

package/worker/src/RTC/SCTP/association/Association.cpp

@@ -3,6 +3,7 @@
 
 #include "RTC/SCTP/association/Association.hpp"
 #include "Logger.hpp"
+#include "RTC/SCTP/association/Capabilities.hpp"
 #include "RTC/SCTP/packet/errorCauses/CookieReceivedWhileShuttingDownErrorCause.hpp"
 #include "RTC/SCTP/packet/errorCauses/NoUserDataErrorCause.hpp"
 #include "RTC/SCTP/packet/errorCauses/OutOfResourceErrorCause.hpp"
@@ -615,7 +616,7 @@ namespace RTC
 
 			if (this->tcb)
 			{
-				return this->tcb->GetNegotiatedCapabilities().negotiatedMaxOutboundStreams;
+				return this->tcb->GetNegotiatedCapabilities().maxOutboundStreams;
 			}
 			else
 			{
@@ -629,7 +630,7 @@ namespace RTC
 
 			if (this->tcb)
 			{
-				return this->tcb->GetNegotiatedCapabilities().negotiatedMaxInboundStreams;
+				return this->tcb->GetNegotiatedCapabilities().maxInboundStreams;
 			}
 			else
 			{
@@ -780,11 +781,9 @@ namespace RTC
 				  return this->state == State::ESTABLISHED;
 			  });
 
-			this->privateMetrics.negotiatedMaxOutboundStreams =
-			  negotiatedCapabilities.negotiatedMaxOutboundStreams;
-			this->privateMetrics.negotiatedMaxInboundStreams =
-			  negotiatedCapabilities.negotiatedMaxInboundStreams;
-			this->privateMetrics.usesPartialReliability  = negotiatedCapabilities.partialReliability;
+			this->privateMetrics.negotiatedMaxOutboundStreams = negotiatedCapabilities.maxOutboundStreams;
+			this->privateMetrics.negotiatedMaxInboundStreams  = negotiatedCapabilities.maxInboundStreams;
+			this->privateMetrics.usesPartialReliability       = negotiatedCapabilities.partialReliability;
 			this->privateMetrics.usesMessageInterleaving = negotiatedCapabilities.messageInterleaving;
 			this->privateMetrics.usesReConfig            = negotiatedCapabilities.reConfig;
 			this->privateMetrics.usesZeroChecksum        = negotiatedCapabilities.zeroChecksum;
@@ -1564,8 +1563,13 @@ namespace RTC
 			// Insert a StateCookieParameter in the INIT-ACK chunk.
 			auto* stateCookieParameter = initAckChunk->BuildParameterInPlace<StateCookieParameter>();
 
+			// The raw capabilities announced by the remote endpoint are stored in the
+			// cookie (not the negotiated ones). This way, when the COOKIE-ECHO is
+			// received they are re-negotiated against our local options, limiting the
+			// effect of a tampered/forged cookie.
+			const auto remoteCapabilities = Capabilities::Factory(receivedInitChunk);
 			const auto negotiatedCapabilities =
-			  NegotiatedCapabilities::Factory(this->sctpOptions, receivedInitChunk);
+			  NegotiatedCapabilities::Factory(this->sctpOptions, remoteCapabilities);
 
 			// When authentication is enabled, generate an authenticated cookie with a
 			// creation timestamp and a MAC keyed with our per-association secret.
@@ -1581,7 +1585,7 @@ namespace RTC
 			  receivedInitChunk->GetInitialTsn(),
 			  receivedInitChunk->GetAdvertisedReceiverWindowCredit(),
 			  tieTag,
-			  negotiatedCapabilities,
+			  remoteCapabilities,
 			  /*creationTimestampMs*/ authenticateCookie ? this->shared->GetTimeMs() : 0,
 			  /*macKey*/ authenticateCookie ? this->stateCookieSecret : nullptr,
 			  /*macKeyLength*/ authenticateCookie ? Association::StateCookieSecretLength : 0);
@@ -1652,8 +1656,9 @@ namespace RTC
 
 			this->t1InitTimer->Stop();
 
+			const auto remoteCapabilities = Capabilities::Factory(receivedInitAckChunk);
 			const auto negotiatedCapabilities =
-			  NegotiatedCapabilities::Factory(this->sctpOptions, receivedInitAckChunk);
+			  NegotiatedCapabilities::Factory(this->sctpOptions, remoteCapabilities);
 
 			// If the association is re-established (peer restarted, but re-used old
 			// association), make sure that all message identifiers are reset and any
@@ -1774,6 +1779,13 @@ namespace RTC
 				// WebRTC, but is a valid operation on the SCTP level.
 				this->sendQueue.Reset();
 
+				// Re-negotiate the raw capabilities stored in the cookie against our
+				// local options. This limits the effect of a tampered/forged cookie
+				// since it can never enable an extension we didn't signal nor raise
+				// the stream limits above what we announced.
+				const auto negotiatedCapabilities =
+				  NegotiatedCapabilities::Factory(this->sctpOptions, cookie->GetRemoteCapabilities());
+
 				CreateTransmissionControlBlock(
 				  cookie->GetLocalVerificationTag(),
 				  cookie->GetRemoteVerificationTag(),
@@ -1781,7 +1793,7 @@ namespace RTC
 				  cookie->GetRemoteInitialTsn(),
 				  cookie->GetRemoteAdvertisedReceiverWindowCredit(),
 				  /*tieTag*/ Utils::Crypto::GetRandomUInt<uint64_t>(0, MaxTieTag),
-				  cookie->GetNegotiatedCapabilities());
+				  negotiatedCapabilities);
 			}
 
 			// https://datatracker.ietf.org/doc/html/rfc9260#section-5.1