mediasoup 3.21.0 → 3.21.2

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

@@ -0,0 +1,87 @@
+#define MS_CLASS "RTC::SCTP::Capabilities"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/SCTP/association/Capabilities.hpp"
+#include "Logger.hpp"
+#include "RTC/SCTP/packet/Chunk.hpp"
+#include "RTC/SCTP/packet/parameters/ForwardTsnSupportedParameter.hpp"
+#include "RTC/SCTP/packet/parameters/SupportedExtensionsParameter.hpp"
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/* Class methods. */
+
+		Capabilities Capabilities::Factory(const AnyInitChunk* remoteChunk)
+		{
+			MS_TRACE();
+
+			Capabilities capabilities{};
+
+			const auto* remoteSupportedExtensionsParameter =
+			  remoteChunk->template GetFirstParameterOfType<SupportedExtensionsParameter>();
+			const auto* remoteForwardTsnSupportedParameter =
+			  remoteChunk->template GetFirstParameterOfType<ForwardTsnSupportedParameter>();
+			const auto* remoteZeroChecksumAcceptableParameter =
+			  remoteChunk->template GetFirstParameterOfType<ZeroChecksumAcceptableParameter>();
+
+			// Streams announced by the remote endpoint in its INIT or INIT-ACK chunk.
+			capabilities.maxOutboundStreams = remoteChunk->GetNumberOfOutboundStreams();
+			capabilities.maxInboundStreams  = remoteChunk->GetNumberOfInboundStreams();
+
+			// Remote announces Partial Reliability Extension support via
+			// Forward-TSN-Supported parameter or via Supported Extensions parameter.
+			capabilities.partialReliability =
+			  remoteForwardTsnSupportedParameter ||
+			  (remoteSupportedExtensionsParameter &&
+			   remoteSupportedExtensionsParameter->IncludesChunkType(Chunk::ChunkType::FORWARD_TSN));
+
+			// Remote announces Message Interleaving support via Supported Extensions
+			// parameter.
+			capabilities.messageInterleaving =
+			  remoteSupportedExtensionsParameter &&
+			  remoteSupportedExtensionsParameter->IncludesChunkType(Chunk::ChunkType::I_DATA) &&
+			  remoteSupportedExtensionsParameter->IncludesChunkType(Chunk::ChunkType::I_FORWARD_TSN);
+
+			// Remote announces Stream Re-Configuration support via Supported
+			// Extensions parameter.
+			capabilities.reConfig =
+			  remoteSupportedExtensionsParameter &&
+			  remoteSupportedExtensionsParameter->IncludesChunkType(Chunk::ChunkType::RE_CONFIG);
+
+			// Alternate Error Detection Method for Zero Checksum announced by the
+			// remote endpoint (NONE if not announced).
+			capabilities.zeroChecksumAlternateErrorDetectionMethod =
+			  remoteZeroChecksumAcceptableParameter
+			    ? remoteZeroChecksumAcceptableParameter->GetAlternateErrorDetectionMethod()
+			    : ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::NONE;
+
+			// NOTE: No need to std::move(). Copy elision (RVO) is used for free in GCC
+			// and clang in C++17 or higher.
+			return capabilities;
+		}
+
+		/* Instance methods. */
+
+		void Capabilities::Dump(int indentation) const
+		{
+			MS_TRACE();
+
+			MS_DUMP_CLEAN(indentation, "<SCTP::Capabilities>");
+			MS_DUMP_CLEAN(indentation, "  max outbound streams: %" PRIu16, this->maxOutboundStreams);
+			MS_DUMP_CLEAN(indentation, "  max inbound streams: %" PRIu16, this->maxInboundStreams);
+			MS_DUMP_CLEAN(indentation, "  partial reliability: %s", this->partialReliability ? "yes" : "no");
+			MS_DUMP_CLEAN(
+			  indentation, "  message interleaving: %s", this->messageInterleaving ? "yes" : "no");
+			MS_DUMP_CLEAN(indentation, "  re-config: %s", this->reConfig ? "yes" : "no");
+			MS_DUMP_CLEAN(
+			  indentation,
+			  "  zero checksum alternate error detection method: %s",
+			  ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethodToString(
+			    this->zeroChecksumAlternateErrorDetectionMethod)
+			    .c_str());
+			MS_DUMP_CLEAN(indentation, "</SCTP::Capabilities>");
+		}
+	} // namespace SCTP
+} // namespace RTC

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

