mediasoup 3.20.8 → 3.20.10

package/worker/include/RTC/TransportTuple.hpp

@@ -23,28 +23,60 @@ namespace RTC
 			TCP = 2
 		};
 
+		class TupleKey
+		{
+		private:
+			friend class TransportTuple;
+			friend class TupleKeyHash;
+
+		public:
+			TupleKey() = default;
+			TupleKey(Protocol protocol, const void* udpSocketOrTcpConnection, const struct sockaddr* udpRemoteAddr)
+			  : protocol(protocol),
+			    udpSocketOrTcpConnection(udpSocketOrTcpConnection),
+			    udpRemoteAddr(udpRemoteAddr) {};
+
+			bool operator==(const TupleKey& other) const noexcept;
+			bool operator!=(const TupleKey& other) const noexcept
+			{
+				return !(*this == other);
+			};
+
+		private:
+			Protocol protocol{ Protocol::UDP };
+			// The local endpoint is identified by object pointer identity: the
+			// UdpSocket or the TcpConnection. For TCP the connection alone identifies
+			// the whole tuple, so `udpRemoteAddr` is unused.
+			const void* udpSocketOrTcpConnection{ nullptr };
+			const struct sockaddr* udpRemoteAddr{ nullptr };
+		};
+
+		struct TupleKeyHash
+		{
+			size_t operator()(const TupleKey& key) const noexcept;
+		};
+
 		static Protocol ProtocolFromFbs(FBS::Transport::Protocol protocol);
 		static FBS::Transport::Protocol ProtocolToFbs(Protocol protocol);
-		static uint64_t GenerateFnv1aHash(const uint8_t* data, size_t size);
 
 	public:
 		TransportTuple(RTC::UdpSocket* udpSocket, const struct sockaddr* udpRemoteAddr)
 		  : udpSocket(udpSocket),
 		    udpRemoteAddr(const_cast<struct sockaddr*>(udpRemoteAddr)),
-		    protocol(Protocol::UDP)
+		    protocol(Protocol::UDP),
+		    tupleKey(Protocol::UDP, udpSocket, udpRemoteAddr)
 		{
-			GenerateHash();
 		}
 
 		explicit TransportTuple(RTC::TcpConnection* tcpConnection)
-		  : tcpConnection(tcpConnection), protocol(Protocol::TCP)
+		  : tcpConnection(tcpConnection),
+		    protocol(Protocol::TCP),
+		    tupleKey(Protocol::TCP, tcpConnection, nullptr)
 		{
-			GenerateHash();
 		}
 
 		explicit TransportTuple(const TransportTuple* tuple)
-		  : hash(tuple->hash),
-		    udpSocket(tuple->udpSocket),
+		  : udpSocket(tuple->udpSocket),
 		    udpRemoteAddr(tuple->udpRemoteAddr),
 		    tcpConnection(tuple->tcpConnection),
 		    localAnnouncedAddress(tuple->localAnnouncedAddress),
@@ -54,6 +86,10 @@ namespace RTC
 			{
 				StoreUdpRemoteAddress();
 			}
+			else
+			{
+				this->tupleKey = TupleKey(this->protocol, this->tcpConnection, nullptr);
+			}
 		}
 
 	public:
@@ -70,11 +106,32 @@ namespace RTC
 			this->udpRemoteAddrStorage = Utils::IP::CopyAddress(this->udpRemoteAddr);
 			this->udpRemoteAddr =
 			  reinterpret_cast<struct sockaddr*>(std::addressof(this->udpRemoteAddrStorage));
+			this->tupleKey = TupleKey(this->protocol, this->udpSocket, this->udpRemoteAddr);
 		}
 
 		bool Compare(const TransportTuple* tuple) const
 		{
-			return this->hash == tuple->hash;
+			if (this->protocol != tuple->protocol)
+			{
+				return false;
+			}
+
+			switch (this->protocol)
+			{
+				case Protocol::UDP:
+				{
+					return (
+					  this->udpSocket == tuple->udpSocket &&
+					  Utils::IP::CompareAddresses(this->udpRemoteAddr, tuple->udpRemoteAddr));
+				}
+
+				case Protocol::TCP:
+				{
+					return (this->tcpConnection == tuple->tcpConnection);
+				}
+			}
+
+			return true;
 		}
 
 		void SetLocalAnnouncedAddress(std::string& localAnnouncedAddress)
