Plumbing changes to be compatible with Steamworks SDK.

In Steamworks, we want to keep the number of odinary DLL imports to an
absolute minimum, because those come from steam_api.dll, which we do
not update.  (The developer needs to take a new one to update their SDK.)
The functions in the interface come from steamclient.dll, which we do
update frequently.

This resulted in the following changes:
* Printing and parsing of SteamNetworkingIPAddr and SteamNetworkingIdentity
  were moved to ISteamNetworkingUtils functions.  Most C++ code will still
  access them through the inline class methods, so they won't really care
  where they are implemented.
* Deleted some hashing functions.  This is not hard to write, and the
  definition of operator= gives you an example of what to do.
* SteamNetworkingMessage::Release will happen through a pointer, so that it
  can be dynamiclaly linked.

Other changes:
* Renamed an old name "STEAMDATAGRAMLIB" to "STEAMNETWORKINGSOCKETS" in
  a few places.
* Use STEAMNETWORKINGSOCKETS_ENABLE_SDR in a few places, to remove
  SDR-specific functionality.  (We might opensource the SDR support code
  in the future.)

Author: zpostfacto

include/steam/isteamnetworkingutils.h

@@ -112,6 +112,13 @@ class ISteamNetworkingUtils
 	/// Return the lowest numbered configuration value available in the current environment.
 	virtual ESteamNetworkingConfigValue GetFirstConfigValue() = 0;
 
+	// String conversions.  You'll usually access these using the respective
+	// inline methods.
+	virtual void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr &addr, char *buf, size_t cbBuf, bool bWithPort ) = 0;
+	virtual bool SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr ) = 0;
+	virtual void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity, char *buf, size_t cbBuf ) = 0;
+	virtual bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, const char *pszStr ) = 0;
+
 protected:
 	~ISteamNetworkingUtils(); // Silence some warnings
 };
@@ -141,4 +148,11 @@ inline bool ISteamNetworkingUtils::SetConnectionConfigValueInt32( HSteamNetConne
 inline bool ISteamNetworkingUtils::SetConnectionConfigValueFloat( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, float val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Connection, hConn, k_ESteamNetworkingConfig_Float, &val ); }
 inline bool ISteamNetworkingUtils::SetConnectionConfigValueString( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, const char *val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Connection, hConn, k_ESteamNetworkingConfig_String, val ); }
 
+#if !defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) && defined( STEAMNETWORKINGSOCKETS_STEAM )
+inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamNetworkingUtils()->SteamNetworkingIPAddr_ToString( *this, buf, cbBuf, bWithPort ); }
+inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIPAddr_ParseString( this, pszStr ); }
+inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamNetworkingUtils()->SteamNetworkingIdentity_ToString( *this, buf, cbBuf ); }
+inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIdentity_ParseString( this, pszStr ); }
+#endif
+
 #endif // ISTEAMNETWORKINGUTILS

include/steam/steamnetworkingsockets_flat.h