@@ -3,8 +3,6 @@
 
 #include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
 #include "Logger.hpp"
-#include "RTC/SCTP/packet/parameters/ForwardTsnSupportedParameter.hpp"
-#include "RTC/SCTP/packet/parameters/SupportedExtensionsParameter.hpp"
 #include "RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp"
 
 namespace RTC
@@ -14,55 +12,39 @@ namespace RTC
 		/* Class methods. */
 
 		NegotiatedCapabilities NegotiatedCapabilities::Factory(
-		  const SctpOptions& sctpOptions, const AnyInitChunk* remoteChunk)
+		  const SctpOptions& sctpOptions, const Capabilities& remoteCapabilities)
 		{
 			MS_TRACE();
 
 			NegotiatedCapabilities negotiatedCapabilities{};
 
-			const auto* remoteSupportedExtensionsParameter =
-			  remoteChunk->template GetFirstParameterOfType<SupportedExtensionsParameter>();
-			const auto* remoteForwardTsnSupportedParameter =
-			  remoteChunk->template GetFirstParameterOfType<ForwardTsnSupportedParameter>();
-			const auto* remoteZeroChecksumAcceptableParameter =
-			  remoteChunk->template GetFirstParameterOfType<ZeroChecksumAcceptableParameter>();
+			negotiatedCapabilities.maxOutboundStreams =
+			  std::min(sctpOptions.announcedMaxOutboundStreams, remoteCapabilities.maxInboundStreams);
 
-			negotiatedCapabilities.negotiatedMaxOutboundStreams =
-			  std::min(sctpOptions.announcedMaxOutboundStreams, remoteChunk->GetNumberOfInboundStreams());
+			negotiatedCapabilities.maxInboundStreams =
+			  std::min(sctpOptions.announcedMaxInboundStreams, remoteCapabilities.maxOutboundStreams);
 
-			negotiatedCapabilities.negotiatedMaxInboundStreams =
-			  std::min(sctpOptions.announcedMaxInboundStreams, remoteChunk->GetNumberOfOutboundStreams());
-
-			// Partial Reliability Extension is negotiated if we desire it and
-			// peer announces support via Forward-TSN-Supported Parameter or via
-			// Supported extensions parameter.
+			// Partial Reliability Extension is negotiated if we desire it and the
+			// remote announces support for it.
 			negotiatedCapabilities.partialReliability =
-			  sctpOptions.enablePartialReliability &&
-			  (remoteForwardTsnSupportedParameter ||
-			   (remoteSupportedExtensionsParameter &&
-			    remoteSupportedExtensionsParameter->IncludesChunkType(Chunk::ChunkType::FORWARD_TSN)));
+			  sctpOptions.enablePartialReliability && remoteCapabilities.partialReliability;
 
-			// Message Interleaving is negotiated if we desire it and peer
-			// announces support via Supported Extensions parameter.
+			// Message Interleaving is negotiated if we desire it and the remote
+			// announces support for it.
 			negotiatedCapabilities.messageInterleaving =
-			  sctpOptions.enableMessageInterleaving && remoteSupportedExtensionsParameter &&
-			  remoteSupportedExtensionsParameter->IncludesChunkType(Chunk::ChunkType::I_DATA) &&
-			  remoteSupportedExtensionsParameter->IncludesChunkType(Chunk::ChunkType::I_FORWARD_TSN);
+			  sctpOptions.enableMessageInterleaving && remoteCapabilities.messageInterleaving;
 
-			// Stream Re-Configuration is negotiated if peer announces support via
-			// Supported extensions parameter.
-			negotiatedCapabilities.reConfig =
-			  remoteSupportedExtensionsParameter &&
-			  remoteSupportedExtensionsParameter->IncludesChunkType(Chunk::ChunkType::RE_CONFIG);
+			// Stream Re-Configuration is negotiated if the remote announces support
+			// for it.
+			negotiatedCapabilities.reConfig = remoteCapabilities.reConfig;
 
-			// Alternate Error Detection Method for Zero Checksum is negotiated
-			// if we desire it and peer announces the same non-none alternate
-			// error detection method.
+			// Alternate Error Detection Method for Zero Checksum is negotiated if we
+			// desire it and the remote announces the same non-none alternate error
+			// detection method.
 			negotiatedCapabilities.zeroChecksum =
 			  sctpOptions.zeroChecksumAlternateErrorDetectionMethod !=
 			    ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::NONE &&
-			  remoteZeroChecksumAcceptableParameter &&
-			  remoteZeroChecksumAcceptableParameter->GetAlternateErrorDetectionMethod() ==
+			  remoteCapabilities.zeroChecksumAlternateErrorDetectionMethod ==
 			    sctpOptions.zeroChecksumAlternateErrorDetectionMethod;
 
 			return negotiatedCapabilities;
@@ -75,10 +57,8 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP_CLEAN(indentation, "<SCTP::NegotiatedCapabilities>");
-			MS_DUMP_CLEAN(
-			  indentation, "  negotiated max outbound streams: %" PRIu16, this->negotiatedMaxOutboundStreams);
-			MS_DUMP_CLEAN(
-			  indentation, "  negotiated max inbound streams: %" PRIu16, this->negotiatedMaxInboundStreams);
+			MS_DUMP_CLEAN(indentation, "  max outbound streams: %" PRIu16, this->maxOutboundStreams);
+			MS_DUMP_CLEAN(indentation, "  max inbound streams: %" PRIu16, this->maxInboundStreams);
 			MS_DUMP_CLEAN(indentation, "  partial reliability: %s", this->partialReliability ? "yes" : "no");
 			MS_DUMP_CLEAN(
 			  indentation, "  message interleaving: %s", this->messageInterleaving ? "yes" : "no");

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

@@ -24,6 +24,15 @@ namespace RTC
 				return nullptr;
 			}
 