@@ -147,12 +204,10 @@ namespace RTC
 			}
 		}
 
-	private:
-		void SetHash();
-		void GenerateHash();
-
-	public:
-		uint64_t hash{ 0u };
+		const TupleKey& GetTupleKey() const
+		{
+			return this->tupleKey;
+		}
 
 	private:
 		// Passed by argument.
@@ -163,6 +218,7 @@ namespace RTC
 		// Others.
 		struct sockaddr_storage udpRemoteAddrStorage{};
 		Protocol protocol;
+		TupleKey tupleKey;
 	};
 } // namespace RTC
 

package/worker/include/RTC/WebRtcServer.hpp

@@ -10,6 +10,7 @@
 #include "RTC/UdpSocket.hpp"
 #include "RTC/WebRtcTransport.hpp"
 #include "SharedInterface.hpp"
+#include "TransportTuple.hpp"
 #include <flatbuffers/flatbuffers.h>
 #include <ankerl/unordered_dense.h>
 #include <string>
@@ -118,8 +119,10 @@ namespace RTC
 		ankerl::unordered_dense::set<RTC::WebRtcTransport*> webRtcTransports;
 		// Map of WebRtcTransports indexed by local ICE usernameFragment.
 		ankerl::unordered_dense::map<std::string, RTC::WebRtcTransport*> mapLocalIceUsernameFragmentWebRtcTransport;
-		// Map of WebRtcTransports indexed by TransportTuple.hash.
-		ankerl::unordered_dense::map<uint64_t, RTC::WebRtcTransport*> mapTupleWebRtcTransport;
+		// Map of WebRtcTransports indexed by TransportTuple::TupleKey.
+		ankerl::unordered_dense::
+		  map<RTC::TransportTuple::TupleKey, RTC::WebRtcTransport*, RTC::TransportTuple::TupleKeyHash>
+		    mapTupleWebRtcTransport;
 		// Whether the destructor has been called.
 		bool closing{ false };
 	};

package/worker/include/Utils.hpp

@@ -264,6 +264,12 @@ namespace Utils
 
 		static void WriteRandomBytes(uint8_t* buffer, size_t len);
 
+		static void HashCombine(size_t& seed, size_t value)
+		{
+			// The implementation is the same as boost::hash_combine().
+			seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+		};
+
 	private:
 		static thread_local std::mt19937_64 rng;
 		static thread_local EVP_MAC* mac;

package/worker/src/RTC/ICE/IceServer.cpp

@@ -523,7 +523,8 @@ namespace RTC
 			HandleTuple(
 			  tuple,
 			  request->HasAttribute(StunPacket::AttributeType::USE_CANDIDATE),
-			  request->HasAttribute(StunPacket::AttributeType::NOMINATION),
+			  request->HasAttribute(StunPacket::AttributeType::NOMINATION) ||
+			    request->HasAttribute(StunPacket::AttributeType::NOMINATION_OLD),
 			  request->GetNomination());
 
 			// If state is 'connected' or 'completed' after handling the tuple, then

package/worker/src/RTC/ICE/StunPacket.cpp

@@ -250,6 +250,11 @@ namespace RTC
 				MS_DUMP_CLEAN(indentation + 1, "  nomination: %" PRIu32, GetNomination());
 			}
 
+			if (HasAttribute(StunPacket::AttributeType::NOMINATION_OLD))
+			{
+				MS_DUMP_CLEAN(indentation + 1, "  nomination (old): %" PRIu32, GetNomination());
+			}
+
 			if (HasAttribute(StunPacket::AttributeType::SOFTWARE))
 			{
 				const auto software = GetSoftware();
@@ -404,6 +409,8 @@ namespace RTC
 
 			StoreNewAttribute(
 			  StunPacket::AttributeType::NOMINATION, AttributeFactoryBuffer, sizeof(nomination));
+			StoreNewAttribute(
+			  StunPacket::AttributeType::NOMINATION_OLD, AttributeFactoryBuffer, sizeof(nomination));
 		}
 
 		void StunPacket::AddSoftware(const std::string_view software)