@@ -18,7 +18,7 @@ extern "C" {
 
 STEAMNETWORKINGSOCKETS_INTERFACE HSteamListenSocket SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP( intptr_t instancePtr, const SteamNetworkingIPAddr *pAddress );
 STEAMNETWORKINGSOCKETS_INTERFACE HSteamNetConnection SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress( intptr_t instancePtr, const SteamNetworkingIPAddr *pAddress );
-#ifndef STEAMNETWORKINGSOCKETS_OPENSOURCE
+#ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
 STEAMNETWORKINGSOCKETS_INTERFACE HSteamNetConnection SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2P( intptr_t instancePtr, int nVirtualPort );
 STEAMNETWORKINGSOCKETS_INTERFACE HSteamNetConnection SteamAPI_ISteamNetworkingSockets_ConnectP2P( intptr_t instancePtr, const SteamNetworkingIdentity *pIdentity, int nVirtualPort );
 #endif
@@ -40,7 +40,7 @@ STEAMNETWORKINGSOCKETS_INTERFACE bool SteamAPI_ISteamNetworkingSockets_GetListen
 
 STEAMNETWORKINGSOCKETS_INTERFACE bool SteamAPI_ISteamNetworkingSockets_CreateSocketPair( intptr_t instancePtr, HSteamNetConnection *pOutConnection1, HSteamNetConnection *pOutConnection2, bool bUseNetworkLoopback, const SteamNetworkingIdentity *pIdentity1, const SteamNetworkingIdentity *pIdentity2 );
 
-#ifndef STEAMNETWORKINGSOCKETS_OPENSOURCE
+#ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
 
 STEAMNETWORKINGSOCKETS_INTERFACE bool SteamAPI_ISteamNetworkingSockets_ReceivedRelayAuthTicket( intptr_t instancePtr, const void *pvTicket, int cbTicket, SteamDatagramRelayAuthTicket *pOutParsedTicket );
 STEAMNETWORKINGSOCKETS_INTERFACE int SteamAPI_ISteamNetworkingSockets_FindRelayAuthTicketForServer( intptr_t instancePtr, const SteamNetworkingIdentity *pIdentityGameserver, int nVirtualPort, SteamDatagramRelayAuthTicket *pOutParsedTicket );
@@ -115,6 +115,8 @@ STEAMNETWORKINGSOCKETS_INTERFACE ESteamNetworkingGetConfigValueResult SteamAPI_I
 STEAMNETWORKINGSOCKETS_INTERFACE bool SteamAPI_ISteamNetworkingUtils_GetConfigValueInfo( intptr_t instancePtr, ESteamNetworkingConfigValue eValue, const char **pOutName, ESteamNetworkingConfigDataType *pOutDataType, ESteamNetworkingConfigScope *pOutScope, ESteamNetworkingConfigValue *pOutNextValue );
 STEAMNETWORKINGSOCKETS_INTERFACE ESteamNetworkingConfigValue SteamAPI_ISteamNetworkingUtils_GetFirstConfigValue( intptr_t instancePtr );
 
+STEAMNETWORKINGSOCKETS_INTERFACE void SteamAPI_SteamNetworkingMessage_t_Release( SteamNetworkingMessage_t *pIMsg );
+
 }
 
 #endif // ISTEAMNETWORKINGSOCKETS

include/steam/steamnetworkingtypes.h

@@ -26,9 +26,9 @@
 #include "steamtypes.h"
 #include "steamclientpublic.h"
 
-#if defined( STEAMDATAGRAMLIB_STATIC_LINK )
+#if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK )
 	#define STEAMNETWORKINGSOCKETS_INTERFACE extern "C"
-#elif defined( STEAMDATAGRAMLIB_FOREXPORT )
+#elif defined( STEAMNETWORKINGSOCKETS_FOREXPORT )
 	#define STEAMNETWORKINGSOCKETS_INTERFACE DLL_EXPORT
 #else
 	#define STEAMNETWORKINGSOCKETS_INTERFACE DLL_IMPORT
@@ -126,11 +126,11 @@ struct SteamNetworkingIPAddr
 	/// form according to RFC5952.  If you include the port, IPv6 will be surrounded by
 	/// brackets, e.g. [::1:2]:80.  Your buffer should be at least k_cchMaxString bytes
 	/// to avoid truncation
-	void ToString( char *buf, size_t cbBuf, bool bWithPort ) const;
+	inline void ToString( char *buf, size_t cbBuf, bool bWithPort ) const;
 
 	/// Parse an IP address and optional port.  If a port is not present, it is set to 0.
 	/// (This means that you cannot tell if a zero port was explicitly specified.)