+			// Reject cookies with a zero verification tag. A zero tag is never
+			// generated by us, so this limits the effect of a tampered/forged cookie.
+			if (Utils::Byte::Get4Bytes(buffer, 8) == 0 || Utils::Byte::Get4Bytes(buffer, 12) == 0)
+			{
+				MS_WARN_TAG(sctp, "invalid StateCookie, verification tag is zero");
+
+				return nullptr;
+			}
+
 			auto* stateCookie = new StateCookie(const_cast<uint8_t*>(buffer), bufferLength);
 
 			return stateCookie;
@@ -38,7 +47,7 @@ namespace RTC
 		  uint32_t remoteInitialTsn,
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
-		  const NegotiatedCapabilities& negotiatedCapabilities,
+		  const Capabilities& remoteCapabilities,
 		  uint64_t creationTimestampMs,
 		  const uint8_t* macKey,
 		  size_t macKeyLength)
@@ -55,7 +64,7 @@ namespace RTC
 			  remoteInitialTsn,
 			  remoteAdvertisedReceiverWindowCredit,
 			  tieTag,
-			  negotiatedCapabilities,
+			  remoteCapabilities,
 			  creationTimestampMs,
 			  macKey,
 			  macKeyLength);
@@ -75,7 +84,7 @@ namespace RTC
 		  uint32_t remoteInitialTsn,
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
-		  const NegotiatedCapabilities& negotiatedCapabilities,
+		  const Capabilities& remoteCapabilities,
 		  uint64_t creationTimestampMs,
 		  const uint8_t* macKey,
 		  size_t macKeyLength)
@@ -99,19 +108,19 @@ namespace RTC
 			Utils::Byte::Set4Bytes(buffer, 24, remoteAdvertisedReceiverWindowCredit);
 			Utils::Byte::Set8Bytes(buffer, 28, tieTag);
 
-			auto* negotiatedCapabilitiesField = reinterpret_cast<NegotiatedCapabilitiesField*>(
-			  buffer + StateCookie::NegotiatedCapabilitiesOffset);
+			auto* remoteCapabilitiesField =
+			  reinterpret_cast<RemoteCapabilitiesField*>(buffer + StateCookie::RemoteCapabilitiesOffset);
 