@@ -1058,6 +1065,7 @@ namespace RTC
 					}
 
 					case StunPacket::AttributeType::NOMINATION:
+					case StunPacket::AttributeType::NOMINATION_OLD:
 					{
 						if (attrLen != 4)
 						{

package/worker/src/RTC/NackGenerator.cpp

@@ -16,7 +16,7 @@ namespace RTC
 
 	/* Instance methods. */
 
-	NackGenerator::NackGenerator(Listener* listener, SharedInterface* shared, unsigned int sendNackDelayMs)
+	NackGenerator::NackGenerator(Listener* listener, SharedInterface* shared, uint32_t sendNackDelayMs)
 	  : listener(listener),
 	    shared(shared),
 	    sendNackDelayMs(sendNackDelayMs),

package/worker/src/RTC/PortManager.cpp

@@ -797,11 +797,6 @@ namespace RTC
 		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)
@@ -810,11 +805,12 @@ namespace RTC
 			{
 				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));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
+				Utils::Crypto::HashCombine(
+				  seed, ankerl::unordered_dense::hash<uint32_t>{}(in->sin_addr.s_addr));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
 
 				break;
 			}
@@ -830,22 +826,22 @@ namespace RTC
 				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));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint64_t>{}(hi));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint64_t>{}(lo));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
+				Utils::Crypto::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));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
 
 				break;
 			}

package/worker/src/RTC/Producer.cpp

@@ -20,7 +20,7 @@ namespace RTC
 
 	static constexpr size_t ProducerSendBufferSize{ 65536 };
 	static thread_local uint8_t ProducerSendBuffer[ProducerSendBufferSize];
-	static constexpr unsigned int SendNackDelay{ 10u }; // In ms.
+	static constexpr uint32_t SendNackDelay{ 10u }; // In ms.
 
 	/* Instance methods. */
 

package/worker/src/RTC/SeqManager.cpp

@@ -140,9 +140,7 @@ namespace RTC
 			}
 
 			// There are dropped inputs, calculate 'base' for this input.
-			auto droppedCount = std::distance(
-			  this->dropped.begin(),
-			  std::lower_bound(this->dropped.begin(), this->dropped.end(), input, SeqLowerThan()));
+			auto droppedCount = std::distance(this->dropped.begin(), it);
 
 			base = (this->base - droppedCount) & SeqManager::MaxValue;
 		}
@@ -187,7 +185,10 @@ namespace RTC
 	template<typename T, uint8_t N>
 	T SeqManager<T, N>::GetMaxOutput() const
 	{
-		return this->maxOutput;
+		// 'maxOutput' is stored in the offset-less space (as 'base' and comparisons
+		// use it), so apply 'initialOutput' here, just like `Input()` does before
+		// returning the output to the caller.
+		return (this->maxOutput + this->initialOutput) & SeqManager::MaxValue;
 	}
 
 	/*

package/worker/src/RTC/TransportTuple.cpp

@@ -49,22 +49,6 @@ namespace RTC
 		}
 	}
 
-	uint64_t TransportTuple::GenerateFnv1aHash(const uint8_t* data, size_t size)
-	{
-		MS_TRACE();
-
-		const uint64_t fnvOffsetBasis = 14695981039346656037ull;
-		const uint64_t fnvPrime       = 1099511628211ull;
-		uint64_t hash                 = fnvOffsetBasis;
-
-		for (size_t i = 0; i < size; ++i)
-		{
-			hash = (hash ^ data[i]) * fnvPrime;
-		}
-
-		return hash;
-	}
-
 	/* Instance methods. */
 
 	void TransportTuple::CloseTcpConnection()
@@ -143,54 +127,107 @@ namespace RTC
 			}
 		}
 
-		MS_DUMP_CLEAN(indentation, "  hash: %" PRIu64, this->hash);
-
 		MS_DUMP_CLEAN(indentation, "</TransportTuple>");
 	}
 