-	bool ParseString( const char *pszStr );
+	inline bool ParseString( const char *pszStr );
 
 	union
 	{
@@ -181,11 +181,6 @@ struct SteamNetworkingIdentity
 	/// See if two identities are identical
 	bool operator==(const SteamNetworkingIdentity &x ) const;
 
-	/// Calculate hash of identity.  NOTE: This is just a reference implementation.
-	/// There is no "official" hash calculation that must be used, and these values
-	/// should never be persisted or used outside of the current process.
-	struct Hash { uint32 operator()( const SteamNetworkingIdentity &x ) const; };
-
 	/// Print to a human-readable string.  This is suitable for debug messages
 	/// or any other time you need to encode the identity as a string.  It has a
 	/// URL-like format (type:<type-data>).  Your buffer should be at least
@@ -499,6 +494,11 @@ typedef struct _SteamNetworkingMessage_t
 	/// free( pMsg->m_pData );
 	void (*m_pfnFreeData)( struct _SteamNetworkingMessage_t *msg );
 
+	/// Function to used to decrement reference count and, if it's zero, release
+	/// the message.  You should not normally need to access this directly.
+	/// (Use Release(), and don't set this.)
+	void (*m_pfnRelease)( struct _SteamNetworkingMessage_t *msg );
+
 	/// The channel number the message was received on.
 	/// (Not used for messages received on "connections")
 	int m_nChannel;
@@ -1048,13 +1048,6 @@ typedef void (*FSteamNetworkingSocketsDebugOutput)( ESteamNetworkingSocketsDebug
 typedef SteamNetworkingMessage_t ISteamNetworkingMessage;
 typedef SteamNetworkingErrMsg SteamDatagramErrMsg;
 
-STEAMNETWORKINGSOCKETS_INTERFACE void SteamAPI_SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr *pAddr, char *buf, size_t cbBuf, bool bWithPort );
-STEAMNETWORKINGSOCKETS_INTERFACE bool SteamAPI_SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr );
-STEAMNETWORKINGSOCKETS_INTERFACE void SteamAPI_SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity, char *buf, size_t cbBuf );
-STEAMNETWORKINGSOCKETS_INTERFACE bool SteamAPI_SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, size_t sizeofIdentity, const char *pszStr );
-STEAMNETWORKINGSOCKETS_INTERFACE uint32 SteamAPI_GenericHash( const void *data, size_t len );
-STEAMNETWORKINGSOCKETS_INTERFACE void SteamAPI_SteamNetworkingMessage_t_Release( SteamNetworkingMessage_t *pMsg );
-
 inline void SteamNetworkingIPAddr::Clear() { memset( this, 0, sizeof(*this) ); }
 inline bool SteamNetworkingIPAddr::IsIPv6AllZeros() const { const uint64 *q = (const uint64 *)m_ipv6; return q[0] == 0 && q[1] == 0; }
 inline void SteamNetworkingIPAddr::SetIPv6( const uint8 *ipv6, uint16 nPort ) { memcpy( m_ipv6, ipv6, 16 ); m_port = nPort; }
@@ -1063,8 +1056,6 @@ inline bool SteamNetworkingIPAddr::IsIPv4() const { return m_ipv4.m_8zeros == 0
 inline uint32 SteamNetworkingIPAddr::GetIPv4() const { return IsIPv4() ? ( (uint32(m_ipv4.m_ip[0])<<24) | (uint32(m_ipv4.m_ip[1])<<16) | (uint32(m_ipv4.m_ip[2])<<8) | uint32(m_ipv4.m_ip[3]) ) : 0; }
 inline void SteamNetworkingIPAddr::SetIPv6LocalHost( uint16 nPort ) { m_ipv4.m_8zeros = 0; m_ipv4.m_0000 = 0; m_ipv4.m_ffff = 0; m_ipv6[12] = 0; m_ipv6[13] = 0; m_ipv6[14] = 0; m_ipv6[15] = 1; m_port = nPort; }
 inline bool SteamNetworkingIPAddr::IsLocalHost() const { return ( m_ipv4.m_8zeros == 0 && m_ipv4.m_0000 == 0 && m_ipv4.m_ffff == 0 && m_ipv6[12] == 0 && m_ipv6[13] == 0 && m_ipv6[14] == 0 && m_ipv6[15] == 1 ) || ( GetIPv4() == 0x7f000001 ); }
-inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamAPI_SteamNetworkingIPAddr_ToString( this, buf, cbBuf, bWithPort ); }
-inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamAPI_SteamNetworkingIPAddr_ParseString( this, pszStr ); }
 
 inline void SteamNetworkingIdentity::Clear() { memset( this, 0, sizeof(*this) ); }
 inline bool SteamNetworkingIdentity::IsInvalid() const { return m_eType == k_ESteamNetworkingIdentityType_Invalid; }