-			negotiatedCapabilitiesField->reserved = 0;
-			negotiatedCapabilitiesField->bitA     = negotiatedCapabilities.partialReliability;
-			negotiatedCapabilitiesField->bitB     = negotiatedCapabilities.messageInterleaving;
-			negotiatedCapabilitiesField->bitC     = negotiatedCapabilities.reConfig;
-			negotiatedCapabilitiesField->bitD     = negotiatedCapabilities.zeroChecksum;
-			negotiatedCapabilitiesField->magic2   = htons(StateCookie::Magic2);
-			negotiatedCapabilitiesField->negotiatedMaxOutboundStreams =
-			  htons(negotiatedCapabilities.negotiatedMaxOutboundStreams);
-			negotiatedCapabilitiesField->negotiatedMaxInboundStreams =
-			  htons(negotiatedCapabilities.negotiatedMaxInboundStreams);
+			remoteCapabilitiesField->reserved   = 0;
+			remoteCapabilitiesField->bitA       = remoteCapabilities.partialReliability;
+			remoteCapabilitiesField->bitB       = remoteCapabilities.messageInterleaving;
+			remoteCapabilitiesField->bitC       = remoteCapabilities.reConfig;
+			remoteCapabilitiesField->unusedBits = 0;
+			remoteCapabilitiesField->magic2     = htons(StateCookie::Magic2);
+			remoteCapabilitiesField->zeroChecksumAlternateErrorDetectionMethod =
+			  htonl(static_cast<uint32_t>(remoteCapabilities.zeroChecksumAlternateErrorDetectionMethod));
+			remoteCapabilitiesField->maxOutboundStreams = htons(remoteCapabilities.maxOutboundStreams);
+			remoteCapabilitiesField->maxInboundStreams  = htons(remoteCapabilities.maxInboundStreams);
 
 			if (!authenticate)
 			{
@@ -144,10 +153,10 @@ namespace RTC
 				return false;
 			}
 
-			auto* negotiatedCapabilitiesField = reinterpret_cast<NegotiatedCapabilitiesField*>(
-			  const_cast<uint8_t*>(buffer) + StateCookie::NegotiatedCapabilitiesOffset);
+			const auto* remoteCapabilitiesField = reinterpret_cast<const RemoteCapabilitiesField*>(
+			  buffer + StateCookie::RemoteCapabilitiesOffset);
 
-			if (ntohs(negotiatedCapabilitiesField->magic2) != StateCookie::Magic2)
+			if (ntohs(remoteCapabilitiesField->magic2) != StateCookie::Magic2)
 			{
 				return false;
 			}
@@ -228,9 +237,10 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			auto negotiatedCapabilities = GetNegotiatedCapabilities();
+			const auto remoteCapabilities = GetRemoteCapabilities();
 
 			MS_DUMP_CLEAN(indentation, "<SCTP::StateCookie>");
+
 			MS_DUMP_CLEAN(indentation, "  length: %zu (buffer length: %zu)", GetLength(), GetBufferLength());
 			MS_DUMP_CLEAN(indentation, "  local verification tag: %" PRIu32, GetLocalVerificationTag());
 			MS_DUMP_CLEAN(indentation, "  remote verification tag: %" PRIu32, GetRemoteVerificationTag());
@@ -248,7 +258,9 @@ namespace RTC
 				MS_DUMP_CLEAN(indentation, "  creation timestamp (ms): %" PRIu64, GetCreationTimestampMs());
 			}
 
-			negotiatedCapabilities.Dump(indentation + 1);
+			MS_DUMP_CLEAN(indentation, "  remote capabilities:");
+			remoteCapabilities.Dump(indentation + 1);
+
 			MS_DUMP_CLEAN(indentation, "</SCTP::StateCookie>");
 		}
 
@@ -263,26 +275,36 @@ namespace RTC
 			return clonedStateCookie;
 		}
 
