Rename SteamDatagramTransportLock to SteamNetworkingGlobalLock.

This is the start of some refactoring for more granular locking.

src/steamnetworkingsockets/clientlib/csteamnetworkingmessages.cpp

@@ -47,8 +47,8 @@ CSteamNetworkingMessages *CSteamNetworkingSockets::GetSteamNetworkingMessages()
 	// Already exist?
 	if ( !m_pSteamNetworkingMessages )
 	{
-		SteamDatagramTransportLock scopeLock;
-		SteamDatagramTransportLock::SetLongLockWarningThresholdMS( "CreateSteamNetworkingMessages", 10 );
+		SteamNetworkingGlobalLock scopeLock;
+		SteamNetworkingGlobalLock::SetLongLockWarningThresholdMS( "CreateSteamNetworkingMessages", 10 );
 		m_pSteamNetworkingMessages = new CSteamNetworkingMessages( *this );
 		if ( !m_pSteamNetworkingMessages->BInit() )
 		{
@@ -109,7 +109,7 @@ bool CSteamNetworkingMessages::BInit()
 
 void CSteamNetworkingMessages::FreeResources()
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread( "CSteamNetworkingMessages::FreeResources" );
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread( "CSteamNetworkingMessages::FreeResources" );
 
 	// Destroy all of our sessions.  This will detach all of our connections
 	FOR_EACH_HASHMAP( m_mapSessions, i )
@@ -156,7 +156,7 @@ void CSteamNetworkingMessages::FreeResources()
 
 CSteamNetworkingMessages::~CSteamNetworkingMessages()
 {
-	SteamDatagramTransportLock scopeLock;
+	SteamNetworkingGlobalLock scopeLock;
 
 	FreeResources();
 
@@ -175,7 +175,7 @@ CSteamNetworkingMessages::~CSteamNetworkingMessages()
 void CSteamNetworkingMessages::ConnectionStatusChangedCallback( SteamNetConnectionStatusChangedCallback_t *pInfo )
 {
 	// These callbacks should happen synchronously, while we have the lock
-	SteamDatagramTransportLock::AssertHeldByCurrentThread( "CSteamNetworkingMessages::ConnectionStatusChangedCallback" );
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread( "CSteamNetworkingMessages::ConnectionStatusChangedCallback" );
 
 	// New connection?
 	if ( pInfo->m_eOldState == k_ESteamNetworkingConnectionState_None )
@@ -235,7 +235,7 @@ EResult CSteamNetworkingMessages::SendMessageToUser( const SteamNetworkingIdenti
 		return k_EResultInvalidSteamID;
 	}
 
-	SteamDatagramTransportLock scopeLock( "SendMessageToUser" );
+	SteamNetworkingGlobalLock scopeLock( "SendMessageToUser" );
 	SteamNetworkingMessagesSession *pSess = FindOrCreateSession( identityRemote );
 	SteamNetworkingMicroseconds usecNow = SteamNetworkingSockets_GetLocalTimestamp();
 
@@ -324,7 +324,7 @@ EResult CSteamNetworkingMessages::SendMessageToUser( const SteamNetworkingIdenti
 
 int CSteamNetworkingMessages::ReceiveMessagesOnChannel( int nLocalChannel, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages )
 {
-	SteamDatagramTransportLock scopeLock( "ReceiveMessagesOnChannel" );
+	SteamNetworkingGlobalLock scopeLock( "ReceiveMessagesOnChannel" );
 
 	// Pull out all messages from the poll group into per-channel queues
 	if ( m_pPollGroup )
@@ -356,7 +356,7 @@ int CSteamNetworkingMessages::ReceiveMessagesOnChannel( int nLocalChannel, Steam
 
 bool CSteamNetworkingMessages::AcceptSessionWithUser( const SteamNetworkingIdentity &identityRemote )
 {
-	SteamDatagramTransportLock scopeLock( "AcceptSessionWithUser" );
+	SteamNetworkingGlobalLock scopeLock( "AcceptSessionWithUser" );
 	SteamNetworkingMessagesSession *pSession = FindSession( identityRemote );
 	if ( !pSession )
 		return false;
@@ -375,7 +375,7 @@ bool CSteamNetworkingMessages::AcceptSessionWithUser( const SteamNetworkingIdent
 
 bool CSteamNetworkingMessages::CloseSessionWithUser( const SteamNetworkingIdentity &identityRemote )
 {
-	SteamDatagramTransportLock scopeLock( "CloseSessionWithUser" );
+	SteamNetworkingGlobalLock scopeLock( "CloseSessionWithUser" );
 	SteamNetworkingMessagesSession *pSession = FindSession( identityRemote );
 	if ( !pSession )
 		return false;
@@ -388,7 +388,7 @@ bool CSteamNetworkingMessages::CloseSessionWithUser( const SteamNetworkingIdenti
 
 bool CSteamNetworkingMessages::CloseChannelWithUser( const SteamNetworkingIdentity &identityRemote, int nChannel )
 {
-	SteamDatagramTransportLock scopeLock( "CloseChannelWithUser" );
+	SteamNetworkingGlobalLock scopeLock( "CloseChannelWithUser" );
 	SteamNetworkingMessagesSession *pSession = FindSession( identityRemote );
 	if ( !pSession )
 		return false;
@@ -427,7 +427,7 @@ bool CSteamNetworkingMessages::CloseChannelWithUser( const SteamNetworkingIdenti
 
 ESteamNetworkingConnectionState CSteamNetworkingMessages::GetSessionConnectionInfo( const SteamNetworkingIdentity &identityRemote, SteamNetConnectionInfo_t *pConnectionInfo, SteamNetworkingQuickConnectionStatus *pQuickStatus )
 {
-	SteamDatagramTransportLock scopeLock( "GetSessionConnectionInfo" );
+	SteamNetworkingGlobalLock scopeLock( "GetSessionConnectionInfo" );
 	if ( pConnectionInfo )
 		memset( pConnectionInfo, 0, sizeof(*pConnectionInfo) );
 	if ( pQuickStatus )
@@ -449,7 +449,7 @@ ESteamNetworkingConnectionState CSteamNetworkingMessages::GetSessionConnectionIn
 
 SteamNetworkingMessagesSession *CSteamNetworkingMessages::FindSession( const SteamNetworkingIdentity &identityRemote )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 	int h = m_mapSessions.Find( identityRemote );
 	if ( h == m_mapSessions.InvalidIndex() )
 		return nullptr;
@@ -483,7 +483,7 @@ CSteamNetworkingMessages::Channel *CSteamNetworkingMessages::FindOrCreateChannel
 
 void CSteamNetworkingMessages::DestroySession( const SteamNetworkingIdentity &identityRemote )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread( "CSteamNetworkingMessages::DestroySession" );
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread( "CSteamNetworkingMessages::DestroySession" );
 	int h = m_mapSessions.Find( identityRemote );
 	if ( h == m_mapSessions.InvalidIndex() )
 		return;

src/steamnetworkingsockets/clientlib/csteamnetworkingsockets.cpp

@@ -126,7 +126,7 @@ static void EnsureConfigValueTableInitted()
 {
 	if ( s_bConfigValueTableInitted )
 		return;
-	SteamDatagramTransportLock scopeLock;
+	SteamNetworkingGlobalLock scopeLock;
 	if ( s_bConfigValueTableInitted )
 		return;
 
@@ -330,7 +330,7 @@ CSteamNetworkingSockets::CSteamNetworkingSockets( CSteamNetworkingUtils *pSteamN
 
 CSteamNetworkingSockets::~CSteamNetworkingSockets()
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 	Assert( !m_bHaveLowLevelRef ); // Called destructor directly?  Use Destroy()!
 }
 
@@ -369,7 +369,7 @@ bool CSteamNetworkingSockets::BInitLowLevel( SteamNetworkingErrMsg &errMsg )
 
 void CSteamNetworkingSockets::KillConnections()
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread( "CSteamNetworkingSockets::KillConnections" );
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread( "CSteamNetworkingSockets::KillConnections" );
 
 	// Warn messages interface that it needs to clean up.  We need to do this
 	// because that class has pointers to objects that we are about to destroy.
@@ -415,7 +415,7 @@ void CSteamNetworkingSockets::KillConnections()
 
 void CSteamNetworkingSockets::Destroy()
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread( "CSteamNetworkingSockets::Destroy" );
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread( "CSteamNetworkingSockets::Destroy" );
 
 	FreeResources();
 
@@ -477,7 +477,7 @@ bool CSteamNetworkingSockets::BHasAnyListenSockets() const
 
 bool CSteamNetworkingSockets::GetIdentity( SteamNetworkingIdentity *pIdentity )
 {
-	SteamDatagramTransportLock scopeLock( "GetIdentity" );
+	SteamNetworkingGlobalLock scopeLock( "GetIdentity" );
 	InternalGetIdentity();
 	if ( pIdentity )
 		*pIdentity = m_identity;
@@ -499,7 +499,7 @@ int CSteamNetworkingSockets::GetSecondsUntilCertExpiry() const
 
 bool CSteamNetworkingSockets::GetCertificateRequest( int *pcbBlob, void *pBlob, SteamNetworkingErrMsg &errMsg )
 {
-	SteamDatagramTransportLock scopeLock( "GetCertificateRequest" );
+	SteamNetworkingGlobalLock scopeLock( "GetCertificateRequest" );
 
 	// If we don't have a private key, generate one now.
 	CECSigningPublicKey pubKey;
@@ -557,7 +557,7 @@ bool CSteamNetworkingSockets::SetCertificate( const void *pCertificate, int cbCe
 		return false;
 	}
 
-	SteamDatagramTransportLock scopeLock( "SetCertificate" );
+	SteamNetworkingGlobalLock scopeLock( "SetCertificate" );
 
 	// Crack the cert, and check the signature.  If *we* aren't even willing
 	// to trust it, assume that our peers won't either
@@ -670,7 +670,7 @@ bool CSteamNetworkingSockets::SetCertificate( const void *pCertificate, int cbCe
 
 ESteamNetworkingAvailability CSteamNetworkingSockets::InitAuthentication()
 {
-	SteamDatagramTransportLock scopeLock( "InitAuthentication" );
+	SteamNetworkingGlobalLock scopeLock( "InitAuthentication" );
 
 	// Check/fetch prerequisites
 	AuthenticationNeeded();
@@ -854,7 +854,7 @@ void CSteamNetworkingSockets::CertRequestFailed( ESteamNetworkingAvailability eC
 
 ESteamNetworkingAvailability CSteamNetworkingSockets::GetAuthenticationStatus( SteamNetAuthenticationStatus_t *pDetails )
 {
-	SteamDatagramTransportLock scopeLock;
+	SteamNetworkingGlobalLock scopeLock;
 
 	// Return details, if requested
 	if ( pDetails )
@@ -866,7 +866,7 @@ ESteamNetworkingAvailability CSteamNetworkingSockets::GetAuthenticationStatus( S
 
 HSteamListenSocket CSteamNetworkingSockets::CreateListenSocketIP( const SteamNetworkingIPAddr &localAddr, int nOptions, const SteamNetworkingConfigValue_t *pOptions )
 {
-	SteamDatagramTransportLock scopeLock( "CreateListenSocketIP" );
+	SteamNetworkingGlobalLock scopeLock( "CreateListenSocketIP" );
 	SteamDatagramErrMsg errMsg;
 
 	CSteamNetworkListenSocketDirectUDP *pSock = new CSteamNetworkListenSocketDirectUDP( this );
@@ -884,7 +884,7 @@ HSteamListenSocket CSteamNetworkingSockets::CreateListenSocketIP( const SteamNet
 
 HSteamNetConnection CSteamNetworkingSockets::ConnectByIPAddress( const SteamNetworkingIPAddr &address, int nOptions, const SteamNetworkingConfigValue_t *pOptions )
 {
-	SteamDatagramTransportLock scopeLock( "ConnectByIPAddress" );
+	SteamNetworkingGlobalLock scopeLock( "ConnectByIPAddress" );
 	CSteamNetworkConnectionUDP *pConn = new CSteamNetworkConnectionUDP( this );
 	if ( !pConn )
 		return k_HSteamNetConnection_Invalid;
@@ -902,7 +902,7 @@ HSteamNetConnection CSteamNetworkingSockets::ConnectByIPAddress( const SteamNetw
 
 EResult CSteamNetworkingSockets::AcceptConnection( HSteamNetConnection hConn )
 {
-	SteamDatagramTransportLock scopeLock( "AcceptConnection" );
+	SteamNetworkingGlobalLock scopeLock( "AcceptConnection" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hConn );
 	if ( !pConn )
 	{
@@ -916,7 +916,7 @@ EResult CSteamNetworkingSockets::AcceptConnection( HSteamNetConnection hConn )
 
 bool CSteamNetworkingSockets::CloseConnection( HSteamNetConnection hConn, int nReason, const char *pszDebug, bool bEnableLinger )
 {
-	SteamDatagramTransportLock scopeLock( "CloseConnection" );
+	SteamNetworkingGlobalLock scopeLock( "CloseConnection" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hConn );
 	if ( !pConn )
 		return false;
@@ -928,7 +928,7 @@ bool CSteamNetworkingSockets::CloseConnection( HSteamNetConnection hConn, int nR
 
 bool CSteamNetworkingSockets::CloseListenSocket( HSteamListenSocket hSocket )
 {
-	SteamDatagramTransportLock scopeLock( "CloseListenSocket" );
+	SteamNetworkingGlobalLock scopeLock( "CloseListenSocket" );
 	CSteamNetworkListenSocketBase *pSock = GetListenSocketByHandle( hSocket );
 	if ( !pSock )
 		return false;
@@ -941,7 +941,7 @@ bool CSteamNetworkingSockets::CloseListenSocket( HSteamListenSocket hSocket )
 
 bool CSteamNetworkingSockets::SetConnectionUserData( HSteamNetConnection hPeer, int64 nUserData )
 {
-	SteamDatagramTransportLock scopeLock( "SetConnectionUserData" );
+	SteamNetworkingGlobalLock scopeLock( "SetConnectionUserData" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hPeer );
 	if ( !pConn )
 		return false;
@@ -951,7 +951,7 @@ bool CSteamNetworkingSockets::SetConnectionUserData( HSteamNetConnection hPeer,
 
 int64 CSteamNetworkingSockets::GetConnectionUserData( HSteamNetConnection hPeer )
 {
-	SteamDatagramTransportLock scopeLock( "GetConnectionUserData" );
+	SteamNetworkingGlobalLock scopeLock( "GetConnectionUserData" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hPeer );
 	if ( !pConn )
 		return -1;
@@ -960,7 +960,7 @@ int64 CSteamNetworkingSockets::GetConnectionUserData( HSteamNetConnection hPeer
 
 void CSteamNetworkingSockets::SetConnectionName( HSteamNetConnection hPeer, const char *pszName )
 {
-	SteamDatagramTransportLock scopeLock( "SetConnectionName" );
+	SteamNetworkingGlobalLock scopeLock( "SetConnectionName" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hPeer );
 	if ( !pConn )
 		return;
@@ -969,7 +969,7 @@ void CSteamNetworkingSockets::SetConnectionName( HSteamNetConnection hPeer, cons
 
 bool CSteamNetworkingSockets::GetConnectionName( HSteamNetConnection hPeer, char *pszName, int nMaxLen )
 {
-	SteamDatagramTransportLock scopeLock( "GetConnectionName" );
+	SteamNetworkingGlobalLock scopeLock( "GetConnectionName" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hPeer );
 	if ( !pConn )
 		return false;
@@ -979,7 +979,7 @@ bool CSteamNetworkingSockets::GetConnectionName( HSteamNetConnection hPeer, char
 
 EResult CSteamNetworkingSockets::SendMessageToConnection( HSteamNetConnection hConn, const void *pData, uint32 cbData, int nSendFlags, int64 *pOutMessageNumber )
 {
-	SteamDatagramTransportLock scopeLock( "SendMessageToConnection" );
+	SteamNetworkingGlobalLock scopeLock( "SendMessageToConnection" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hConn );
 	if ( !pConn )
 		return k_EResultInvalidParam;
@@ -988,7 +988,7 @@ EResult CSteamNetworkingSockets::SendMessageToConnection( HSteamNetConnection hC
 
 void CSteamNetworkingSockets::SendMessages( int nMessages, SteamNetworkingMessage_t *const *pMessages, int64 *pOutMessageNumberOrResult )
 {
-	SteamDatagramTransportLock scopeLock( "SendMessages" );
+	SteamNetworkingGlobalLock scopeLock( "SendMessages" );
 	SteamNetworkingMicroseconds usecNow = SteamNetworkingSockets_GetLocalTimestamp();
 
 	vstd::small_vector<CSteamNetworkConnectionBase *,64 > vecConnectionsToCheck;
@@ -1035,7 +1035,7 @@ void CSteamNetworkingSockets::SendMessages( int nMessages, SteamNetworkingMessag
 
 EResult CSteamNetworkingSockets::FlushMessagesOnConnection( HSteamNetConnection hConn )
 {
-	SteamDatagramTransportLock scopeLock( "FlushMessagesOnConnection" );
+	SteamNetworkingGlobalLock scopeLock( "FlushMessagesOnConnection" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hConn );
 	if ( !pConn )
 		return k_EResultInvalidParam;
@@ -1044,7 +1044,7 @@ EResult CSteamNetworkingSockets::FlushMessagesOnConnection( HSteamNetConnection
 
 int CSteamNetworkingSockets::ReceiveMessagesOnConnection( HSteamNetConnection hConn, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages )
 {
-	SteamDatagramTransportLock scopeLock( "ReceiveMessagesOnConnection" );
+	SteamNetworkingGlobalLock scopeLock( "ReceiveMessagesOnConnection" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hConn );
 	if ( !pConn )
 		return -1;
@@ -1053,7 +1053,7 @@ int CSteamNetworkingSockets::ReceiveMessagesOnConnection( HSteamNetConnection hC
 
 HSteamNetPollGroup CSteamNetworkingSockets::CreatePollGroup()
 {
-	SteamDatagramTransportLock scopeLock( "CreatePollGroup" );
+	SteamNetworkingGlobalLock scopeLock( "CreatePollGroup" );
 	CSteamNetworkPollGroup *pPollGroup = new CSteamNetworkPollGroup( this );
 	pPollGroup->AssignHandleAndAddToGlobalTable();
 	return pPollGroup->m_hPollGroupSelf;
@@ -1061,7 +1061,7 @@ HSteamNetPollGroup CSteamNetworkingSockets::CreatePollGroup()
 
 bool CSteamNetworkingSockets::DestroyPollGroup( HSteamNetPollGroup hPollGroup )
 {
-	SteamDatagramTransportLock scopeLock( "DestroyPollGroup" );
+	SteamNetworkingGlobalLock scopeLock( "DestroyPollGroup" );
 	CSteamNetworkPollGroup *pPollGroup = GetPollGroupByHandle( hPollGroup );
 	if ( !pPollGroup )
 		return false;
@@ -1071,7 +1071,7 @@ bool CSteamNetworkingSockets::DestroyPollGroup( HSteamNetPollGroup hPollGroup )
 
 bool CSteamNetworkingSockets::SetConnectionPollGroup( HSteamNetConnection hConn, HSteamNetPollGroup hPollGroup )
 {
-	SteamDatagramTransportLock scopeLock( "SetConnectionPollGroup" );
+	SteamNetworkingGlobalLock scopeLock( "SetConnectionPollGroup" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hConn );
 	if ( !pConn )
 		return false;
@@ -1095,7 +1095,7 @@ bool CSteamNetworkingSockets::SetConnectionPollGroup( HSteamNetConnection hConn,
 
 int CSteamNetworkingSockets::ReceiveMessagesOnPollGroup( HSteamNetPollGroup hPollGroup, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages )
 {
-	SteamDatagramTransportLock scopeLock( "ReceiveMessagesOnPollGroup" );
+	SteamNetworkingGlobalLock scopeLock( "ReceiveMessagesOnPollGroup" );
 	CSteamNetworkPollGroup *pPollGroup = GetPollGroupByHandle( hPollGroup );
 	if ( !pPollGroup )
 		return -1;
@@ -1105,7 +1105,7 @@ int CSteamNetworkingSockets::ReceiveMessagesOnPollGroup( HSteamNetPollGroup hPol
 #ifdef STEAMNETWORKINGSOCKETS_STEAMCLIENT
 int CSteamNetworkingSockets::ReceiveMessagesOnListenSocketLegacyPollGroup( HSteamListenSocket hSocket, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages )
 {
-	SteamDatagramTransportLock scopeLock( "ReceiveMessagesOnListenSocket" );
+	SteamNetworkingGlobalLock scopeLock( "ReceiveMessagesOnListenSocket" );
 	CSteamNetworkListenSocketBase *pSock = GetListenSocketByHandle( hSocket );
 	if ( !pSock )
 		return -1;
@@ -1115,7 +1115,7 @@ int CSteamNetworkingSockets::ReceiveMessagesOnListenSocketLegacyPollGroup( HStea
 
 bool CSteamNetworkingSockets::GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo_t *pInfo )
 {
-	SteamDatagramTransportLock scopeLock( "GetConnectionInfo" );
+	SteamNetworkingGlobalLock scopeLock( "GetConnectionInfo" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hConn );
 	if ( !pConn )
 		return false;
@@ -1126,7 +1126,7 @@ bool CSteamNetworkingSockets::GetConnectionInfo( HSteamNetConnection hConn, Stea
 
 bool CSteamNetworkingSockets::GetQuickConnectionStatus( HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus *pStats )
 {
-	SteamDatagramTransportLock scopeLock( "GetQuickConnectionStatus" );
+	SteamNetworkingGlobalLock scopeLock( "GetQuickConnectionStatus" );
 	CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hConn );
 	if ( !pConn )
 		return false;
@@ -1141,7 +1141,7 @@ int CSteamNetworkingSockets::GetDetailedConnectionStatus( HSteamNetConnection hC
 
 	// Only hold the lock for as long as we need.
 	{
-		SteamDatagramTransportLock scopeLock( "GetDetailedConnectionStatus" );
+		SteamNetworkingGlobalLock scopeLock( "GetDetailedConnectionStatus" );
 		CSteamNetworkConnectionBase *pConn = GetConnectionByHandleForAPI( hConn );
 		if ( !pConn )
 			return -1;
@@ -1160,7 +1160,7 @@ int CSteamNetworkingSockets::GetDetailedConnectionStatus( HSteamNetConnection hC
 
 bool CSteamNetworkingSockets::GetListenSocketAddress( HSteamListenSocket hSocket, SteamNetworkingIPAddr *pAddress )
 {
-	SteamDatagramTransportLock scopeLock( "GetListenSocketAddress" );
+	SteamNetworkingGlobalLock scopeLock( "GetListenSocketAddress" );
 	CSteamNetworkListenSocketBase *pSock = GetListenSocketByHandle( hSocket );
 	if ( !pSock )
 		return false;
@@ -1169,7 +1169,7 @@ bool CSteamNetworkingSockets::GetListenSocketAddress( HSteamListenSocket hSocket
 
 bool CSteamNetworkingSockets::CreateSocketPair( HSteamNetConnection *pOutConnection1, HSteamNetConnection *pOutConnection2, bool bUseNetworkLoopback, const SteamNetworkingIdentity *pIdentity1, const SteamNetworkingIdentity *pIdentity2 )
 {
-	SteamDatagramTransportLock scopeLock( "CreateSocketPair" );
+	SteamNetworkingGlobalLock scopeLock( "CreateSocketPair" );
 
 	// Assume failure
 	*pOutConnection1 = k_HSteamNetConnection_Invalid;
@@ -1221,7 +1221,7 @@ bool CSteamNetworkingSockets::BCertHasIdentity() const
 
 bool CSteamNetworkingSockets::SetCertificateAndPrivateKey( const void *pCert, int cbCert, void *pPrivateKey, int cbPrivateKey )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread( "SetCertificateAndPrivateKey" );
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread( "SetCertificateAndPrivateKey" );
 
 	m_msgCert.Clear();
 	m_msgSignedCert.Clear();
@@ -1338,7 +1338,7 @@ void CSteamNetworkingSockets::RunCallbacks()
 
 void CSteamNetworkingSockets::InternalQueueCallback( int nCallback, int cbCallback, const void *pvCallback, void *fnRegisteredFunctionPtr )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	if ( !fnRegisteredFunctionPtr )
 		return;
@@ -1734,7 +1734,7 @@ bool CSteamNetworkingUtils::SetConfigValue( ESteamNetworkingConfigValue eValue,
 	if ( pEntry == nullptr )
 		return false;
 
-	SteamDatagramTransportLock scopeLock( "SetConfigValue" );
+	SteamNetworkingGlobalLock scopeLock( "SetConfigValue" );
 
 	switch ( pEntry->m_eDataType )
 	{
@@ -1777,7 +1777,7 @@ ESteamNetworkingGetConfigValueResult CSteamNetworkingUtils::GetConfigValue(
 	if ( pOutDataType )
 		*pOutDataType = pEntry->m_eDataType;
 
-	SteamDatagramTransportLock scopeLock( "GetConfigValue" );
+	SteamNetworkingGlobalLock scopeLock( "GetConfigValue" );
 
 	switch ( pEntry->m_eDataType )
 	{
@@ -1974,7 +1974,7 @@ static CSteamNetworkingSockets *s_pSteamNetworkingSockets = nullptr;
 
 STEAMNETWORKINGSOCKETS_INTERFACE bool GameNetworkingSockets_Init( const SteamNetworkingIdentity *pIdentity, SteamNetworkingErrMsg &errMsg )
 {
-	SteamDatagramTransportLock lock( "GameNetworkingSockets_Init" );
+	SteamNetworkingGlobalLock lock( "GameNetworkingSockets_Init" );
 
 	// Already initted?
 	if ( s_pSteamNetworkingSockets )
@@ -1997,7 +1997,7 @@ STEAMNETWORKINGSOCKETS_INTERFACE bool GameNetworkingSockets_Init( const SteamNet
 
 STEAMNETWORKINGSOCKETS_INTERFACE void GameNetworkingSockets_Kill()
 {
-	SteamDatagramTransportLock lock( "GameNetworkingSockets_Kill" );
+	SteamNetworkingGlobalLock lock( "GameNetworkingSockets_Kill" );
 	if ( s_pSteamNetworkingSockets )
 	{
 		s_pSteamNetworkingSockets->Destroy();

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_connections.cpp

@@ -1272,7 +1272,7 @@ void CSteamNetworkConnectionBase::CertRequestFailed( ESteamNetConnectionEnd nCon
 
 bool CSteamNetworkConnectionBase::BRecvCryptoHandshake( const CMsgSteamDatagramCertificateSigned &msgCert, const CMsgSteamDatagramSessionCryptInfoSigned &msgSessionInfo, bool bServer )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread( "BRecvCryptoHandshake" );
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread( "BRecvCryptoHandshake" );
 	SteamNetworkingErrMsg errMsg;
 
 	// Have we already done key exchange?

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_lowlevel.cpp

@@ -62,7 +62,7 @@ int g_nSteamDatagramSocketBufferSize = 256*1024;
 #else
 	static std::recursive_timed_mutex s_steamDatagramTransportMutex;
 #endif
-int SteamDatagramTransportLock::s_nLocked;
+int SteamNetworkingGlobalLock::s_nLocked;
 static SteamNetworkingMicroseconds s_usecWhenLocked;
 static std::thread::id s_threadIDLockOwner;
 static SteamNetworkingMicroseconds s_usecLongLockWarningThreshold;
@@ -75,7 +75,7 @@ static void (*s_fLockAcquiredCallback)( const char *tags, SteamNetworkingMicrose
 static void (*s_fLockHeldCallback)( const char *tags, SteamNetworkingMicroseconds usecWaited );
 static SteamNetworkingMicroseconds s_usecLockWaitWarningThreshold = 2*1000;
 
-void SteamDatagramTransportLock::AddTag( const char *pszTag )
+void SteamNetworkingGlobalLock::AddTag( const char *pszTag )
 {
 	if ( !pszTag || s_nCurrentLockTags >= k_nMaxCurrentLockTags )
 		return;
@@ -94,7 +94,7 @@ void SteamDatagramTransportLock::AddTag( const char *pszTag )
 	++s_nCurrentLockTags;
 }
 
-void SteamDatagramTransportLock::OnLocked( const char *pszTag, SteamNetworkingMicroseconds usecTimeStartedLocking )
+void SteamNetworkingGlobalLock::OnLocked( const char *pszTag, SteamNetworkingMicroseconds usecTimeStartedLocking )
 {
 	++s_nLocked;
 	SteamNetworkingMicroseconds usecNow = SteamNetworkingSockets_GetLocalTimestamp();
@@ -131,7 +131,7 @@ void SteamDatagramTransportLock::OnLocked( const char *pszTag, SteamNetworkingMi
 	AddTag( pszTag );
 }
 
-void SteamDatagramTransportLock::Lock( const char *pszTag )
+void SteamNetworkingGlobalLock::Lock( const char *pszTag )
 {
 	SteamNetworkingMicroseconds usecTimeStartedLocking;
 	#ifdef MSVC_STL_MUTEX_WORKAROUND
@@ -147,7 +147,7 @@ void SteamDatagramTransportLock::Lock( const char *pszTag )
 	OnLocked( pszTag, usecTimeStartedLocking );
 }
 
-bool SteamDatagramTransportLock::TryLock( const char *pszTag, int msTimeout )
+bool SteamNetworkingGlobalLock::TryLock( const char *pszTag, int msTimeout )
 {
 	SteamNetworkingMicroseconds usecTimeStartedLocking = SteamNetworkingSockets_GetLocalTimestamp();
 	#ifdef MSVC_STL_MUTEX_WORKAROUND
@@ -161,7 +161,7 @@ bool SteamDatagramTransportLock::TryLock( const char *pszTag, int msTimeout )
 	return true;
 }
 
-void SteamDatagramTransportLock::Unlock()
+void SteamNetworkingGlobalLock::Unlock()
 {
 	char tags[ 256 ];
 
@@ -232,7 +232,7 @@ void SteamDatagramTransportLock::Unlock()
 	}
 }
 
-void SteamDatagramTransportLock::SetLongLockWarningThresholdMS( const char *pszTag, int msWarningThreshold )
+void SteamNetworkingGlobalLock::SetLongLockWarningThresholdMS( const char *pszTag, int msWarningThreshold )
 {
 	AssertHeldByCurrentThread( pszTag );
 	SteamNetworkingMicroseconds usecWarningThreshold = SteamNetworkingMicroseconds{msWarningThreshold}*1000;
@@ -243,13 +243,13 @@ void SteamDatagramTransportLock::SetLongLockWarningThresholdMS( const char *pszT
 	}
 }
 
-void SteamDatagramTransportLock::AssertHeldByCurrentThread()
+void SteamNetworkingGlobalLock::AssertHeldByCurrentThread()
 {
 	Assert( s_nLocked > 0 ); // NOTE: This could succeed even if another thread has the lock
 	Assert( s_threadIDLockOwner == std::this_thread::get_id() );
 }
 
-void SteamDatagramTransportLock::AssertHeldByCurrentThread( const char *pszTag )
+void SteamNetworkingGlobalLock::AssertHeldByCurrentThread( const char *pszTag )
 {
 	Assert( s_nLocked > 0 ); // NOTE: This could succeed even if another thread has the lock
 	if ( s_threadIDLockOwner == std::this_thread::get_id() )
@@ -303,7 +303,7 @@ ISteamNetworkingSocketsRunWithLock::~ISteamNetworkingSocketsRunWithLock() {}
 bool ISteamNetworkingSocketsRunWithLock::RunOrQueue( const char *pszTag )
 {
 	// Check if lock is available immediately
-	if ( !SteamDatagramTransportLock::TryLock( pszTag, 0 ) )
+	if ( !SteamNetworkingGlobalLock::TryLock( pszTag, 0 ) )
 	{
 		Queue( pszTag );
 		return false;
@@ -316,7 +316,7 @@ bool ISteamNetworkingSocketsRunWithLock::RunOrQueue( const char *pszTag )
 	Run();
 
 	// Go ahead and unlock now
-	SteamDatagramTransportLock::Unlock();
+	SteamNetworkingGlobalLock::Unlock();
 
 	// Self destruct
 	delete this;
@@ -365,7 +365,7 @@ void ISteamNetworkingSocketsRunWithLock::ServiceQueue()
 	for ( ISteamNetworkingSocketsRunWithLock *pItem: vecTempQueue )
 	{
 		// Make sure we hold the lock, and also set the tag for debugging purposes
-		SteamDatagramTransportLock::AssertHeldByCurrentThread( pItem->m_pszTag );
+		SteamNetworkingGlobalLock::AssertHeldByCurrentThread( pItem->m_pszTag );
 
 		// Do the work and nuke
 		pItem->Run();
@@ -540,7 +540,7 @@ public:
 
 		// Add a tag.  If we end up holding the lock for a long time, this tag
 		// will tell us how many packets were sent
-		SteamDatagramTransportLock::AddTag( "SendUDPacket" );
+		SteamNetworkingGlobalLock::AddTag( "SendUDPacket" );
 
 		// Convert address to BSD interface
 		struct sockaddr_storage destAddress;
@@ -637,7 +637,7 @@ public:
 
 	void LagPacket( bool bSend, const CRawUDPSocketImpl *pSock, const netadr_t &adr, int msDelay, int nChunks, const iovec *pChunks )
 	{
-		SteamDatagramTransportLock::AssertHeldByCurrentThread( "LagPacket" );
+		SteamNetworkingGlobalLock::AssertHeldByCurrentThread( "LagPacket" );
 
 		int cbPkt = 0;
 		for ( int i = 0 ; i < nChunks ; ++i )
@@ -835,7 +835,7 @@ bool IRawUDPSocket::BSendRawPacket( const void *pPkt, int cbPkt, const netadr_t
 
 bool IRawUDPSocket::BSendRawPacketGather( int nChunks, const iovec *pChunks, const netadr_t &adrTo ) const
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	// Silently ignore a request to send a packet anytime we're in the process of shutting down the system
 	if ( s_nLowLevelSupportRefCount.load(std::memory_order_acquire) <= 0 )
@@ -877,7 +877,7 @@ bool IRawUDPSocket::BSendRawPacketGather( int nChunks, const iovec *pChunks, con
 
 void IRawUDPSocket::Close()
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread( "IRawUDPSocket::Close" );
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread( "IRawUDPSocket::Close" );
 	CRawUDPSocketImpl *self = static_cast<CRawUDPSocketImpl *>( this );
 
 	/// Clear the callback, to ensure that no further callbacks will be executed.
@@ -1008,7 +1008,7 @@ static CRawUDPSocketImpl *OpenRawUDPSocketInternal( CRecvPacketCallback callback
 {
 	// Creating a socket *should* be fast, but sometimes the OS might need to do some work.
 	// We shouldn't do this too often, give it a little extra time.
-	SteamDatagramTransportLock::SetLongLockWarningThresholdMS( "OpenRawUDPSocketInternal", 100 );
+	SteamNetworkingGlobalLock::SetLongLockWarningThresholdMS( "OpenRawUDPSocketInternal", 100 );
 
 	// Make sure have been initialized
 	if ( s_nLowLevelSupportRefCount.load(std::memory_order_acquire) <= 0 )
@@ -1185,8 +1185,8 @@ static bool PollRawUDPSockets( int nMaxTimeoutMS, bool bManualPoll )
 {
 	// This should only ever be called from our one thread proc,
 	// and we assume that it will have locked the lock exactly once.
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
-	Assert( SteamDatagramTransportLock::s_nLocked == 1 );
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
+	Assert( SteamNetworkingGlobalLock::s_nLocked == 1 );
 
 	const int nSocketsToPoll = s_vecRawSockets.Count();
 
@@ -1238,7 +1238,7 @@ static bool PollRawUDPSockets( int nMaxTimeoutMS, bool bManualPoll )
 	#endif
 
 	// Release lock while we're asleep
-	SteamDatagramTransportLock::Unlock();
+	SteamNetworkingGlobalLock::Unlock();
 
 	// Shutdown request?
 	if ( s_nLowLevelSupportRefCount.load(std::memory_order_acquire) <= 0 || s_bManualPollMode != bManualPoll )
@@ -1263,7 +1263,7 @@ static bool PollRawUDPSockets( int nMaxTimeoutMS, bool bManualPoll )
 
 		// Try to acquire the lock.  But don't wait forever, in case the other thread has the lock
 		// and then makes a shutdown request while we're waiting on the lock here.
-		if ( SteamDatagramTransportLock::TryLock( "ServiceThread", 250 ) )
+		if ( SteamNetworkingGlobalLock::TryLock( "ServiceThread", 250 ) )
 			break;
 
 		// The only time this really should happen is a relatively rare race condition
@@ -1368,7 +1368,7 @@ static bool PollRawUDPSockets( int nMaxTimeoutMS, bool bManualPoll )
 
 			// Add a tag.  If we end up holding the lock for a long time, this tag
 			// will tell us how many packets were processed
-			SteamDatagramTransportLock::AddTag( "RecvUDPPacket" );
+			SteamNetworkingGlobalLock::AddTag( "RecvUDPPacket" );
 
 			// Check for simulating random packet loss
 			if ( RandomBoolWithOdds( g_Config_FakePacketLoss_Recv.Get() ) )
@@ -1440,7 +1440,7 @@ static bool PollRawUDPSockets( int nMaxTimeoutMS, bool bManualPoll )
 
 void ProcessPendingDestroyClosedRawUDPSockets()
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	for ( CRawUDPSocketImpl *pSock: s_vecRawSocketsPendingDeletion )
 	{
@@ -1465,8 +1465,8 @@ void ProcessPendingDestroyClosedRawUDPSockets()
 //
 static bool SteamNetworkingSockets_InternalPoll( int msWait, bool bManualPoll )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread(); // We should own the lock
-	Assert( SteamDatagramTransportLock::s_nLocked == 1 ); // exactly once
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread(); // We should own the lock
+	Assert( SteamNetworkingGlobalLock::s_nLocked == 1 ); // exactly once
 
 	// Figure out how long to sleep
 	IThinker *pNextThinker = Thinker_GetNextScheduled();
@@ -1520,13 +1520,13 @@ static bool SteamNetworkingSockets_InternalPoll( int msWait, bool bManualPoll )
 		return false;
 	}
 
-	SteamDatagramTransportLock::AssertHeldByCurrentThread(); // We should own the lock
-	Assert( SteamDatagramTransportLock::s_nLocked == 1 ); // exactly once
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread(); // We should own the lock
+	Assert( SteamNetworkingGlobalLock::s_nLocked == 1 ); // exactly once
 
 	// Shutdown request?
 	if ( s_nLowLevelSupportRefCount.load(std::memory_order_acquire) <= 0 || s_bManualPollMode != bManualPoll )
 	{
-		SteamDatagramTransportLock::Unlock();
+		SteamNetworkingGlobalLock::Unlock();
 		return false; // Shutdown request, we have released the lock
 	}
 
@@ -1619,7 +1619,7 @@ static void SteamNetworkingThreadProc()
 	{
 		if ( s_nLowLevelSupportRefCount.load(std::memory_order_acquire) <= 0 || s_bManualPollMode )
 			return;
-	} while ( !SteamDatagramTransportLock::TryLock( "ServiceThread", 10 ) );
+	} while ( !SteamNetworkingGlobalLock::TryLock( "ServiceThread", 10 ) );
 
 	// Random number generator may be per thread!  Make sure and see it for
 	// this thread, if so
@@ -1633,7 +1633,7 @@ static void SteamNetworkingThreadProc()
 		// If they activate manual poll mode, then bail!
 		if ( s_bManualPollMode )
 		{
-			SteamDatagramTransportLock::Unlock();
+			SteamNetworkingGlobalLock::Unlock();
 			break;
 		}
 	}
@@ -1704,7 +1704,7 @@ static void DedicatedBoundSocketCallback( const void *pPkt, int cbPkt, const net
 
 IBoundUDPSocket *OpenUDPSocketBoundToHost( const netadr_t &adrRemote, CRecvPacketCallback callback, SteamDatagramErrMsg &errMsg )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	// Select local address to use.
 	// Since we know the remote host, let's just always use a single-stack socket
@@ -1727,7 +1727,7 @@ IBoundUDPSocket *OpenUDPSocketBoundToHost( const netadr_t &adrRemote, CRecvPacke
 
 bool CreateBoundSocketPair( CRecvPacketCallback callback1, CRecvPacketCallback callback2, IBoundUDPSocket **ppOutSockets, SteamDatagramErrMsg &errMsg )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	SteamNetworkingIPAddr localAddr;
 
@@ -1783,7 +1783,7 @@ void CSharedSocket::CallbackRecvPacket( const void *pPkt, int cbPkt, const netad
 
 bool CSharedSocket::BInit( const SteamNetworkingIPAddr &localAddr, CRecvPacketCallback callbackDefault, SteamDatagramErrMsg &errMsg )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	Kill();
 
@@ -1798,7 +1798,7 @@ bool CSharedSocket::BInit( const SteamNetworkingIPAddr &localAddr, CRecvPacketCa
 
 void CSharedSocket::Kill()
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	m_callbackDefault.m_fnCallback = nullptr;
 	if ( m_pRawSock )
@@ -1814,7 +1814,7 @@ void CSharedSocket::Kill()
 
 void CSharedSocket::CloseRemoteHostByIndex( int idx )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	delete m_mapRemoteHosts[ idx ];
 	m_mapRemoteHosts[idx] = nullptr; // just for grins
@@ -1823,7 +1823,7 @@ void CSharedSocket::CloseRemoteHostByIndex( int idx )
 
 IBoundUDPSocket *CSharedSocket::AddRemoteHost( const netadr_t &adrRemote, CRecvPacketCallback callback )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	if ( m_mapRemoteHosts.HasElement( adrRemote ) )
 	{
@@ -1840,7 +1840,7 @@ IBoundUDPSocket *CSharedSocket::AddRemoteHost( const netadr_t &adrRemote, CRecvP
 
 void CSharedSocket::RemoteHost::Close()
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	int idx = m_pOwner->m_mapRemoteHosts.Find( m_adr );
 	if ( idx == m_pOwner->m_mapRemoteHosts.InvalidIndex() || m_pOwner->m_mapRemoteHosts[idx] != this )
@@ -1877,7 +1877,7 @@ void ReallySpewTypeFmt( int eType, const char *pMsg, ... )
 
 bool BSteamNetworkingSocketsLowLevelAddRef( SteamDatagramErrMsg &errMsg )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	// Make sure and call time function at least once
 	// just before we start up our thread, so we don't lurch
@@ -1895,7 +1895,7 @@ bool BSteamNetworkingSocketsLowLevelAddRef( SteamDatagramErrMsg &errMsg )
 
 		// Give us a extra time here.  This is a one-time init function and the OS might
 		// need to load up libraries and stuff.
-		SteamDatagramTransportLock::SetLongLockWarningThresholdMS( "BSteamNetworkingSocketsLowLevelAddRef", 500 );
+		SteamNetworkingGlobalLock::SetLongLockWarningThresholdMS( "BSteamNetworkingSocketsLowLevelAddRef", 500 );
 
 		// Initialize COM
 		#ifdef _XBOX_ONE
@@ -1993,7 +1993,7 @@ bool BSteamNetworkingSocketsLowLevelAddRef( SteamDatagramErrMsg &errMsg )
 	{
 		s_bInstalledAtExitHandler = true;
 		atexit( []{
-			SteamDatagramTransportLock scopeLock( "atexit" );
+			SteamNetworkingGlobalLock scopeLock( "atexit" );
 
 			// Static destruction is about to happen.  If we have a thread,
 			// we need to nuke it
@@ -2008,7 +2008,7 @@ bool BSteamNetworkingSocketsLowLevelAddRef( SteamDatagramErrMsg &errMsg )
 
 void SteamNetworkingSocketsLowLevelDecRef()
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	// Last user is now done?
 	int nLastRefCount = s_nLowLevelSupportRefCount.fetch_sub(1, std::memory_order_acq_rel);
@@ -2022,7 +2022,7 @@ void SteamNetworkingSocketsLowLevelDecRef()
 	// There is a potential race condition / deadlock with the service thread,
 	// that might cause us to have to wait for it to timeout.  And the OS
 	// might need to do stuff when we close a bunch of sockets (and WSACleanup)
-	SteamDatagramTransportLock::SetLongLockWarningThresholdMS( "SteamNetworkingSocketsLowLevelDecRef", 500 );
+	SteamNetworkingGlobalLock::SetLongLockWarningThresholdMS( "SteamNetworkingSocketsLowLevelDecRef", 500 );
 
 	if ( s_vecRawSockets.IsEmpty() )
 	{
@@ -2165,7 +2165,7 @@ STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingSockets_SetManualPollMode(
 {
 	if ( s_bManualPollMode == bFlag )
 		return;
-	SteamDatagramTransportLock scopeLock( "SteamNetworkingSockets_SetManualPollMode" );
+	SteamNetworkingGlobalLock scopeLock( "SteamNetworkingSockets_SetManualPollMode" );
 	s_bManualPollMode = bFlag;
 
 	// Check for starting/stopping the thread
@@ -2198,7 +2198,7 @@ STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingSockets_Poll( int msMaxWait
 	}
 	Assert( s_nLowLevelSupportRefCount.load(std::memory_order_acquire) > 0 );
 
-	while ( !SteamDatagramTransportLock::TryLock( "SteamNetworkingSockets_Poll", 1 ) )
+	while ( !SteamNetworkingGlobalLock::TryLock( "SteamNetworkingSockets_Poll", 1 ) )
 	{
 		if ( --msMaxWaitTime <= 0 )
 			return;
@@ -2206,7 +2206,7 @@ STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingSockets_Poll( int msMaxWait
 
 	bool bStillLocked = SteamNetworkingSockets_InternalPoll( msMaxWaitTime, true );
 	if ( bStillLocked )
-		SteamDatagramTransportLock::Unlock();
+		SteamNetworkingGlobalLock::Unlock();
 }
 
 STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingSockets_SetLockWaitWarningThreshold( SteamNetworkingMicroseconds usecTheshold )

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_lowlevel.h

@@ -304,10 +304,10 @@ extern void SteamNetworkingSocketsLowLevelDecRef();
 /// Scope lock object used to synchronize access to internal data structures.  We use a global lock,
 /// even though in some cases it might not be necessary, to simplify the code, since in most cases
 /// there will be very little contention and the should be held only for a short amount of time.
-struct SteamDatagramTransportLock
+struct SteamNetworkingGlobalLock
 {
-	inline SteamDatagramTransportLock( const char *pszTag = nullptr ) { Lock( pszTag ); }
-	inline ~SteamDatagramTransportLock() { Unlock(); }
+	inline SteamNetworkingGlobalLock( const char *pszTag = nullptr ) { Lock( pszTag ); }
+	inline ~SteamNetworkingGlobalLock() { Unlock(); }
 	static void Lock( const char *pszTag );
 	static bool TryLock( const char *pszTag, int msTimeout );
 	static void Unlock();

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_p2p.cpp

@@ -509,7 +509,7 @@ void CSteamNetworkConnectionP2P::CheckInitICE()
 		{
 			SteamNetworkingErrMsg errMsg;
 			tried = true;
-			SteamDatagramTransportLock::SetLongLockWarningThresholdMS( "LoadICEDll", 500 );
+			SteamNetworkingGlobalLock::SetLongLockWarningThresholdMS( "LoadICEDll", 500 );
 			static const char pszExportFunc[] = "CreateWebRTCICESession";
 
 			#if defined( _WINDOWS )
@@ -761,7 +761,7 @@ void CSteamNetworkConnectionP2P::DestroyICENow()
 #ifdef STEAMNETWORKINGSOCKETS_ENABLE_ICE
 void CSteamNetworkConnectionP2P::ICEFailed( int nReasonCode, const char *pszReason )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	// Remember reason code, if we didn't already set one
 	if ( GetICEFailureCode() == 0 )
@@ -2203,7 +2203,7 @@ HSteamListenSocket CSteamNetworkingSockets::CreateListenSocketP2P( int nLocalVir
 		return k_HSteamListenSocket_Invalid;
 	}
 
-	SteamDatagramTransportLock scopeLock( "CreateListenSocketP2P" );
+	SteamNetworkingGlobalLock scopeLock( "CreateListenSocketP2P" );
 
 	CSteamNetworkListenSocketP2P *pSock = InternalCreateListenSocketP2P( nLocalVirtualPort, nOptions, pOptions );
 	if ( pSock )
@@ -2277,7 +2277,7 @@ HSteamNetConnection CSteamNetworkingSockets::ConnectP2P( const SteamNetworkingId
 		return k_HSteamNetConnection_Invalid;
 	}
 
-	SteamDatagramTransportLock scopeLock( "ConnectP2P" );
+	SteamNetworkingGlobalLock scopeLock( "ConnectP2P" );
 	CSteamNetworkConnectionBase *pConn = InternalConnectP2PDefaultSignaling( identityRemote, nRemoteVirtualPort, nOptions, pOptions );
 	if ( pConn )
 		return pConn->m_hConnectionSelf;
@@ -2370,7 +2370,7 @@ HSteamNetConnection CSteamNetworkingSockets::ConnectP2PCustomSignaling( ISteamNe
 	if ( !pSignaling )
 		return k_HSteamNetConnection_Invalid;
 
-	SteamDatagramTransportLock scopeLock( "ConnectP2PCustomSignaling" );
+	SteamNetworkingGlobalLock scopeLock( "ConnectP2PCustomSignaling" );
 	CSteamNetworkConnectionBase *pConn = InternalConnectP2P( pSignaling, pPeerIdentity, nRemoteVirtualPort, nOptions, pOptions );
 	if ( pConn )
 		return pConn->m_hConnectionSelf;
@@ -2551,7 +2551,7 @@ bool CSteamNetworkingSockets::InternalReceivedP2PSignal( const void *pMsg, int c
 	int nLogLevel = m_connectionConfig.m_LogLevel_P2PRendezvous.Get();
 
 	// Grab the lock now.  (We might not have previously held it.)
-	SteamDatagramTransportLock lock( "ReceivedP2PSignal" );
+	SteamNetworkingGlobalLock lock( "ReceivedP2PSignal" );
 
 	SteamNetworkingMicroseconds usecNow = SteamNetworkingSockets_GetLocalTimestamp();
 

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_p2p_ice.cpp

@@ -96,7 +96,7 @@ void CConnectionTransportP2PICE::Init()
 		return;
 	}
 
-	SteamDatagramTransportLock::SetLongLockWarningThresholdMS( "CConnectionTransportP2PICE::Init", 50 );
+	SteamNetworkingGlobalLock::SetLongLockWarningThresholdMS( "CConnectionTransportP2PICE::Init", 50 );
 
 	ICESessionConfig cfg;
 
@@ -717,7 +717,7 @@ void CConnectionTransportP2PICE::OnData( const void *pPkt, size_t nSize )
 
 	// See if we can process this packet (and anything queued before us)
 	// immediately
-	if ( SteamDatagramTransportLock::TryLock( "ICE Data", 0 ) )
+	if ( SteamNetworkingGlobalLock::TryLock( "ICE Data", 0 ) )
 	{
 		// We can process the data now!
 		//SpewMsg( "CConnectionTransportP2PICE::OnData %d bytes, process immediate\n", (int)nSize );
@@ -733,7 +733,7 @@ void CConnectionTransportP2PICE::OnData( const void *pPkt, size_t nSize )
 
 		// And now process this packet
 		ProcessPacket( (const uint8_t*)pPkt, cbPkt, usecNow );
-		SteamDatagramTransportLock::Unlock();
+		SteamNetworkingGlobalLock::Unlock();
 		return;
 	}
 

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_udp.cpp

@@ -1779,7 +1779,7 @@ EUnsignedCert CSteamNetworkConnectionlocalhostLoopback::AllowLocalUnsignedCert()
 
 bool CSteamNetworkConnectionlocalhostLoopback::APICreateSocketPair( CSteamNetworkingSockets *pSteamNetworkingSocketsInterface, CSteamNetworkConnectionlocalhostLoopback *pConn[2], const SteamNetworkingIdentity pIdentity[2] )
 {
-	SteamDatagramTransportLock::AssertHeldByCurrentThread();
+	SteamNetworkingGlobalLock::AssertHeldByCurrentThread();
 
 	SteamDatagramErrMsg errMsg;
 

tests/test_common.cpp

@@ -40,7 +40,7 @@ static void DebugOutput( ESteamNetworkingSocketsDebugOutputType eType, const cha
 		// is occasionally triggering this assert.  Just ignroe that one
 		// error for now.
 		// Yes, this is a kludge.
-		if ( strstr( pszMsg, "SteamDatagramTransportLock held for" ) )
+		if ( strstr( pszMsg, "SteamNetworkingGlobalLock held for" ) )
 			return;
 
 		assert( !"TEST FAILED" );