-	void TransportTuple::GenerateHash()
+	bool TransportTuple::TupleKey::operator==(const TupleKey& other) const noexcept
 	{
 		MS_TRACE();
 
-		const auto* localSockAddr  = GetLocalAddress();
-		const auto* remoteSockAddr = GetRemoteAddress();
-
-		// Maximum buffer length for two IPv6 addresses and ports plus protocol.
-		static constexpr size_t BufferSize = ((16 + 2) * 2) + 1;
-		uint8_t buffer[BufferSize]         = {};
-		size_t idx                         = 0;
+		if (this->protocol != other.protocol)
+		{
+			return false;
+		}
 
-		auto appendSockAddr = [&](const struct sockaddr* addr)
+		switch (this->protocol)
 		{
-			if (addr->sa_family == AF_INET)
+			// For UDP compare the remote address first (it discriminates faster) and then
+			// the socket.
+			case Protocol::UDP:
 			{
-				const auto* in      = reinterpret_cast<const struct sockaddr_in*>(addr);
-				const auto* ip      = reinterpret_cast<const uint8_t*>(&in->sin_addr.s_addr);
-				const uint16_t port = ntohs(in->sin_port);
-
-				std::memcpy(buffer + idx, ip, 4);
-				idx += 4;
-				buffer[idx++] = (port >> 8) & 0xFF;
-				buffer[idx++] = port & 0xFF;
+				return Utils::IP::CompareAddresses(this->udpRemoteAddr, other.udpRemoteAddr) &&
+				       this->udpSocketOrTcpConnection == other.udpSocketOrTcpConnection;
 			}
-			else if (addr->sa_family == AF_INET6)
+
+			// For TCP the connection pointer fully identifies the tuple.
+			case Protocol::TCP:
 			{
-				const auto* in6     = reinterpret_cast<const struct sockaddr_in6*>(addr);
-				const auto* ip      = reinterpret_cast<const uint8_t*>(&in6->sin6_addr);
-				const uint16_t port = ntohs(in6->sin6_port);
-
-				std::memcpy(buffer + idx, ip, 16);
-				idx += 16;
-				buffer[idx++] = (port >> 8) & 0xFF;
-				buffer[idx++] = port & 0xFF;
+				return this->udpSocketOrTcpConnection == other.udpSocketOrTcpConnection;
 			}
-		};
 
-		appendSockAddr(localSockAddr);
-		appendSockAddr(remoteSockAddr);
+				NO_DEFAULT_GCC();
+		}
+	}
+
+	size_t TransportTuple::TupleKeyHash::operator()(const TupleKey& key) const noexcept
+	{
+		MS_TRACE();
+
+		const auto protocolBits = static_cast<uint8_t>(key.protocol);
 
-		buffer[idx] = static_cast<uint8_t>(this->protocol);
+		size_t seed = 0;
 
-		this->hash = TransportTuple::GenerateFnv1aHash(buffer, idx + 1);
+		Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
+		Utils::Crypto::HashCombine(
+		  seed,
+		  ankerl::unordered_dense::hash<uintptr_t>{}(
+		    reinterpret_cast<uintptr_t>(key.udpSocketOrTcpConnection)));
+
+		switch (key.protocol)
+		{
+			case Protocol::UDP:
+			{
+				// For UDP also combine the remote address.
+				const auto familyBits = static_cast<uint16_t>(key.udpRemoteAddr->sa_family);
+
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
+
+				switch (key.udpRemoteAddr->sa_family)
+				{
+					case AF_INET:
+					{
+						const auto* remoteIn = reinterpret_cast<const sockaddr_in*>(key.udpRemoteAddr);
+
+						Utils::Crypto::HashCombine(
+						  seed, ankerl::unordered_dense::hash<uint32_t>{}(remoteIn->sin_addr.s_addr));
+						Utils::Crypto::HashCombine(
+						  seed, ankerl::unordered_dense::hash<uint16_t>{}(remoteIn->sin_port));
+
+						break;
+					}
+
+					case AF_INET6:
+					{
+						const auto* remoteIn6 = reinterpret_cast<const sockaddr_in6*>(key.udpRemoteAddr);
+						const auto* addr      = remoteIn6->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));
+
+						Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint64_t>{}(hi));
+						Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint64_t>{}(lo));
+						Utils::Crypto::HashCombine(
+						  seed, ankerl::unordered_dense::hash<uint16_t>{}(remoteIn6->sin6_port));
+
+						break;
+					}
+
+					default:;
+				}
+
+				return seed;
+			}
+
+			case Protocol::TCP:
+			{
+				// For TCP the connection pointer is enough.
+				return seed;
+			}
+
+				NO_DEFAULT_GCC();
+		}
 	}
 } // namespace RTC