-		NegotiatedCapabilities StateCookie::GetNegotiatedCapabilities() const
+		Capabilities StateCookie::GetRemoteCapabilities() const
 		{
 			MS_TRACE();
 
-			auto* negotiatedCapabilitiesField = GetNegotiatedCapabilitiesField();
+			const auto* remoteCapabilitiesField = GetRemoteCapabilitiesField();
+
+			Capabilities remoteCapabilities;
+
+			remoteCapabilities.maxOutboundStreams  = ntohs(remoteCapabilitiesField->maxOutboundStreams);
+			remoteCapabilities.maxInboundStreams   = ntohs(remoteCapabilitiesField->maxInboundStreams);
+			remoteCapabilities.partialReliability  = remoteCapabilitiesField->bitA;
+			remoteCapabilities.messageInterleaving = remoteCapabilitiesField->bitB;
+			remoteCapabilities.reConfig            = remoteCapabilitiesField->bitC;
 
-			NegotiatedCapabilities negotiatedCapabilities;
+			// Only keep the zero checksum method if it's a value we know about.
+			// Anything else (unknown/future method or a tampered cookie) is treated
+			// as none.
+			const uint32_t zeroChecksumAlternateErrorDetectionMethod =
+			  ntohl(remoteCapabilitiesField->zeroChecksumAlternateErrorDetectionMethod);
 
-			negotiatedCapabilities.negotiatedMaxOutboundStreams =
-			  ntohs(negotiatedCapabilitiesField->negotiatedMaxOutboundStreams);
-			negotiatedCapabilities.negotiatedMaxInboundStreams =
-			  ntohs(negotiatedCapabilitiesField->negotiatedMaxInboundStreams);
-			negotiatedCapabilities.partialReliability  = negotiatedCapabilitiesField->bitA;
-			negotiatedCapabilities.messageInterleaving = negotiatedCapabilitiesField->bitB;
-			negotiatedCapabilities.reConfig            = negotiatedCapabilitiesField->bitC;
-			negotiatedCapabilities.zeroChecksum        = negotiatedCapabilitiesField->bitD;
+			remoteCapabilities.zeroChecksumAlternateErrorDetectionMethod =
+			  zeroChecksumAlternateErrorDetectionMethod ==
+			      static_cast<uint32_t>(
+			        ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::SCTP_OVER_DTLS)
+			    ? ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::SCTP_OVER_DTLS
+			    : ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::NONE;
 
 			// NOTE: No need to std::move(). Copy elision (RVO) is used for free in GCC
 			// and clang in C++17 or higher.
-			return negotiatedCapabilities;
+			return remoteCapabilities;
 		}
 	} // namespace SCTP
 } // namespace RTC

package/worker/src/RTC/SCTP/packet/Chunk.cpp

@@ -70,6 +70,22 @@ namespace RTC
 
 		/* Class methods. */
 
+		const std::string& Chunk::ChunkTypeToString(ChunkType chunkType)
+		{
+			MS_TRACE();
+
+			static const std::string Unknown("UNKNOWN");
+
+			auto it = Chunk::ChunkType2String.find(chunkType);
+
+			if (it == Chunk::ChunkType2String.end())
+			{
+				return Unknown;
+			}
+
+			return it->second;
+		}
+
 		bool Chunk::IsChunk(
 		  const uint8_t* buffer,
 		  size_t bufferLength,
@@ -89,22 +105,6 @@ namespace RTC
 			return true;
 		}
 
-		const std::string& Chunk::ChunkTypeToString(ChunkType chunkType)
-		{
-			MS_TRACE();
-
-			static const std::string Unknown("UNKNOWN");
-
-			auto it = Chunk::ChunkType2String.find(chunkType);
-
-			if (it == Chunk::ChunkType2String.end())
-			{
-				return Unknown;
-			}
-
-			return it->second;
-		}
-
 		/* Instance methods. */
 
 		Chunk::Chunk(uint8_t* buffer, size_t bufferLength) : TLV(buffer, bufferLength)
@@ -312,13 +312,13 @@ namespace RTC
 			chunk->SetLength(GetLength());
 		}
 
-		void Chunk::InitializeHeader(ChunkType chunkType, uint8_t flags, uint16_t lengthFieldValue)
+		void Chunk::InitializeHeader(ChunkType chunkType, uint8_t flags, uint16_t length)
 		{
 			MS_TRACE();
 
 			SetType(chunkType);
 			SetFlags(flags);
-			InitializeTLVHeader(lengthFieldValue);
+			InitializeTLVHeader(length);
 		}
 
 		bool Chunk::ParseParameters()

package/worker/src/RTC/SCTP/packet/ErrorCause.cpp

@@ -32,6 +32,22 @@ namespace RTC
 
 		/* Class methods. */
 
+		const std::string& ErrorCause::ErrorCauseCodeToString(ErrorCauseCode causeCode)
+		{
+			MS_TRACE();
+
+			static const std::string Unknown("UNKNOWN");
+
+			auto it = ErrorCause::ErrorCauseCode2String.find(causeCode);
+
+			if (it == ErrorCause::ErrorCauseCode2String.end())
+			{
+				return Unknown;
+			}
+
+			return it->second;
+		}
+
 		bool ErrorCause::IsErrorCause(
 		  const uint8_t* buffer,
 		  size_t bufferLength,
@@ -51,22 +67,6 @@ namespace RTC
 			return true;
 		}
 