@@ -1084,10 +1075,17 @@ inline bool SteamNetworkingIdentity::SetGenericBytes( const void *data, size_t c
 inline const uint8 *SteamNetworkingIdentity::GetGenericBytes( int &cbLen ) const { if ( m_eType != k_ESteamNetworkingIdentityType_GenericBytes ) return nullptr;
 	cbLen = m_cbSize; return m_genericBytes; }
 inline bool SteamNetworkingIdentity::operator==(const SteamNetworkingIdentity &x ) const { return m_eType == x.m_eType && m_cbSize == x.m_cbSize && memcmp( m_genericBytes, x.m_genericBytes, m_cbSize ) == 0; }
+inline void SteamNetworkingMessage_t::Release() { (*m_pfnRelease)( this ); }
+
+#if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) || !defined( STEAMNETWORKINGSOCKETS_STEAM )
+STEAMNETWORKINGSOCKETS_INTERFACE void SteamAPI_SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr *pAddr, char *buf, size_t cbBuf, bool bWithPort );
+STEAMNETWORKINGSOCKETS_INTERFACE bool SteamAPI_SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr );
+STEAMNETWORKINGSOCKETS_INTERFACE void SteamAPI_SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity, char *buf, size_t cbBuf );
+STEAMNETWORKINGSOCKETS_INTERFACE bool SteamAPI_SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, size_t sizeofIdentity, const char *pszStr );
+inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamAPI_SteamNetworkingIPAddr_ToString( this, buf, cbBuf, bWithPort ); }
+inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamAPI_SteamNetworkingIPAddr_ParseString( this, pszStr ); }
 inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamAPI_SteamNetworkingIdentity_ToString( *this, buf, cbBuf ); }
 inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamAPI_SteamNetworkingIdentity_ParseString( this, sizeof(*this), pszStr ); }
-inline uint32 SteamNetworkingIdentity::Hash::operator()( const SteamNetworkingIdentity &x ) const { return SteamAPI_GenericHash( &x, sizeof( x.m_eType ) + sizeof( x.m_cbSize ) + x.m_cbSize ); }
-
-inline void SteamNetworkingMessage_t::Release() { SteamAPI_SteamNetworkingMessage_t_Release( this ); }
+#endif
 
 #endif // #ifndef STEAMNETWORKINGTYPES

src/CMakeLists.txt

