mediasoup 3.20.1 → 3.20.3

package/worker/src/RTC/PortManager.cpp

@@ -6,7 +6,8 @@
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
 #include "Utils.hpp"
-#include <tuple> // std:make_tuple()
+#include <cstring> // std::memcmp(), std::memset()
+#include <tuple>   // std::make_tuple()
 
 /* Static methods for UV callbacks. */
 
@@ -31,9 +32,11 @@ namespace RTC
 {
 	/* Class variables. */
 
-	thread_local ankerl::unordered_dense::map<uint64_t, PortManager::PortRange> PortManager::mapPortRanges;
+	thread_local ankerl::unordered_dense::
+	  map<PortManager::PortRangeKey, PortManager::PortRange, PortManager::PortRangeKeyHash>
+	    PortManager::mapPortRanges;
 
-	/* Class methods. */
+	/* PortManager class methods. */
 
 	uv_handle_t* PortManager::Bind(
 	  Protocol protocol, std::string& ip, uint16_t port, RTC::Transport::SocketFlags& flags)
@@ -71,7 +74,8 @@ namespace RTC
 		{
 			case AF_INET:
 			{
-				err = uv_ip4_addr(ip.c_str(), 0, reinterpret_cast<struct sockaddr_in*>(&bindAddr));
+				err = uv_ip4_addr(
+				  ip.c_str(), 0, reinterpret_cast<struct sockaddr_in*>(std::addressof(bindAddr)));
 
 				if (err != 0)
 				{
@@ -83,7 +87,8 @@ namespace RTC
 
 			case AF_INET6:
 			{
-				err = uv_ip6_addr(ip.c_str(), 0, reinterpret_cast<struct sockaddr_in6*>(&bindAddr));
+				err = uv_ip6_addr(
+				  ip.c_str(), 0, reinterpret_cast<struct sockaddr_in6*>(std::addressof(bindAddr)));
 
 				if (err != 0)
 				{
@@ -105,14 +110,14 @@ namespace RTC
 		{
 			case AF_INET:
 			{
-				(reinterpret_cast<struct sockaddr_in*>(&bindAddr))->sin_port = htons(port);
+				(reinterpret_cast<struct sockaddr_in*>(std::addressof(bindAddr)))->sin_port = htons(port);
 
 				break;
 			}
 
 			case AF_INET6:
 			{
-				(reinterpret_cast<struct sockaddr_in6*>(&bindAddr))->sin6_port = htons(port);
+				(reinterpret_cast<struct sockaddr_in6*>(std::addressof(bindAddr)))->sin6_port = htons(port);
 
 				break;
 			}
@@ -175,7 +180,7 @@ namespace RTC
 			{
 				err = uv_udp_bind(
 				  reinterpret_cast<uv_udp_t*>(uvHandle),
-				  reinterpret_cast<const struct sockaddr*>(&bindAddr),
+				  reinterpret_cast<const struct sockaddr*>(std::addressof(bindAddr)),
 				  bitFlags);
 
 				if (err != 0)
@@ -198,7 +203,7 @@ namespace RTC
 			{
 				err = uv_tcp_bind(
 				  reinterpret_cast<uv_tcp_t*>(uvHandle),
-				  reinterpret_cast<const struct sockaddr*>(&bindAddr),
+				  reinterpret_cast<const struct sockaddr*>(std::addressof(bindAddr)),
 				  bitFlags);
 
 				if (err != 0)
@@ -250,7 +255,7 @@ namespace RTC
 	  uint16_t minPort,
 	  uint16_t maxPort,
 	  RTC::Transport::SocketFlags& flags,
-	  uint64_t& hash)
+	  PortRangeKey& key)
 	{
 		MS_TRACE();
 
@@ -288,7 +293,8 @@ namespace RTC
 		{
 			case AF_INET:
 			{
-				err = uv_ip4_addr(ip.c_str(), 0, reinterpret_cast<struct sockaddr_in*>(&bindAddr));
+				err = uv_ip4_addr(
+				  ip.c_str(), 0, reinterpret_cast<struct sockaddr_in*>(std::addressof(bindAddr)));
 
 				if (err != 0)
 				{
@@ -300,7 +306,8 @@ namespace RTC
 
 			case AF_INET6:
 			{
-				err = uv_ip6_addr(ip.c_str(), 0, reinterpret_cast<struct sockaddr_in6*>(&bindAddr));
+				err = uv_ip6_addr(
+				  ip.c_str(), 0, reinterpret_cast<struct sockaddr_in6*>(std::addressof(bindAddr)));
 
 				if (err != 0)
 				{
@@ -317,9 +324,9 @@ namespace RTC
 			}
 		}
 
-		hash = GeneratePortRangeHash(protocol, std::addressof(bindAddr), minPort, maxPort);
+		key = PortRangeKey(protocol, bindAddr, minPort, maxPort);
 
-		auto& portRange          = PortManager::GetOrCreatePortRange(hash, minPort, maxPort);
+		auto& portRange          = PortManager::GetOrCreatePortRange(key, minPort, maxPort);
 		const size_t numPorts    = portRange.ports.size();
 		const size_t numAttempts = numPorts;
 		size_t attempt{ 0u };
@@ -385,14 +392,14 @@ namespace RTC
 			{
 				case AF_INET:
 				{
-					(reinterpret_cast<struct sockaddr_in*>(&bindAddr))->sin_port = htons(port);
+					(reinterpret_cast<struct sockaddr_in*>(std::addressof(bindAddr)))->sin_port = htons(port);
 
 					break;
 				}
 
 				case AF_INET6:
 				{
-					(reinterpret_cast<struct sockaddr_in6*>(&bindAddr))->sin6_port = htons(port);
+					(reinterpret_cast<struct sockaddr_in6*>(std::addressof(bindAddr)))->sin6_port = htons(port);
 
 					break;
 				}
@@ -455,7 +462,7 @@ namespace RTC
 				{
 					err = uv_udp_bind(
 					  reinterpret_cast<uv_udp_t*>(uvHandle),
-					  reinterpret_cast<const struct sockaddr*>(&bindAddr),
+					  reinterpret_cast<const struct sockaddr*>(std::addressof(bindAddr)),
 					  bitFlags);
 
 					if (err != 0)
@@ -477,7 +484,7 @@ namespace RTC
 				{
 					err = uv_tcp_bind(
 					  reinterpret_cast<uv_tcp_t*>(uvHandle),
-					  reinterpret_cast<const struct sockaddr*>(&bindAddr),
+					  reinterpret_cast<const struct sockaddr*>(std::addressof(bindAddr)),
 					  bitFlags);
 
 					if (err != 0)
@@ -595,16 +602,19 @@ namespace RTC
 		return uvHandle;
 	}
 
-	void PortManager::Unbind(uint64_t hash, uint16_t port)
+	void PortManager::Unbind(const PortRangeKey& key, uint16_t port)
 	{
 		MS_TRACE();
 
-		auto it = PortManager::mapPortRanges.find(hash);
+		auto it = PortManager::mapPortRanges.find(key);
 
 		// This should not happen.
 		if (it == PortManager::mapPortRanges.end())
 		{
-			MS_ERROR("hash %" PRIu64 " doesn't exist in the map", hash);
+			MS_ERROR(
+			  "port range key [minPort:%" PRIu16 ", maxPort:%" PRIu16 "] doesn't exist in the map",
+			  key.minPort,
+			  key.maxPort);
 
 			return;
 		}
@@ -633,13 +643,15 @@ namespace RTC
 	{
 		MS_DUMP_CLEAN(indentation, "<PortManager>");
 
-		for (auto& kv : PortManager::mapPortRanges)
+		for (const auto& kv : PortManager::mapPortRanges)
 		{
-			auto hash      = kv.first;
-			auto portRange = kv.second;
+			const auto& key         = kv.first;
+			const auto& portRange   = kv.second;
+			const char* protocolStr = (key.protocol == Protocol::UDP) ? "udp" : "tcp";
 
 			MS_DUMP_CLEAN(indentation + 1, "<PortRange>");
-			MS_DUMP_CLEAN(indentation + 1, "  hash: %" PRIu64, hash);
+			MS_DUMP_CLEAN(indentation + 1, "  protocol: %s", protocolStr);
+			MS_DUMP_CLEAN(indentation + 1, "  family: %d", key.bindAddr.ss_family);
 			MS_DUMP_CLEAN(indentation + 1, "  minPort: %" PRIu16, portRange.minPort);
 			MS_DUMP_CLEAN(indentation + 1, "  maxPort: %zu", portRange.minPort + portRange.ports.size() - 1);
 			MS_DUMP_CLEAN(indentation + 1, "  numUsedPorts: %" PRIu16, portRange.numUsedPorts);
@@ -649,95 +661,14 @@ namespace RTC
 		MS_DUMP_CLEAN(indentation, "</PortManager>");
 	}
 
-	/*
-	 * Hash for IPv4.
-	 *
-	 *  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
-	 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 * |           MIN PORT            |           MAX PORT            |
-	 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 * |              IP               |           IP >> 2         |F|P|
-	 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 *
-	 * Hash for IPv6.
-	 *
-	 *  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
-	 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 * |           MIN PORT            |           MAX PORT            |
-	 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 * |IP[0] ^  IP[1] ^ IP[2] ^ IP[3] |           same >> 2       |F|P|
-	 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 */
-	uint64_t PortManager::GeneratePortRangeHash(
-	  Protocol protocol, sockaddr_storage* bindAddr, uint16_t minPort, uint16_t maxPort)
-	{
-		MS_TRACE();
-
-		uint64_t hash{ 0u };
-
-		switch (bindAddr->ss_family)
-		{
-			case AF_INET:
-			{
-				auto* bindAddrIn = reinterpret_cast<struct sockaddr_in*>(bindAddr);
-
-				// We want it in network order.
-				const uint64_t address = bindAddrIn->sin_addr.s_addr;
-
-				hash |= static_cast<uint64_t>(minPort) << 48;
-				hash |= static_cast<uint64_t>(maxPort) << 32;
-				hash |= (address >> 2) << 2;
-				hash |= 0x0000; // AF_INET.
-
-				break;
-			}
-
-			case AF_INET6:
-			{
-				auto* bindAddrIn6 = reinterpret_cast<struct sockaddr_in6*>(bindAddr);
-				auto* a           = reinterpret_cast<uint32_t*>(std::addressof(bindAddrIn6->sin6_addr));
-
-				const auto address = a[0] ^ a[1] ^ a[2] ^ a[3];
-
-				hash |= static_cast<uint64_t>(minPort) << 48;
-				hash |= static_cast<uint64_t>(maxPort) << 32;
-				hash |= static_cast<uint64_t>(address) << 16;
-				hash |= (static_cast<uint64_t>(address) >> 2) << 2;
-				hash |= 0x0002; // AF_INET6.
-
-				break;
-			}
-
-			// This cannot happen.
-			default:
-			{
-				MS_THROW_ERROR("unknown IP family");
-			}
-		}
-
-		// Override least significant bit with protocol information:
-		// - If UDP, start with 0.
-		// - If TCP, start with 1.
-		if (protocol == Protocol::UDP)
-		{
-			hash |= 0x0000;
-		}
-		else
-		{
-			hash |= 0x0001;
-		}
-
-		return hash;
-	}
-
 	PortManager::PortRange& PortManager::GetOrCreatePortRange(
-	  uint64_t hash, uint16_t minPort, uint16_t maxPort)
+	  const PortRangeKey& key, uint16_t minPort, uint16_t maxPort)
 	{
 		MS_TRACE();
 
-		auto it = PortManager::mapPortRanges.find(hash);
+		const auto it = PortManager::mapPortRanges.find(key);
 
-		// If the hash is already handled, return its port range.
+		// If the key is already handled, return its port range.
 		if (it != PortManager::mapPortRanges.end())
 		{
 			auto& portRange = it->second;
@@ -747,10 +678,10 @@ namespace RTC
 
 		const uint16_t numPorts = maxPort - minPort + 1;
 
-		// Emplace a new vector filled with numPorts false values, meaning that
+		// Emplace a new vector filled with `numPorts` false values, meaning that
 		// all ports are available.
-		auto pair = PortManager::mapPortRanges.emplace(
-		  std::piecewise_construct, std::make_tuple(hash), std::make_tuple(numPorts, minPort));
+		const auto pair = PortManager::mapPortRanges.emplace(
+		  std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(numPorts, minPort));
 
 		// pair.first is an iterator to the inserted value.
 		auto& portRange = pair.first->second;
@@ -764,7 +695,7 @@ namespace RTC
 
 		uint8_t bitFlags{ 0b00000000 };
 
-		// Ignore ipv6Only in IPv4, otherwise libuv will throw.
+		// Ignore `ipv6Only` in IPv4, otherwise libuv will throw.
 		if (flags.ipv6Only && family == AF_INET6)
 		{
 			switch (protocol)
@@ -785,7 +716,7 @@ namespace RTC
 			}
 		}
 
-		// Ignore udpReusePort in TCP, otherwise libuv will throw.
+		// Ignore `udpReusePort` in TCP, otherwise libuv will throw.
 		if (flags.udpReusePort && protocol == Protocol::UDP)
 		{
 			bitFlags |= UV_UDP_REUSEADDR;
@@ -793,4 +724,133 @@ namespace RTC
 
 		return bitFlags;
 	}
+
+	/* PortRangeKey instance methods. */
+
+	PortManager::PortRangeKey::PortRangeKey(
+	  Protocol protocol, const sockaddr_storage& bindAddr, uint16_t minPort, uint16_t maxPort)
+	  : protocol(protocol), bindAddr(bindAddr), minPort(minPort), maxPort(maxPort)
+	{
+		MS_TRACE();
+
+		// `sockaddr_storage` is padded; the unused tail bytes are caller-controlled.
+		// `operator==` inspects only the meaningful address bytes (`sin_addr` /
+		// `sin6_addr`) so padding does not affect equality, and the hash function
+		// hashes the same exact fields, so two structurally-equal keys always
+		// produce the same hash regardless of how the caller zero-initialized.
+	}
+
+	bool PortManager::PortRangeKey::operator==(const PortRangeKey& other) const noexcept
+	{
+		MS_TRACE();
+
+		if (this->protocol != other.protocol)
+		{
+			return false;
+		}
+		else if (this->minPort != other.minPort)
+		{
+			return false;
+		}
+		else if (this->maxPort != other.maxPort)
+		{
+			return false;
+		}
+		else if (this->bindAddr.ss_family != other.bindAddr.ss_family)
+		{
+			return false;
+		}
+
+		switch (this->bindAddr.ss_family)
+		{
+			case AF_INET:
+			{
+				const auto* a = reinterpret_cast<const sockaddr_in*>(std::addressof(this->bindAddr));
+				const auto* b = reinterpret_cast<const sockaddr_in*>(std::addressof(other.bindAddr));
+
+				return a->sin_addr.s_addr == b->sin_addr.s_addr;
+			}
+
+			case AF_INET6:
+			{
+				const auto* a = reinterpret_cast<const sockaddr_in6*>(std::addressof(this->bindAddr));
+				const auto* b = reinterpret_cast<const sockaddr_in6*>(std::addressof(other.bindAddr));
+
+				return std::memcmp(
+				         std::addressof(a->sin6_addr), std::addressof(b->sin6_addr), sizeof(in6_addr)) == 0;
+			}
+
+			default:
+			{
+				// Unknown family; treat as not equal to avoid accidental merge.
+				return false;
+			}
+		}
+	}
+
+	/* PortRangeKeyHash instance methods. */
+
+	size_t PortManager::PortRangeKeyHash::operator()(const PortRangeKey& key) const noexcept
+	{
+		MS_TRACE();
+
+		const auto protocolBits = static_cast<uint8_t>(key.protocol);
+		const auto familyBits   = static_cast<uint16_t>(key.bindAddr.ss_family);
+
+		auto hashCombine = [](size_t& seed, size_t value)
+		{
+			seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+		};
+
+		size_t seed = 0;
+
+		switch (key.bindAddr.ss_family)
+		{
+			case AF_INET:
+			{
+				const auto* in = reinterpret_cast<const sockaddr_in*>(std::addressof(key.bindAddr));
+
+				hashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint32_t>{}(in->sin_addr.s_addr));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
+
+				break;
+			}
+
+			case AF_INET6:
+			{
+				const auto* in6  = reinterpret_cast<const sockaddr_in6*>(std::addressof(key.bindAddr));
+				const auto* addr = in6->sin6_addr.s6_addr;
+
+				uint64_t hi;
+				uint64_t lo;
+
+				std::memcpy(std::addressof(hi), addr, sizeof(uint64_t));
+				std::memcpy(std::addressof(lo), addr + sizeof(uint64_t), sizeof(uint64_t));
+
+				hashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint64_t>{}(hi));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint64_t>{}(lo));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
+
+				break;
+			}
+
+			default:
+			{
+				hashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
+				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
+
+				break;
+			}
+		}
+
+		return seed;
+	}
 } // namespace RTC

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

@@ -1104,11 +1104,12 @@ namespace RTC
 				{
 					MS_WARN_TAG(
 					  sctp,
-					  "ABORT chunk verification tag %" PRIu32 " is wrong, packet discarded",
+					  "receievd ABORT chunk has invalid verification tag %" PRIu32 ", packet discarded",
 					  receivedPacket->GetVerificationTag());
 
 					this->associationListenerDeferrer.OnAssociationError(
-					  Types::ErrorKind::PARSE_FAILED, "packet with ABORT chunk has invalid verification tag");
+					  Types::ErrorKind::PARSE_FAILED,
+					  "received packet with ABORT chunk has invalid verification tag");
 
 					return false;
 				}
@@ -1124,13 +1125,14 @@ namespace RTC
 				{
 					MS_WARN_TAG(
 					  sctp,
-					  "INIT-ACK chunk verification tag %" PRIu32 " (should be %" PRIu32 ")",
+					  "received INIT-ACK chunk has invalid verification tag %" PRIu32 " (should be %" PRIu32
+					  "), packet discarded",
 					  receivedPacket->GetVerificationTag(),
 					  this->preTcb.localVerificationTag);
 
 					this->associationListenerDeferrer.OnAssociationError(
 					  Types::ErrorKind::PARSE_FAILED,
-					  "packet with INIT-ACK chunk has invalid verification tag");
+					  "received packet with INIT-ACK chunk has invalid verification tag");
 
 					return false;
 				}
@@ -1173,12 +1175,13 @@ namespace RTC
 				{
 					MS_WARN_TAG(
 					  sctp,
-					  "SHUTDOWN-COMPLETE chunk verification tag %" PRIu32 " is wrong, packet discarded",
+					  "received SHUTDOWN-COMPLETE chunk has invalid verification tag %" PRIu32
+					  ", packet discarded",
 					  receivedPacket->GetVerificationTag());
 
 					this->associationListenerDeferrer.OnAssociationError(
 					  Types::ErrorKind::PARSE_FAILED,
-					  "packet with SHUTDOWN-COMPLETE chunk has invalid verification tag");
+					  "received packet with SHUTDOWN-COMPLETE chunk has invalid verification tag");
 
 					return false;
 				}
@@ -1200,7 +1203,8 @@ namespace RTC
 			{
 				MS_WARN_TAG(
 				  sctp,
-				  "invalid verification tag %" PRIu32 " (should be %" PRIu32 ")",
+				  "received packet has invalid verification tag %" PRIu32 " (should be %" PRIu32
+				  "), packet discarded",
 				  receivedPacket->GetVerificationTag(),
 				  localVerificationTag);
 
@@ -1369,7 +1373,7 @@ namespace RTC
 			// be 0, the receiver MUST silently discard the packet."
 			if (receivedInitChunk->GetInitiateTag() == 0)
 			{
-				MS_WARN_TAG(sctp, "invalid value 0 in Initiate Tagin received INIT chunk, discarded");
+				MS_WARN_TAG(sctp, "invalid value 0 in Initiate Tag in received INIT chunk, packet discarded");
 
 				return;
 			}
@@ -1388,7 +1392,7 @@ namespace RTC
 			{
 				MS_WARN_TAG(
 				  sctp,
-				  "invalid number of outbound streams or Number of inbound streams in received INIT chunk, aborting association");
+				  "invalid number of outbound streams or number of inbound streams in received INIT chunk, aborting association");
 
 				auto packet                 = CreatePacketWithVerificationTag(0);
 				auto* abortAssociationChunk = packet->BuildChunkInPlace<AbortAssociationChunk>();
@@ -1557,7 +1561,7 @@ namespace RTC
 			// INIT ACK chunk."
 			if (this->state != State::COOKIE_WAIT)
 			{
-				MS_DEBUG_TAG(sctp, "ignoring received INIT-ACK chunk when not in COOKIE_WAIT state");
+				MS_DEBUG_TAG(sctp, "ignoring INIT-ACK chunk when not in COOKIE_WAIT state");
 
 				return;
 			}
@@ -1567,8 +1571,7 @@ namespace RTC
 
 			if (!stateCookieParameter || !stateCookieParameter->GetCookie())
 			{
-				MS_WARN_TAG(
-				  sctp, "ignoring received INIT-ACK chunk without StateCookieParameter or without cookie");
+				MS_WARN_TAG(sctp, "ignoring INIT-ACK chunk without StateCookieParameter or without cookie");
 
 				auto packet = CreatePacketWithVerificationTag(this->preTcb.localVerificationTag);
 				auto* abortAssociationChunk = packet->BuildChunkInPlace<AbortAssociationChunk>();
@@ -1643,10 +1646,10 @@ namespace RTC
 
 			if (!receivedCookieEchoChunk->HasCookie())
 			{
-				MS_WARN_TAG(sctp, "ignoring received COOKIE-ECHO chunk without cookie");
+				MS_WARN_TAG(sctp, "ignoring invalid COOKIE-ECHO chunk without cookie");
 
 				this->associationListenerDeferrer.OnAssociationError(
-				  Types::ErrorKind::PARSE_FAILED, "received COOKIE-ECHO chunk without cookie");
+				  Types::ErrorKind::PARSE_FAILED, "received COOKIE-ECHO chunk has no cookie");
 
 				return;
 			}

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

@@ -19,11 +19,11 @@ namespace RTC
 		/* Instance methods. */
 
 		HeartbeatHandler::HeartbeatHandler(
-		  AssociationListenerInterface& associationListener,
+		  AssociationListenerDeferrer& associationListenerDeferrer,
 		  const SctpOptions& sctpOptions,
 		  SharedInterface* shared,
 		  TransmissionControlBlockContextInterface* tcbContext)
-		  : associationListener(associationListener),
+		  : associationListenerDeferrer(associationListenerDeferrer),
 		    sctpOptions(sctpOptions),
 		    shared(shared),
 		    tcbContext(tcbContext),
@@ -124,7 +124,7 @@ namespace RTC
 
 			if (!heartbeatInfoParameter)
 			{
-				this->associationListener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED,
 				  "ignoring HEARTBEAT-ACK chunk without Heartbeat Info parameter");
 
@@ -136,14 +136,14 @@ namespace RTC
 
 			if (!info)
 			{
-				this->associationListener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "ignoring Heartbeat Info parameter without info field");
 
 				return;
 			}
 			else if (infoLen != HeartbeatInfoLength)
 			{
-				this->associationListener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "ignoring Heartbeat Info parameter with wrong length");
 
 				return;
@@ -180,6 +180,11 @@ namespace RTC
 		{
 			MS_TRACE();
 
+			// This is a top-level timer entry point (invoked by libuv outside any other
+			// SCTP API call), so it must establish the deferrer scope itself, just like
+			// Association does in its own timer handlers.
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
+
 			if (!this->tcbContext->IsAssociationEstablished())
 			{
 				MS_DEBUG_DEV("won't send HEARTBEAT-REQUEST when SCTP association is not established");
@@ -214,6 +219,11 @@ namespace RTC
 		{
 			MS_TRACE();
 
+			// This is a top-level timer entry point (invoked by libuv outside any other
+			// SCTP API call), so it must establish the deferrer scope itself, just like
+			// Association does in its own timer handlers.
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
+
 			// Note that the timeout timer is not restarted. It will be started again when
 			// the interval timer expires.
 			MS_ASSERT(!this->timeoutTimer->IsRunning(), "timeout timer shouldn't be running");

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

@@ -13,13 +13,13 @@ namespace RTC
 		/* Instance methods. */
 
 		StreamResetHandler::StreamResetHandler(
-		  AssociationListenerInterface& associationListener,
+		  AssociationListenerDeferrer& associationListenerDeferrer,
 		  SharedInterface* shared,
 		  TransmissionControlBlockContextInterface* tcbContext,
 		  DataTracker* dataTracker,
 		  ReassemblyQueue* reassemblyQueue,
 		  RetransmissionQueue* retransmissionQueue)
-		  : associationListener(associationListener),
+		  : associationListenerDeferrer(associationListenerDeferrer),
 		    shared(shared),
 		    tcbContext(tcbContext),
 		    dataTracker(dataTracker),
@@ -89,7 +89,7 @@ namespace RTC
 
 			if (!ValidateReceivedReConfigChunk(receivedReConfigChunk))
 			{
-				this->associationListener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "invalid RE-CONFIG command received");
 
 				return;
@@ -334,7 +334,7 @@ namespace RTC
 				this->reassemblyQueue->ResetStreamsAndLeaveDeferredReset(
 				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
 
-				this->associationListener.OnAssociationInboundStreamsReset(
+				this->associationListenerDeferrer.OnAssociationInboundStreamsReset(
 				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
 
 				this->lastProcessedReqResult = ReconfigurationResponseParameter::Result::SUCCESS_PERFORMED;
@@ -412,7 +412,7 @@ namespace RTC
 						MS_DEBUG_DEV(
 						  "reset stream success [reqSeqNbr:%" PRIu32 "]", this->currentRequest->GetReqSeqNbr());
 
-						this->associationListener.OnAssociationStreamsResetPerformed(
+						this->associationListenerDeferrer.OnAssociationStreamsResetPerformed(
 						  this->currentRequest->GetStreamIds());
 
 						this->currentRequest = std::nullopt;
@@ -450,7 +450,7 @@ namespace RTC
 						    receivedReconfigurationResponseParameter->GetResult())
 						    .c_str());
 
-						this->associationListener.OnAssociationStreamsResetFailed(
+						this->associationListenerDeferrer.OnAssociationStreamsResetFailed(
 						  this->currentRequest->GetStreamIds(),
 						  ReconfigurationResponseParameter::ResultToString(
 						    receivedReconfigurationResponseParameter->GetResult()));
@@ -469,6 +469,11 @@ namespace RTC
 		{
 			MS_TRACE();
 
+			// This is a top-level timer entry point (invoked by libuv outside any other
+			// SCTP API call), so it must establish the deferrer scope itself, just like
+			// Association does in its own timer handlers.
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
+
 			if (this->currentRequest && this->currentRequest->HasBeenSent())
 			{
 				// The request was deferred (received "In Progress"). This is not a