-		const std::string& ErrorCause::ErrorCauseCodeToString(ErrorCauseCode causeCode)
-		{
-			MS_TRACE();
-
-			static const std::string Unknown("UNKNOWN");
-
-			auto it = ErrorCause::ErrorCauseCode2String.find(causeCode);
-
-			if (it == ErrorCause::ErrorCauseCode2String.end())
-			{
-				return Unknown;
-			}
-
-			return it->second;
-		}
-
 		/* Instance methods. */
 
 		ErrorCause::ErrorCause(uint8_t* buffer, size_t bufferLength) : TLV(buffer, bufferLength)
@@ -107,12 +107,12 @@ namespace RTC
 			SetBuffer(const_cast<uint8_t*>(buffer));
 		}
 
-		void ErrorCause::InitializeHeader(ErrorCauseCode causeCode, uint16_t lengthFieldValue)
+		void ErrorCause::InitializeHeader(ErrorCauseCode causeCode, uint16_t length)
 		{
 			MS_TRACE();
 
 			SetCode(causeCode);
-			InitializeTLVHeader(lengthFieldValue);
+			InitializeTLVHeader(length);
 		}
 	} // namespace SCTP
 } // namespace RTC

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

@@ -32,6 +32,8 @@ namespace RTC
 
 		bool Packet::IsSctp(const uint8_t* /*buffer*/, size_t bufferLength)
 		{
+			MS_TRACE();
+
 			return (
 			  bufferLength >= Packet::CommonHeaderLength && Utils::Byte::IsPaddedTo4Bytes(bufferLength));
 		}

package/worker/src/RTC/SCTP/packet/Parameter.cpp

@@ -35,6 +35,22 @@ namespace RTC
 
 		/* Class methods. */
 
+		const std::string& Parameter::ParameterTypeToString(ParameterType parameterType)
+		{
+			MS_TRACE();
+
+			static const std::string Unknown("UNKNOWN");
+
+			auto it = Parameter::ParameterType2String.find(parameterType);
+
+			if (it == Parameter::ParameterType2String.end())
+			{
+				return Unknown;
+			}
+
+			return it->second;
+		}
+
 		bool Parameter::IsParameter(
 		  const uint8_t* buffer,
 		  size_t bufferLength,
@@ -54,22 +70,6 @@ namespace RTC
 			return true;
 		}
 
-		const std::string& Parameter::ParameterTypeToString(ParameterType parameterType)
-		{
-			MS_TRACE();
-
-			static const std::string Unknown("UNKNOWN");
-
-			auto it = Parameter::ParameterType2String.find(parameterType);
-
-			if (it == Parameter::ParameterType2String.end())
-			{
-				return Unknown;
-			}
-
-			return it->second;
-		}
-
 		/* Instance methods. */
 
 		Parameter::Parameter(uint8_t* buffer, size_t bufferLength) : TLV(buffer, bufferLength)
@@ -110,12 +110,12 @@ namespace RTC
 			SetBuffer(const_cast<uint8_t*>(buffer));
 		}
 
-		void Parameter::InitializeHeader(ParameterType parameterType, uint16_t lengthFieldValue)
+		void Parameter::InitializeHeader(ParameterType parameterType, uint16_t length)
 		{
 			MS_TRACE();
 
 			SetType(parameterType);
-			InitializeTLVHeader(lengthFieldValue);
+			InitializeTLVHeader(length);
 		}
 	} // namespace SCTP
 } // namespace RTC

package/worker/src/RTC/SCTP/packet/TLV.cpp

@@ -80,31 +80,22 @@ namespace RTC
 			  GetBufferLength());
 		}
 
-		void TLV::InitializeTLVHeader(uint16_t lengthFieldValue)
+		void TLV::InitializeTLVHeader(uint16_t length)
 		{
 			MS_TRACE();
 
-			SetLengthField(lengthFieldValue);
+			SetLengthField(length);
 		}
 