@@ -170,7 +170,7 @@ macro(gamenetworkingsockets_common GNS_TARGET)
 	endif()
 
 	target_compile_definitions(${GNS_TARGET} PRIVATE
-		STEAMDATAGRAMLIB_FOREXPORT
+		STEAMNETWORKINGSOCKETS_FOREXPORT
 		ENABLE_OPENSSLCONNECTION
 		CRYPTO_DISABLE_ENCRYPT_WITH_PASSWORD
 		GOOGLE_PROTOBUF_NO_RTTI
@@ -273,7 +273,7 @@ add_sanitizers(GameNetworkingSockets)
 
 add_library(GameNetworkingSockets_s STATIC "")
 add_library(GameNetworkingSockets::static ALIAS GameNetworkingSockets_s)
-target_compile_definitions(GameNetworkingSockets_s INTERFACE STEAMDATAGRAMLIB_STATIC_LINK)
+target_compile_definitions(GameNetworkingSockets_s INTERFACE STEAMNETWORKINGSOCKETS_STATIC_LINK)
 gamenetworkingsockets_common(GameNetworkingSockets_s)
 add_sanitizers(GameNetworkingSockets_s)
 

src/meson.build

@@ -60,7 +60,7 @@ dependencies += [
 incdirs = include_directories('.', '../include', 'common', 'public')
 
 cpp_flags = [
-  '-DSTEAMDATAGRAMLIB_FOREXPORT',
+  '-DSTEAMNETWORKINGSOCKETS_FOREXPORT',
   '-DENABLE_OPENSSLCONNECTION',
   '-DCRYPTO_DISABLE_ENCRYPT_WITH_PASSWORD',
   '-DGOOGLE_PROTOBUF_NO_RTTI',
@@ -137,7 +137,7 @@ GameNetworkingSockets_static = static_library('GameNetworkingSockets',
 
 dep_GameNetworkingSockets_static = declare_dependency(
   include_directories: include_directories( '../include', '.' ),
-  compile_args: ['-DSTEAMDATAGRAMLIB_STATIC_LINK'],
+  compile_args: ['-DSTEAMNETWORKINGSOCKETS_STATIC_LINK'],
   link_with: GameNetworkingSockets_static )
 
 GameNetworkingSockets_so = library('GameNetworkingSockets',

src/steamnetworkingsockets/clientlib/csteamnetworkingsockets.cpp

@@ -1,7 +1,6 @@
 //====== Copyright Valve Corporation, All rights reserved. ====================
 
 #include "csteamnetworkingsockets.h"
-#include <steam/steamnetworkingsockets.h>
 #include "steamnetworkingsockets_lowlevel.h"
 #include "steamnetworkingsockets_connections.h"
 #include "steamnetworkingsockets_udp.h"
@@ -1204,6 +1203,27 @@ ESteamNetworkingConfigValue CSteamNetworkingUtils::GetFirstConfigValue()
 	return s_vecConfigValueTable[0]->m_eValue;
 }
 
+
+void CSteamNetworkingUtils::SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr &addr, char *buf, size_t cbBuf, bool bWithPort )
+{
+	SteamAPI_SteamNetworkingIPAddr_ToString( &addr, buf, cbBuf, bWithPort );
+}
+
+bool CSteamNetworkingUtils::SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr )
+{
+	return SteamAPI_SteamNetworkingIPAddr_ParseString( pAddr, pszStr );
+}
+
+void CSteamNetworkingUtils::SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity, char *buf, size_t cbBuf )
+{
+	return SteamAPI_SteamNetworkingIdentity_ToString( identity, buf, cbBuf );
+}
+
+bool CSteamNetworkingUtils::SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, const char *pszStr )
+{
+	return SteamAPI_SteamNetworkingIdentity_ParseString( pIdentity, sizeof(SteamNetworkingIdentity), pszStr );
+}
+
 } // namespace SteamNetworkingSocketsLib
 using namespace SteamNetworkingSocketsLib;
 

src/steamnetworkingsockets/clientlib/csteamnetworkingsockets.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <time.h>
-#include <steam/steamnetworkingsockets.h>
+#include <steam/isteamnetworkingsockets.h>
 #include <steam/isteamnetworkingutils.h>
 
 #ifdef STEAMNETWORKINGSOCKETS_STEAM
@@ -140,6 +140,11 @@ class CSteamNetworkingUtils : public IClientNetworkingUtils
 		ESteamNetworkingConfigScope *pOutScope, ESteamNetworkingConfigValue *pOutNextValue ) override;
 
 	virtual ESteamNetworkingConfigValue GetFirstConfigValue() override;
+
+	virtual void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr &addr, char *buf, size_t cbBuf, bool bWithPort ) override;
+	virtual bool SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr ) override;
+	virtual void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity, char *buf, size_t cbBuf ) override;
+	virtual bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, const char *pszStr ) override;
 };
 
 } // namespace SteamNetworkingSocketsLib

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_connections.cpp

@@ -97,6 +97,32 @@ void CSteamNetworkingMessage::DefaultFreeData( SteamNetworkingMessage_t *pMsg )
 	free( pMsg->m_pData );
 }
 
