mediasoup 3.20.8 → 3.20.9

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/SeqManager.cpp

@@ -187,7 +187,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