package/worker/src/RTC/WebRtcServer.cpp

@@ -303,26 +303,13 @@ namespace RTC
 			    builder, localIceUsernameFragment.c_str(), webRtcTransport->id.c_str()));
 		}
 
-		// Add tupleHashes.
-		std::vector<flatbuffers::Offset<FBS::WebRtcServer::TupleHash>> tupleHashes;
-
-		for (const auto& kv : this->mapTupleWebRtcTransport)
-		{
-			const auto& tupleHash       = kv.first;
-			const auto* webRtcTransport = kv.second;
-
-			tupleHashes.emplace_back(
-			  FBS::WebRtcServer::CreateTupleHashDirect(builder, tupleHash, webRtcTransport->id.c_str()));
-		}
-
 		return FBS::WebRtcServer::CreateDumpResponseDirect(
 		  builder,
 		  this->id.c_str(),
-		  &udpSockets,
-		  &tcpServers,
-		  &webRtcTransportIds,
-		  &localIceUsernameFragments,
-		  &tupleHashes);
+		  std::addressof(udpSockets),
+		  std::addressof(tcpServers),
+		  std::addressof(webRtcTransportIds),
+		  std::addressof(localIceUsernameFragments));
 	}
 
 	void WebRtcServer::HandleRequest(Channel::ChannelRequest* request)
@@ -450,7 +437,7 @@ namespace RTC
 		}
 
 		// First try doing lookup in the tuples table.