+
+void SteamNetworkingMessage_t_Release( SteamNetworkingMessage_t *pIMsg )
+{
+	CSteamNetworkingMessage *pMsg = static_cast<CSteamNetworkingMessage *>( pIMsg );
+
+	// Free up the buffer, if we have one
+	if ( pMsg->m_pData )
+	{
+		(*pMsg->m_pfnFreeData)( pMsg );
+		pMsg->m_pData = nullptr;
+	}
+
+	// We must not currently be in any queue.  In fact, our parent
+	// might have been destroyed.
+	Assert( !pMsg->m_linksSameConnection.m_pQueue );
+	Assert( !pMsg->m_linksSameConnection.m_pPrev );
+	Assert( !pMsg->m_linksSameConnection.m_pNext );
+	Assert( !pMsg->m_linksSecondaryQueue.m_pQueue );
+	Assert( !pMsg->m_linksSecondaryQueue.m_pPrev );
+	Assert( !pMsg->m_linksSecondaryQueue.m_pNext );
+
+	// Self destruct
+	// FIXME Should avoid this dynamic memory call with some sort of pooling
+	delete pMsg;
+}
+
 CSteamNetworkingMessage *CSteamNetworkingMessage::New( CSteamNetworkConnectionBase *pParent, uint32 cbSize, int64 nMsgNum, SteamNetworkingMicroseconds usecNow )
 {
 	// FIXME Should avoid this dynamic memory call with some sort of pooling
@@ -120,6 +146,7 @@ CSteamNetworkingMessage *CSteamNetworkingMessage::New( CSteamNetworkConnectionBa
 	pMsg->m_usecTimeReceived = usecNow;
 	pMsg->m_nMessageNumber = nMsgNum;
 	pMsg->m_pfnFreeData = CSteamNetworkingMessage::DefaultFreeData;
+	pMsg->m_pfnRelease = SteamNetworkingMessage_t_Release;
 	return pMsg;
 }
 
@@ -2278,30 +2305,3 @@ void CSteamNetworkConnectionBase::ValidateStatics( CValidator &validator )
 #endif
 
 } // namespace SteamNetworkingSocketsLib
-
-using namespace SteamNetworkingSocketsLib;
-
-STEAMNETWORKINGSOCKETS_INTERFACE void SteamAPI_SteamNetworkingMessage_t_Release( SteamNetworkingMessage_t *pIMsg )
-{
-	CSteamNetworkingMessage *pMsg = static_cast<CSteamNetworkingMessage *>( pIMsg );
-
-	// Free up the buffer, if we have one
-	if ( pMsg->m_pData )
-	{
-		(*pMsg->m_pfnFreeData)( pMsg );
-		pMsg->m_pData = nullptr;
-	}
-
-	// We must not currently be in any queue.  In fact, our parent
-	// might have been destroyed.
-	Assert( !pMsg->m_linksSameConnection.m_pQueue );
-	Assert( !pMsg->m_linksSameConnection.m_pPrev );
-	Assert( !pMsg->m_linksSameConnection.m_pNext );
-	Assert( !pMsg->m_linksSecondaryQueue.m_pQueue );
-	Assert( !pMsg->m_linksSecondaryQueue.m_pPrev );
-	Assert( !pMsg->m_linksSecondaryQueue.m_pNext );
-
-	// Self destruct
-	// FIXME Should avoid this dynamic memory call with some sort of pooling
-	delete pMsg;
-}

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_connections.h

@@ -66,7 +66,7 @@ struct RemoteConnectionKey_t
 	// protect against malicious clients we might have to include
 	// some random private data so that they don't know how our hash
 	// function works.  We'll assume for now that this isn't a problem
-	struct Hash { uint32 operator()( const RemoteConnectionKey_t &x ) const { return SteamNetworkingIdentity::Hash{}( x.m_identity ) ^ x.m_unConnectionID; } };
+	struct Hash { uint32 operator()( const RemoteConnectionKey_t &x ) const { return SteamNetworkingIdentityHash{}( x.m_identity ) ^ x.m_unConnectionID; } };
 	inline bool operator ==( const RemoteConnectionKey_t &x ) const
 	{
 		return m_unConnectionID == x.m_unConnectionID && m_identity == x.m_identity;