-		void TLV::SetLengthField(size_t lengthField)
+		void TLV::SetVariableLengthValue(const uint8_t* value, size_t valueLength)
 		{
 			MS_TRACE();
 
-			if (lengthField > std::numeric_limits<uint16_t>::max())
+			if (value == nullptr && valueLength > 0)
 			{
-				MS_THROW_TYPE_ERROR("lengthField (%zu bytes) cannot be greater than 65535", lengthField);
+				MS_THROW_TYPE_ERROR("value cannot be nullptr if valueLength is > 0");
 			}
 
-			Utils::Byte::Set2Bytes(const_cast<uint8_t*>(GetBuffer()), 2, lengthField);
-		}
-
-		void TLV::SetVariableLengthValue(const uint8_t* value, size_t valueLength)
-		{
-			MS_TRACE();
-
-			MS_ASSERT(value != nullptr || valueLength == 0, "value cannot be nullptr if valueLength is > 0");
-
 			// NOTE: This can throw.
 			SetVariableLengthValueLength(valueLength);
 
@@ -118,12 +109,12 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			auto previousLength      = GetLength();
-			auto previousLengthField = GetLengthField();
-			auto previousValueLength = GetVariableLengthValueLength();
-			auto newNotPaddedLength =
+			const size_t previousLength        = GetLength();
+			const uint16_t previousLengthField = GetLengthField();
+			const uint16_t previousValueLength = GetVariableLengthValueLength();
+			const size_t newNotPaddedLength =
 			  size_t{ previousLengthField } - size_t{ previousValueLength } + valueLength;
-			auto newPaddedLength = Utils::Byte::PadTo4Bytes(newNotPaddedLength);
+			const size_t newPaddedLength = Utils::Byte::PadTo4Bytes(newNotPaddedLength);
 
 			try
 			{
@@ -134,6 +125,10 @@ namespace RTC
 				// Update length field.
 				// NOTE: This will throw if computed value is too big.
 				SetLengthField(newNotPaddedLength);
+
+				// Fill padding bytes with zero.
+				// NOTE: This may throw.
+				FillPadding(newPaddedLength - newNotPaddedLength);
 			}
 			catch (const MediaSoupError& error)
 			{
@@ -143,17 +138,13 @@ namespace RTC
 
 				throw;
 			}
-
-			// Fill padding bytes with zero.
-			FillPadding(newPaddedLength - newNotPaddedLength);
 		}
 
 		void TLV::AddItem(const TLV* item)
 		{
 			MS_TRACE();
 
-			auto previousLength      = GetLength();
-			auto previousLengthField = GetLengthField();
+			const size_t previousLength = GetLength();
 
 			try
 			{
@@ -169,10 +160,21 @@ namespace RTC
 			{
 				// Rollback.
 				SetLength(previousLength);
-				SetLengthField(previousLengthField);
 
 				throw;
 			}
 		}
+
+		void TLV::SetLengthField(size_t length)
+		{
+			MS_TRACE();
+
+			if (length > std::numeric_limits<uint16_t>::max())
+			{
+				MS_THROW_TYPE_ERROR("length (%zu bytes) cannot be greater than 65535", length);
+			}
+
+			Utils::Byte::Set2Bytes(const_cast<uint8_t*>(GetBuffer()), 2, length);
+		}
 	} // namespace SCTP
 } // namespace RTC

package/worker/src/RTC/SCTP/packet/parameters/StateCookieParameter.cpp

@@ -122,7 +122,7 @@ namespace RTC
 		  uint32_t remoteInitialTsn,
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
-		  const NegotiatedCapabilities& negotiatedCapabilities,
+		  const Capabilities& remoteCapabilities,
 		  uint64_t creationTimestampMs,
 		  const uint8_t* macKey,
 		  size_t macKeyLength)
@@ -147,7 +147,7 @@ namespace RTC
 			  remoteInitialTsn,
 			  remoteAdvertisedReceiverWindowCredit,
 			  tieTag,
-			  negotiatedCapabilities,
+			  remoteCapabilities,
 			  creationTimestampMs,
 			  macKey,
 			  macKeyLength);

package/worker/src/RTC/SvcProducerStreamManager.cpp

@@ -447,7 +447,10 @@ namespace RTC
 
 		auto previousLayers = this->encodingContext->GetCurrentLayers();
 
-		bool marker{ false };
+		// Preserve the original marker bit. ProcessPayload may update it (VP9/AV1
+		// overwrite it based on spatial-layer end-of-frame; VP8/H264 do not, so the
+		// original packet marker must survive).
+		bool marker{ packet->HasMarker() };
 
 		if (!packet->ProcessPayload(this->encodingContext.get(), marker))
 		{