-		auto it1 = this->mapTupleWebRtcTransport.find(tuple->hash);
+		auto it1 = this->mapTupleWebRtcTransport.find(tuple->GetTupleKey());
 
 		if (it1 != this->mapTupleWebRtcTransport.end())
 		{
@@ -488,7 +475,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		auto it = this->mapTupleWebRtcTransport.find(tuple->hash);
+		auto it = this->mapTupleWebRtcTransport.find(tuple->GetTupleKey());
 
 		if (it == this->mapTupleWebRtcTransport.end())
 		{
@@ -562,14 +549,16 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		if (this->mapTupleWebRtcTransport.find(tuple->hash) != this->mapTupleWebRtcTransport.end())
+		auto tupleKey = tuple->GetTupleKey();
+
+		if (this->mapTupleWebRtcTransport.contains(tupleKey))
 		{
-			MS_WARN_TAG(ice, "tuple hash already exists in the table");
+			MS_WARN_TAG(ice, "tuple key already exists in the table");
 
 			return;
 		}
 
-		this->mapTupleWebRtcTransport[tuple->hash] = webRtcTransport;
+		this->mapTupleWebRtcTransport[tupleKey] = webRtcTransport;
 	}
 
 	inline void WebRtcServer::OnWebRtcTransportTransportTupleRemoved(
@@ -577,14 +566,16 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		if (this->mapTupleWebRtcTransport.find(tuple->hash) == this->mapTupleWebRtcTransport.end())
+		auto it = this->mapTupleWebRtcTransport.find(tuple->GetTupleKey());
+
+		if (it == this->mapTupleWebRtcTransport.end())
 		{
-			MS_DEBUG_TAG(ice, "tuple hash not found in the table");
+			MS_DEBUG_TAG(ice, "tuple key not found in the table");
 
 			return;
 		}
 
-		this->mapTupleWebRtcTransport.erase(tuple->hash);
+		this->mapTupleWebRtcTransport.erase(it);
 	}
 
 	inline void WebRtcServer::OnUdpSocketPacketReceived(
@@ -598,7 +589,7 @@ namespace RTC
 
 		RTC::TransportTuple tuple(socket, remoteAddr);
 
-		OnPacketReceived(&tuple, data, len, bufferLen);
+		OnPacketReceived(std::addressof(tuple), data, len, bufferLen);
 	}
 
 	inline void WebRtcServer::OnRtcTcpConnectionClosed(
@@ -612,7 +603,7 @@ namespace RTC
 		// mapTupleWebRtcTransport because this event may be called after the tuple
 		// was removed from it.
 
-		auto it = this->mapTupleWebRtcTransport.find(tuple.hash);
+		auto it = this->mapTupleWebRtcTransport.find(tuple.GetTupleKey());
 
 		if (it == this->mapTupleWebRtcTransport.end())
 		{
@@ -621,7 +612,7 @@ namespace RTC
 
 		auto* webRtcTransport = it->second;
 
-		webRtcTransport->RemoveTuple(&tuple);
+		webRtcTransport->RemoveTuple(std::addressof(tuple));
 	}
 
 	inline void WebRtcServer::OnTcpConnectionPacketReceived(
@@ -631,6 +622,6 @@ namespace RTC
 
 		RTC::TransportTuple tuple(connection);
 
-		OnPacketReceived(&tuple, data, len, bufferLen);
+		OnPacketReceived(std::addressof(tuple), data, len, bufferLen);
 	}
 } // namespace RTC

package/worker/test/src/RTC/ICE/TestStunPacket.cpp

@@ -508,7 +508,9 @@ SCENARIO("ICE StunPacket", "[serializable][ice][stunpacket]")
 		// Byte length: 8.
 		uint64_t iceControlling = 15697499370457501716u;
 		// Byte length of USE_CANDIDATE: 0.
-		// // Byte length: 4.
+		// NOTE: `AddNomination()` adds the "NOMINATION" attribute with both the old
+		// and the new value, so it will insert 2 attributes instead of one.
+		// Byte length: 4 x 2.
 		uint32_t nomination = 12345678u;
 		// Byte length: 18 (2 byte of padding needed).
 		std::string software = "mediasoup x.y.z :)";
@@ -518,7 +520,7 @@ SCENARIO("ICE StunPacket", "[serializable][ice][stunpacket]")
 
 		// Total length of the attributes.
 		size_t attributesLen =
-		  (4 + 27 + 1) + (4 + 4) + (4 + 8) + (4) + (4 + 4) + (4 + 18 + 2) + (4 + 4 + 23 + 1);
+		  (4 + 27 + 1) + (4 + 4) + (4 + 8) + (4) + ((4 + 4) * 2) + (4 + 18 + 2) + (4 + 4 + 23 + 1);
 
 		request->AddUsername(username);
 		request->AddPriority(priority);
@@ -533,6 +535,8 @@ SCENARIO("ICE StunPacket", "[serializable][ice][stunpacket]")
 		REQUIRE_THROWS_AS(request->AddPriority(priority), MediaSoupError);
 		REQUIRE_THROWS_AS(request->AddIceControlling(iceControlling), MediaSoupError);
 		REQUIRE_THROWS_AS(request->AddUseCandidate(), MediaSoupError);
+		// NOTE: `AddNomination()` adds the "NOMINATION" attribute with both the old
+		// and the new value, so it will insert 2 attributes instead of one.
 		REQUIRE_THROWS_AS(request->AddNomination(nomination), MediaSoupError);
 		REQUIRE_THROWS_AS(request->AddSoftware(software), MediaSoupError);
 		REQUIRE_THROWS_AS(request->AddErrorCode(errorCode, errorReasonPhrase), MediaSoupError);

package/worker/test/src/RTC/RTP/TestRtpStreamRecv.cpp

@@ -8,7 +8,7 @@
 
 // 17: 16 bit mask + the initial sequence number.
 static constexpr size_t MaxRequestedPackets{ 17 };
-static constexpr unsigned int SendNackDelay{ 0u }; // In ms.
+static constexpr uint32_t SendNackDelay{ 0u }; // In ms.
 static const bool UseRtpInactivityCheck{ false };
 
 SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")

package/worker/test/src/RTC/TestNackGenerator.cpp

@@ -9,7 +9,7 @@
 
 SCENARIO("NackGenerator generator", "[rtp][rtcp][nack]")
 {
-	constexpr unsigned int SendNackDelay{ 0u }; // In ms.
+	constexpr uint32_t SendNackDelay{ 0u }; // In ms.
 
 	struct TestNackGeneratorInput
 	{