mediasoup 3.21.0 → 3.21.2

package/worker/include/RTC/NEW_RTCP/packet/Packet.hpp

@@ -0,0 +1,354 @@
+#ifndef MS_RTC_NEW_RTCP_PACKET_HPP
+#define MS_RTC_NEW_RTCP_PACKET_HPP
+
+#include "common.hpp"
+#include "RTC/Serializable.hpp"
+#include "Utils.hpp"
+#include <ankerl/unordered_dense.h>
+#include <cstdint>
+#include <string>
+
+namespace RTC
+{
+	namespace NEW_RTCP
+	{
+		/**
+		 * RTCP Packet.
+		 *
+		 * @see RFC 3550.
+		 *
+		 * @remarks
+		 * - This class represents a single RTCP packet and not a compound packet.
+		 */
+		class Packet : public Serializable
+		{
+			// We need that CompoundPacket calls protected and private methods in this
+			// class.
+			friend class CompoundPacket;
+
+		public:
+			/**
+			 * RTCP Packet Type.
+			 */
+			enum class PacketType : uint8_t
+			{
+				/**
+				 * Extended Jitter Report.
+				 */
+				IJ = 195,
+				/**
+				 * RTCP Sender Report.
+				 */
+				SR = 200,
+				/**
+				 * RTCP Receiver Report.
+				 */
+				RR = 201,
+				/**
+				 * RTCP Sender Report.
+				 */
+				SDES = 202,
+				/**
+				 * RTCP BYE.
+				 */
+				BYE = 203,
+				/**
+				 * RTCP APP.
+				 */
+				APP = 204,
+				/**
+				 * RTCP Transport Layer Feedback.
+				 */
+				RTPFB = 205,
+				/**
+				 * RTCP Payload Specific Feedback.
+				 */
+				PSFB = 206,
+				/**
+				 * RTCP Extended Report.
+				 */
+				XR = 207,
+			};
+
+			/**
+			 * RTCP Packet (RTCP Common Header + Value).
+			 *
+			 * @see RFC 3550.
+			 *
+			 *  0                   1                   2                   3
+			 *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+			 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+			 * |V=2|P|  Count  |      PT       |            Length             |
+			 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+			 * \                                                               \
+			 * /                             Value                             /
+			 * \                                                               \
+			 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+			 *
+			 * - Version (2 bits): RTP/RTCP version. Always 2.
+			 * - Padding (1 bit): If set, the packet contains padding bytes at the
+			 *   end that are not part of the value. The last padding byte indicates
+			 *   how many padding bytes must be ignored, including itself (it will be
+			 *   a multiple of four).
+			 * - Count (5 bits): Field whose meaning depends on the packet type
+			 *   (PT). RFC 3550 does not assign it a single name because it varies
+			 *   per packet: in Sender/Receiver Report it is the reception report
+			 *   block count (RC), in SDES and BYE it is the source count (SC), and
+			 *   in APP it acts as an application-defined subtype. It is treated
+			 *   generically as a 5-bit value specific to each packet type.
+			 * - Packet type (8 bits): Identifies the RTCP packet type. Common
+			 *   values: 200 (SR), 201 (RR), 202 (SDES), 203 (BYE), 204 (APP).
+			 * - Length (16 bits): Length of the RTCP packet in 32-bit words minus
+			 *   one, including the Common Header and any padding. Therefore the
+			 *   total size in bytes is (Length + 1) * 4.
+			 * - Value (variable length): Packet content, whose format depends on
+			 *   the packet type (PT).
+			 *
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 4 bytes.
+			 * - 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.
+			 */
+			struct CommonHeader
+			{
+#if defined(MS_LITTLE_ENDIAN)
+				uint8_t count : 5;
+				uint8_t padding : 1;
+				uint8_t version : 2;
+#elif defined(MS_BIG_ENDIAN)
+				uint8_t version : 2;
+				uint8_t padding : 1;
+				uint8_t count : 5;
+#endif
+				PacketType packetType;
+				uint16_t length;
+			};
+
+		public:
+			/**
+			 * Length (in bytes) of the RTCP Common Header.
+			 */
+			static constexpr size_t CommonHeaderLength{ 4 };
+
+			/**
+			 * Whether given buffer could be a valid RTCP packet.
+			 */
+			static bool IsRtcp(const uint8_t* buffer, size_t bufferLength);
+
+			static const std::string& PacketTypeToString(PacketType packetType);
+
+		protected:
+			/**
+			 * Whether given buffer could be a a valid RTCP packet.
+			 *
+			 * @param buffer
+			 * @param bufferLength - Can be greater than real packet length.
+			 * @param packetType - If given buffer is a valid packet then `packetType`
+			 *   is rewritten to parsed PacketType.
+			 * @param packetLength - If given buffer is a valid packet then
+			 *   `packetLength` is rewritten to the computed length of the packet.
+			 *
+			 * @remarks
+			 * - Packets with Padding bit set to 1 are not supported (see note above)
+			 *   and hence this function returns false if it's set.
+			 */
+			static bool IsPacket(
+			  const uint8_t* buffer, size_t bufferLength, PacketType& packetType, size_t& packetLength);
+
+		private:
+			static const ankerl::unordered_dense::map<PacketType, std::string> PacketType2String;
+
+		protected:
+			/**
+			 * Constructor is protected because we only want to create packets
+			 * instances via Parse() and Factory() in subclasses.
+			 */
+			Packet(uint8_t* buffer, size_t bufferLength);
+
+		public:
+			~Packet() override;
+
+			/**
+			 * Must be overridden by each subclass.
+			 */
+			void Dump(int indentation = 0) const override = 0;
+
+			/**
+			 * Must be overridden by each subclass.
+			 */
+			Packet* Clone(uint8_t* buffer, size_t bufferLength) const override = 0;
+
+			uint8_t GetVersion() const
+			{
+				return GetCommonHeaderPointer()->version;
+			}
+
+			PacketType GetType() const
+			{
+				return GetCommonHeaderPointer()->packetType;
+			}
+
+			/**
+			 * False by default. UnknownPacket class overrides this method to return
+			 * true instead.
+			 */
+			virtual bool HasUnknownType() const
+			{
+				return false;
+			}
+
+			/**
+			 * Whether the Padding bit is set to 1.
+			 *
+			 * @remarks
+			 * - 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.
+			 */
+			bool HasPadding() const
+			{
+				return GetCommonHeaderPointer()->padding;
+			}
+
+		protected:
+			/**
+			 * Subclasses must invoke this method within their Dump() method.
+			 */
+			void DumpCommon(int indentation) const;
+
+			virtual void SoftSerialize(const uint8_t* buffer) final;
+
+			/**
+			 * Can be overridden by each subclass.
+			 */
+			virtual Packet* SoftClone(const uint8_t* buffer) const = 0;
+
+			virtual void SoftCloneInto(Packet* packet) const final;
+
+			virtual void InitializeHeader(PacketType packetType, uint16_t length) final;
+
+			virtual uint8_t GetCount() const final
+			{
+				return GetCommonHeaderPointer()->count;
+			}
+
+			virtual void SetCount(uint8_t count) final
+			{
+				GetCommonHeaderPointer()->count = count;
+			}
+
+			/**
+			 * Value of the Length field, which is the length of the RTCP packet in
+			 * 32-bit words minus one, including the Common Header and any padding.
+			 * Therefore the total size in bytes is (Length + 1) * 4.
+			 */
+			virtual uint16_t GetLengthField() const final
+			{
+				return Utils::Byte::Get2Bytes(GetBuffer(), 2);
+			}
+
+			/**
+			 * Computed value (in bytes) of the Length field.
+			 */
+			virtual size_t GetLengthFieldComputed() const final
+			{
+				return (static_cast<size_t>(GetLengthField()) + 1) * 4;
+			}
+
+			/**
+			 * Set the Length field given the total packet length in bytes. It
+			 * encodes it as 32-bit words minus one as required by the RTCP Length
+			 * field.
+			 *
+			 * @throw MediaSoupTypeError - If given `length` is higher than the maximum
+			 *   representable packet length (262144 bytes).
+			 */
+			virtual void SetLengthField(size_t length) final;
+
+			/**
+			 * A pointer to the position in the buffer where the variable-length value
+			 * (if any) starts or should start.
+			 */
+			virtual uint8_t* GetVariableLengthValuePointer() const final
+			{
+				return const_cast<uint8_t*>(GetBuffer()) + Packet::CommonHeaderLength;
+			}
+
+			/**
+			 * Whether this packet contains a variable-length value.
+			 *
+			 * @see GetVariableLengthValue()
+			 */
+			virtual bool HasVariableLengthValue() const final
+			{
+				return GetLengthFieldComputed() > Packet::CommonHeaderLength;
+			}
+
+			/**
+			 * Variable-length value of this packet.
+			 */
+			virtual const uint8_t* GetVariableLengthValue() const final
+			{
+				if (!HasVariableLengthValue())
+				{
+					return nullptr;
+				}
+
+				return GetVariableLengthValuePointer();
+			}
+
+			/**
+			 * Set the variable-length value. It copies the given value into the
+			 * the variable-length value of the packet and updates both the length of
+			 * the Serializable and the length field.
+			 *
+			 * @throw MediaSoupTypeError - If given `valueLength` is higher than
+			 *   available length.
+			 *
+			 * @see GetVariableLengthValue()
+			 */
+			virtual void SetVariableLengthValue(const uint8_t* value, size_t valueLength) final;
+
+			/**
+			 * The length of the variable-length value.
+			 */
+			virtual size_t GetVariableLengthValueLength() const final
+			{
+				if (!HasVariableLengthValue())
+				{
+					return 0u;
+				}
+
+				return GetLengthFieldComputed() - Packet::CommonHeaderLength;
+			}
+
+			/**
+			 * Set the length of the variable-length value. It doesn't copy any value
+			 * into the variable-length value. This method is used in packets that
+			 * have variable-length value but it doesn't consist on a buffer + length,
+			 * but instead is an structure with fields (with variable length).
+			 *
+			 * @see GetVariableLengthValue()
+			 */
+			virtual void SetVariableLengthValueLength(size_t valueLength) final;
+
+		private:
+			/**
+			 * @remarks
+			 * - Returns CommonHeader* instead of const CommonHeader* since we may want
+			 *   to modify its fields.
+			 */
+			CommonHeader* GetCommonHeaderPointer() const
+			{
+				return reinterpret_cast<CommonHeader*>(const_cast<uint8_t*>(GetBuffer()));
+			}
+		};
+	} // namespace NEW_RTCP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/NEW_RTCP/packet/TODO_NEW_RTCP.md

@@ -0,0 +1,17 @@
+# TODO NEW RTCP
+
+- Remove `NEW_` prefix in folders.
+
+- Remove `NEW_` prefix in C++ `NEW_RTCP` namespace.
+
+- Remove `NEW_` prefix in `#ifndef` in `.hpp` files.
+
+- We are not implementing `NeedsConsolidation()` in `Packet` class (only in `CompoundPacket` class). For now it's ok. Let's see.
+
+- `Packet`: Check if we need all those `Get/SetVariableLengthXxxxxx()` methods.
+
+- All the `TODO` comments.
+
+- Tests for `Packet` and `CompoundPacket`.
+
+- Fuzzer for `Packet` and `CompoundPacket`.

package/worker/include/RTC/RTP/Codecs/Tools.hpp

@@ -159,7 +159,9 @@ namespace RTC
 								{
 									switch (mimeType.subtype)
 									{
+										case RTC::RtpCodecMimeType::Subtype::VP8:
 										case RTC::RtpCodecMimeType::Subtype::VP9:
+										case RTC::RtpCodecMimeType::Subtype::H264:
 										case RTC::RtpCodecMimeType::Subtype::AV1:
 										{
 											return true;

package/worker/include/RTC/Router.hpp

@@ -49,11 +49,11 @@ namespace RTC
 
 	private:
 		RTC::Transport* AssertAndGetTransportById(
-		  const std::string& transportId, const std::string& message) const;
+		  const std::string& transportId, const std::string& method) const;
 		RTC::RtpObserver* AssertAndGetRtpObserverById(
-		  const std::string& rtpObserverId, const std::string& message) const;
-		void CheckNoTransport(const std::string& transportId, const std::string& message) const;
-		void CheckNoRtpObserver(const std::string& rtpObserverId, const std::string& message) const;
+		  const std::string& rtpObserverId, const std::string& method) const;
+		void CheckNoTransport(const std::string& transportId, const std::string& method) const;
+		void CheckNoRtpObserver(const std::string& rtpObserverId, const std::string& method) const;
 
 		/* Pure virtual methods inherited from RTC::Transport::Listener. */
 	public:

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

@@ -0,0 +1,73 @@
+#ifndef MS_RTC_SCTP_CAPABILITIES_HPP
+#define MS_RTC_SCTP_CAPABILITIES_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/packet/chunks/AnyInitChunk.hpp"
+#include "RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp"
+
+namespace RTC
+{
+	namespace SCTP
+	{
+		/**
+		 * Those are the raw SCTP capabilities announced by an endpoint in its INIT
+		 * or INIT-ACK chunk, before any negotiation against local options takes
+		 * place.
+		 */
+		struct Capabilities
+		{
+			/**
+			 * Create a Capabilities struct holding the capabilities announced by
+			 * the remote endpoint. No local option is applied here.
+			 *
+			 * @remarks
+			 * - Given `remoteChunk` must be an INIT or an INIT-ACK chunk.
+			 */
+			static Capabilities Factory(const AnyInitChunk* remoteChunk);
+
+			/**
+			 * Maximum number of outbound streams (OS).
+			 */
+			uint16_t maxOutboundStreams{ 0 };
+
+			/**
+			 * Maximum number of inbound streams (MIS).
+			 */
+			uint16_t maxInboundStreams{ 0 };
+
+			/**
+			 * Partial Reliability Extension.
+			 *
+			 * @see RFC 3758.
+			 */
+			bool partialReliability{ false };
+
+			/**
+			 * Stream Schedulers and User Message Interleaving (I-DATA chunks).
+			 *
+			 * @see RFC 8260.
+			 */
+			bool messageInterleaving{ false };
+
+			/**
+			 * Stream Re-Configuration.
+			 *
+			 * @see RFC 6525.
+			 */
+			bool reConfig{ false };
+
+			/**
+			 * Alternate Error Detection Method for Zero Checksum.
+			 *
+			 * @see RFC 9653.
+			 */
+			ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod zeroChecksumAlternateErrorDetectionMethod{
+				ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::NONE
+			};
+
+			void Dump(int indentation = 0) const;
+		};
+	} // namespace SCTP
+} // namespace RTC
+
+#endif

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

@@ -2,7 +2,7 @@
 #define MS_RTC_SCTP_NEGOTIATED_CAPABILITIES_HPP
 
 #include "common.hpp"
-#include "RTC/SCTP/packet/chunks/AnyInitChunk.hpp"
+#include "RTC/SCTP/association/Capabilities.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
 
 namespace RTC
@@ -17,24 +17,22 @@ namespace RTC
 		struct NegotiatedCapabilities
 		{
 			/**
-			 * Create a NegotiatedCapabilities struct. Intended to be used during
-			 * the SCTP association handshake flow.
-			 *
-			 * @remarks
-			 * - Given `remoteChunk` must be an INIT or an INIT-ACK chunk.
+			 * Create a NegotiatedCapabilities struct by negotiating the capabilities
+			 * announced by the remote endpoint against our local options. Intended
+			 * to be used during the SCTP association handshake flow.
 			 */
 			static NegotiatedCapabilities Factory(
-			  const SctpOptions& sctpOptions, const AnyInitChunk* remoteChunk);
+			  const SctpOptions& sctpOptions, const Capabilities& remoteCapabilities);
 
 			/**
 			 * Negotiated maximum number of outbound streams (OS).
 			 */
-			uint16_t negotiatedMaxOutboundStreams{ 0 };
+			uint16_t maxOutboundStreams{ 0 };
 
 			/**
 			 * Negotiated maximum number of inbound streams (MIS).
 			 */
-			uint16_t negotiatedMaxInboundStreams{ 0 };
+			uint16_t maxInboundStreams{ 0 };
 
 			/**
 			 * Partial Reliability Extension.

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

@@ -2,7 +2,7 @@
 #define MS_RTC_SCTP_STATE_COOKIE_HPP
 
 #include "common.hpp"
-#include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
+#include "RTC/SCTP/association/Capabilities.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
 #include "RTC/Serializable.hpp"
 #include "Utils.hpp"
@@ -38,30 +38,41 @@ namespace RTC
 		 * |                                                               |
 		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 		 * \                                                               \
-		 * /                     Negotiated Capabilities                   /
+		 * /                      Remote Capabilities                      /
 		 * \                                                               \
 		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 		 *
-		 * Negotiated Capabilities are serialized as follows:
+		 * The Remote Capabilities are the raw capabilities announced by the remote
+		 * endpoint in its INIT or INIT-ACK chunk (before being negotiated against
+		 * our local options). Storing the raw remote capabilities (instead of the
+		 * already negotiated ones) limits the effect of a tampered/forged cookie:
+		 * when the COOKIE-ECHO is received they are re-negotiated against our local
+		 * options, so an attacker can never enable an extension we didn't signal
+		 * nor raise the stream limits above what we announced.
+		 *
+		 * Remote Capabilities are serialized as follows:
 		 *
 		 *  0                   1                   2                   3
 		 *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		 * |   (Reserved)  |       |D|C|B|A|            Magic 2            |
+		 * |   (Reserved)  |         |C|B|A|            Magic 2            |
+		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		 * |         Zero Checksum Alternate Error Detection Method        |
 		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 		 * |      Max Outbound Streams     |       Max Inbound Streams     |
 		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 		 *
 		 * - Flag A (partialReliability): Partial Reliability Extension.
 		 * - Flag B (messageInterleaving): Stream Schedulers and User Message
-		 *   Interleaving (I-DATA).
-		 * - Flag C (reconfig): Stream Reconfiguration.
-		 * - Flag D (zeroChecksum): Zero Checksum.
+		 *     Interleaving (I-DATA).
+		 * - Flag C (reConfig): Stream Reconfiguration.
+		 * - Zero Checksum Alternate Error Detection Method: the method announced
+		 *     by the remote endpoint (0 means none).
 		 *
 		 * When State Cookie authentication is enabled (see
 		 * `SctpOptions::requireAuthenticatedCookie`), two extra fields are appended
-		 * after the Negotiated Capabilities so the receiver can verify that the
-		 * cookie was generated by itself and is not stale:
+		 * after the Remote Capabilities so the receiver can verify that the cookie
+		 * was generated by itself and is not stale:
 		 *
 		 *  0                   1                   2                   3
 		 *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -83,39 +94,37 @@ namespace RTC
 		class StateCookie : public Serializable
 		{
 		private:
-			struct NegotiatedCapabilitiesField
+			struct RemoteCapabilitiesField
 			{
 				uint8_t reserved;
 #if defined(MS_LITTLE_ENDIAN)
 				uint8_t bitA : 1;
 				uint8_t bitB : 1;
 				uint8_t bitC : 1;
-				uint8_t bitD : 1;
-				uint8_t unusedBits : 4;
+				uint8_t unusedBits : 5;
 #elif defined(MS_BIG_ENDIAN)
-				uint8_t unusedBits : 4;
-				uint8_t bitD : 1;
+				uint8_t unusedBits : 5;
 				uint8_t bitC : 1;
 				uint8_t bitB : 1;
 				uint8_t bitA : 1;
 #endif
 				uint16_t magic2;
-				uint16_t negotiatedMaxOutboundStreams;
-				uint16_t negotiatedMaxInboundStreams;
+				uint32_t zeroChecksumAlternateErrorDetectionMethod;
+				uint16_t maxOutboundStreams;
+				uint16_t maxInboundStreams;
 			};
 
 		public:
 			// Fixed length of our generated State Cookies when authentication is
 			// disabled.
-			static constexpr size_t StateCookieLength{ 44 };
-			// Offset in the State Cookie where the Negotiated Capabilitied are
-			// located.
-			static constexpr size_t NegotiatedCapabilitiesOffset{ 36 };
+			static constexpr size_t StateCookieLength{ 48 };
+			// Offset in the State Cookie where the Remote Capabilities are located.
+			static constexpr size_t RemoteCapabilitiesOffset{ 36 };
 			// Magic value we prefix the State Cookie with. Note that it is
 			// "msworker" in ASCII bytes.
 			static constexpr uint64_t Magic1{ 0x6D73776F726B6572 };
 			static constexpr size_t Magic1Length{ 8 };
-			// Magic value used within the Negotiated Capabilities block.
+			// Magic value used within the Remote Capabilities block.
 			static constexpr uint16_t Magic2{ 0xAD81 };
 			// Offset of the creation timestamp present in authenticated State
 			// Cookies.
@@ -165,7 +174,7 @@ namespace RTC
 			  uint32_t remoteInitialTsn,
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
-			  const NegotiatedCapabilities& negotiatedCapabilities,
+			  const Capabilities& remoteCapabilities,
 			  uint64_t creationTimestampMs = 0,
 			  const uint8_t* macKey        = nullptr,
 			  size_t macKeyLength          = 0);
@@ -187,7 +196,7 @@ namespace RTC
 			  uint32_t remoteInitialTsn,
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
-			  const NegotiatedCapabilities& negotiatedCapabilities,
+			  const Capabilities& remoteCapabilities,
 			  uint64_t creationTimestampMs = 0,
 			  const uint8_t* macKey        = nullptr,
 			  size_t macKeyLength          = 0);
@@ -287,9 +296,10 @@ namespace RTC
 			}
 
 			/**
-			 * Negotiated association capabilities.
+			 * Raw capabilities announced by the remote endpoint (before being
+			 * negotiated against our local options).
 			 */
-			NegotiatedCapabilities GetNegotiatedCapabilities() const;
+			Capabilities GetRemoteCapabilities() const;
 
 			/**
 			 * Whether this is an authenticated StateCookie (i.e. it carries a
@@ -312,10 +322,10 @@ namespace RTC
 			}
 
 		private:
-			NegotiatedCapabilitiesField* GetNegotiatedCapabilitiesField() const
+			RemoteCapabilitiesField* GetRemoteCapabilitiesField() const
 			{
-				return reinterpret_cast<NegotiatedCapabilitiesField*>(
-				  const_cast<uint8_t*>(GetBuffer()) + StateCookie::NegotiatedCapabilitiesOffset);
+				return reinterpret_cast<RemoteCapabilitiesField*>(
+				  const_cast<uint8_t*>(GetBuffer()) + StateCookie::RemoteCapabilitiesOffset);
 			}
 		};
 	} // namespace SCTP