Replace ESteamNetTransportKind with flags

(At least in the public interface.)

P4:6571004,6571013

Author: zpostfacto

include/steam/steamnetworkingtypes.h

@@ -622,21 +622,6 @@ enum ESteamNetConnectionEnd
 	k_ESteamNetConnectionEnd__Force32Bit = 0x7fffffff
 };
 
-/// Enumerate different kinds of transport that can be used
-enum ESteamNetTransportKind
-{
-	k_ESteamNetTransport_Unknown = 0,
-	k_ESteamNetTransport_LoopbackBuffers = 1, // Internal buffers, not using OS network stack
-	k_ESteamNetTransport_LocalHost = 2, // Using OS network stack to talk to localhost address
-	k_ESteamNetTransport_UDP = 3, // Ordinary UDP connection.
-	k_ESteamNetTransport_UDPProbablyLocal = 4, // Ordinary UDP connection over a route that appears to be "local", meaning we think it is probably fast.  This is just a guess: VPNs and IPv6 make this pretty fuzzy.
-	k_ESteamNetTransport_TURN = 5, // Relayed over TURN server
-	k_ESteamNetTransport_SDRP2P = 6, // P2P connection relayed over Steam Datagram Relay
-	k_ESteamNetTransport_SDRHostedServer = 7, // Connection to a server hosted in a known data center via Steam Datagram Relay
-
-	k_ESteamNetTransport_Force32Bit = 0x7fffffff
-};
-
 /// Max length, in bytes (including null terminator) of the reason string
 /// when a connection is closed.
 const int k_cchSteamNetworkingMaxConnectionCloseReason = 128;
@@ -645,6 +630,13 @@ const int k_cchSteamNetworkingMaxConnectionCloseReason = 128;
 /// of a connection.
 const int k_cchSteamNetworkingMaxConnectionDescription = 128;
 
+const int k_nSteamNetworkConnectionInfoFlags_Unauthenticated = 1; // We don't have a certificate for the remote host.
+const int k_nSteamNetworkConnectionInfoFlags_Unencrypted = 2; // Information is being sent out over a wire unencrypted (by this library)
+const int k_nSteamNetworkConnectionInfoFlags_LoopbackBuffers = 4; // Internal loopback buffers.  Won't be true for localhost.  (You can check the address to determine that.)  This implies k_nSteamNetworkConnectionInfoFlags_FastLAN
+const int k_nSteamNetworkConnectionInfoFlags_Fast = 8; // The connection is "fast" and "reliable".  Either internal/localhost (check the address to find out), or the peer is on the same LAN.  (Probably.  It's based on the address and the ping time, this is actually hard to determine unambiguously).
+const int k_nSteamNetworkConnectionInfoFlags_Relayed = 16; // The connection is relayed somehow (SDR or TURN).
+const int k_nSteamNetworkConnectionInfoFlags_DualWifi = 32; // We're taking advantage of dual-wifi multi-path
+
 /// Describe the state of a connection.
 struct SteamNetConnectionInfo_t
 {
@@ -689,11 +681,8 @@ struct SteamNetConnectionInfo_t
 	/// internal logging messages.
 	char m_szConnectionDescription[ k_cchSteamNetworkingMaxConnectionDescription ];
 
-	/// What kind of transport is currently being used?
-	/// Note that this is potentially a dynamic property!  Also, it may not
-	/// always be available, especially right as the connection starts, or
-	/// after the connection ends.
-	ESteamNetTransportKind m_eTransportKind;
+	/// Misc flags.  Bitmask of k_nSteamNetworkConnectionInfoFlags_Xxxx
+	int m_nFlags;
 
 	/// Internal stuff, room to change API easily
 	uint32 reserved[63];

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_connections.cpp

@@ -1112,6 +1112,7 @@ void CSteamNetworkConnectionBase::ClearCrypto()
 	m_msgCertRemote.Clear();
 	m_msgCryptRemote.Clear();
 	m_bCertHasIdentity = false;
+	m_bRemoteCertHasTrustedCASignature = false;
 	m_keyPrivate.Wipe();
 	ClearLocalCrypto();
 }
@@ -1530,6 +1531,9 @@ bool CSteamNetworkConnectionBase::BRecvCryptoHandshake( const CMsgSteamDatagramC
 		return false;
 	}
 
+	// Remember if we they were authenticated
+	m_bRemoteCertHasTrustedCASignature = ( pCACertAuthScope != nullptr );
+
 	// Deserialize crypt info
 	if ( !m_msgCryptRemote.ParseFromString( m_sCryptRemote ) )
 	{
@@ -1891,6 +1895,12 @@ void CSteamNetworkConnectionBase::ConnectionPopulateInfo( SteamNetConnectionInfo
 	V_strcpy_safe( info.m_szEndDebug, m_szEndDebug );
 	V_strcpy_safe( info.m_szConnectionDescription, m_szDescription );
 
+	// Set security flags
+	if ( !m_bRemoteCertHasTrustedCASignature || m_identityRemote.IsInvalid() || m_identityRemote.m_eType == k_ESteamNetworkingIdentityType_IPAddress )
+		info.m_nFlags |= k_nSteamNetworkConnectionInfoFlags_Unauthenticated;
+	if ( m_eNegotiatedCipher <= k_ESteamNetworkingSocketsCipher_NULL )
+		info.m_nFlags |= k_nSteamNetworkConnectionInfoFlags_Unencrypted;
+
 	if ( m_pTransport )
 		m_pTransport->TransportPopulateConnectionInfo( info );
 }
@@ -2791,8 +2801,8 @@ void CSteamNetworkConnectionBase::ConnectionPopulateDiagnostics( ESteamNetworkin
 	APIGetDetailedConnectionStatus( stats, usecNow );
 
 	// Fill in diagnostic fields that correspond to SteamNetConnectionInfo_t
-	if ( stats.m_info.m_eTransportKind != k_ESteamNetTransport_Unknown )
-		msgConnectionState.set_transport_kind( stats.m_info.m_eTransportKind );
+	if ( stats.m_eTransportKind != k_ESteamNetTransport_Unknown )
+		msgConnectionState.set_transport_kind( stats.m_eTransportKind );
 	if ( stats.m_info.m_idPOPRelay )
 		msgConnectionState.set_sdrpopid_local( SteamNetworkingPOPIDRender( stats.m_info.m_idPOPRelay ).c_str() );
 	if ( stats.m_info.m_idPOPRemote )
@@ -3928,7 +3938,12 @@ int CSteamNetworkConnectionPipe::SendEncryptedDataChunk( const void *pChunk, int
 void CSteamNetworkConnectionPipe::TransportPopulateConnectionInfo( SteamNetConnectionInfo_t &info ) const
 {
 	CConnectionTransport::TransportPopulateConnectionInfo( info );
-	info.m_eTransportKind = k_ESteamNetTransport_LoopbackBuffers;
+	info.m_nFlags |= k_nSteamNetworkConnectionInfoFlags_LoopbackBuffers | k_nSteamNetworkConnectionInfoFlags_Fast;
+
+	// Since we're using loopback buffers, the security flags can't really apply.
+	// Make sure they are turned off
+	info.m_nFlags &= ~k_nSteamNetworkConnectionInfoFlags_Unauthenticated;
+	info.m_nFlags &= ~k_nSteamNetworkConnectionInfoFlags_Unencrypted;
 }
 
 void CSteamNetworkConnectionPipe::ConnectionStateChanged( ESteamNetworkingConnectionState eOldState )

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_connections.h

@@ -697,6 +697,7 @@ class CSteamNetworkConnectionBase : public ILockableThinker< ConnectionLock >
 	std::string m_sCryptRemote;
 	CMsgSteamDatagramCertificate m_msgCertRemote;
 	CMsgSteamDatagramSessionCryptInfo m_msgCryptRemote;
+	bool m_bRemoteCertHasTrustedCASignature; // Could expand this to an enum of different states
 
 	// Local crypto info for this connection
 	CECSigningPrivateKey m_keyPrivate; // Private key corresponding to our cert.  We'll wipe this in FinalizeLocalCrypto, as soon as we've locked in the crypto properties we're going to use
@@ -952,7 +953,7 @@ class CSteamNetworkConnectionPipe final : public CSteamNetworkConnectionBase, pu
 	virtual void DestroyTransport() override;
 	virtual void ConnectionStateChanged( ESteamNetworkingConnectionState eOldState ) override;
 
-	// CSteamNetworkConnectionTransport
+	// CConnectionTransport
 	virtual bool SendDataPacket( SteamNetworkingMicroseconds usecNow ) override;
 	virtual bool BCanSendEndToEndConnectRequest() const override;
 	virtual bool BCanSendEndToEndData() const override;

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_p2p_ice.cpp

@@ -42,23 +42,44 @@ void CConnectionTransportP2PICE::TransportPopulateConnectionInfo( SteamNetConnec
 	CConnectionTransport::TransportPopulateConnectionInfo( info );
 
 	info.m_addrRemote = m_currentRouteRemoteAddress;
-	info.m_eTransportKind = m_eCurrentRouteKind;
-
-	// If we thought the route was local, but ping time is too high, then clear local flag.
-	// (E.g. VPN)
-	if ( info.m_eTransportKind == k_ESteamNetTransport_UDPProbablyLocal )
+	switch ( m_eCurrentRouteKind )
 	{
-		int nPingMin, nPingMax;
-		m_pingEndToEnd.GetPingRangeFromRecentBuckets( nPingMin, nPingMax, SteamNetworkingSockets_GetLocalTimestamp() );
-		if ( nPingMin >= k_nMinPingTimeLocalTolerance )
-			info.m_eTransportKind = k_ESteamNetTransport_UDP;
+		default:
+		case k_ESteamNetTransport_SDRP2P:
+		case k_ESteamNetTransport_Unknown:
+			// Hm...
+			Assert( false );
+			break;
+
+		case k_ESteamNetTransport_LocalHost:
+			info.m_nFlags |= k_nSteamNetworkConnectionInfoFlags_Fast;
+			break;
+
+		case k_ESteamNetTransport_UDP:
+			break;
+
+		case k_ESteamNetTransport_UDPProbablyLocal:
+		{
+			int nPingMin, nPingMax;
+			m_pingEndToEnd.GetPingRangeFromRecentBuckets( nPingMin, nPingMax, SteamNetworkingSockets_GetLocalTimestamp() );
+			if ( nPingMin < k_nMinPingTimeLocalTolerance )
+				info.m_nFlags |= k_nSteamNetworkConnectionInfoFlags_Fast;
+			break;
+		}
+
+		case k_ESteamNetTransport_TURN:
+			info.m_nFlags |= k_nSteamNetworkConnectionInfoFlags_Relayed;
+			info.m_addrRemote.Clear();
+			break;
 	}
 }
 
 void CConnectionTransportP2PICE::GetDetailedConnectionStatus( SteamNetworkingDetailedConnectionStatus &stats, SteamNetworkingMicroseconds usecNow )
 {
-	// FIXME Need to indicate whether we are relayed or were able to pierce NAT
-	CConnectionTransport::GetDetailedConnectionStatus( stats, usecNow );
+	CConnectionTransportUDPBase::GetDetailedConnectionStatus( stats, usecNow );
+	stats.m_eTransportKind = m_eCurrentRouteKind;
+	if ( stats.m_eTransportKind == k_ESteamNetTransport_UDPProbablyLocal && !( stats.m_info.m_nFlags & k_nSteamNetworkConnectionInfoFlags_Fast ) )
+		stats.m_eTransportKind = k_ESteamNetTransport_UDP;
 }
 
 // Base-64 encode the least significant 30 bits.

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_udp.cpp

@@ -896,6 +896,25 @@ void CConnectionTransportUDPBase::Received_NoConnection( const CMsgSteamSockets_
 	m_connection.ConnectionState_ClosedByPeer( k_ESteamNetConnectionEnd_Misc_PeerSentNoConnection, "Received unexpected 'no connection' from peer");
 }
 
+void CConnectionTransportUDPBase::GetDetailedConnectionStatus( SteamNetworkingDetailedConnectionStatus &stats, SteamNetworkingMicroseconds usecNow )
+{
+	CConnectionTransport::GetDetailedConnectionStatus( stats, usecNow );
+
+	// Assume that flags field has already been populated by code above
+	if ( stats.m_info.m_addrRemote.IsLocalHost() )
+	{
+		stats.m_eTransportKind = k_ESteamNetTransport_LocalHost;
+	}
+	else if ( stats.m_info.m_nFlags & k_nSteamNetworkConnectionInfoFlags_Fast )
+	{
+		stats.m_eTransportKind = k_ESteamNetTransport_UDPProbablyLocal;
+	}
+	else
+	{
+		stats.m_eTransportKind = k_ESteamNetTransport_UDP;
+	}
+}
+
 /////////////////////////////////////////////////////////////////////////////
 //
 // IP connections
@@ -1312,18 +1331,26 @@ void CConnectionTransportUDP::TransportConnectionStateChanged( ESteamNetworkingC
 
 void CConnectionTransportUDP::TransportPopulateConnectionInfo( SteamNetConnectionInfo_t &info ) const
 {
-	CConnectionTransport::TransportPopulateConnectionInfo( info );
+	CConnectionTransportUDPBase::TransportPopulateConnectionInfo( info );
 
 	if ( m_pSocket )
 	{
 		const netadr_t &addr = m_pSocket->GetRemoteHostAddr();
 		NetAdrToSteamNetworkingIPAddr( info.m_addrRemote, addr );
-		if ( addr.IsLoopback() )
-			info.m_eTransportKind = k_ESteamNetTransport_LocalHost;
+		if ( addr.IsLoopback() ) // Actually "localhost"
+		{
+			info.m_nFlags |= k_nSteamNetworkConnectionInfoFlags_Fast;
+
+			// Should we turn off security flags?  not sure.  We are not really sure that
+			// the other side is "us", meaning our own process.  It could be
+			// some rogue hacker process.
+			//info.m_nFlags &= ~k_nSteamNetworkConnectionInfoFlags_Unauthenticated;
+			//info.m_nFlags &= ~k_nSteamNetworkConnectionInfoFlags_Unencrypted;
+		}
 		else if ( m_connection.m_statsEndToEnd.m_ping.m_nSmoothedPing <= 5 && IsRouteToAddressProbablyLocal( addr ) )
-			info.m_eTransportKind = k_ESteamNetTransport_UDPProbablyLocal;
-		else
-			info.m_eTransportKind = k_ESteamNetTransport_UDP;
+		{
+			info.m_nFlags |= k_nSteamNetworkConnectionInfoFlags_Fast;
+		}
 	}
 }
 

src/steamnetworkingsockets/clientlib/steamnetworkingsockets_udp.h

@@ -125,10 +125,11 @@ class CConnectionTransportUDPBase : public CConnectionTransport
 public:
 	CConnectionTransportUDPBase( CSteamNetworkConnectionBase &connection );
 
-	// Implements CSteamNetworkConnectionTransport
+	// Implements CConnectionTransport
 	virtual bool SendDataPacket( SteamNetworkingMicroseconds usecNow ) override;
 	virtual int SendEncryptedDataChunk( const void *pChunk, int cbChunk, SendPacketContext_t &ctx ) override;
 	virtual void SendEndToEndStatsMsg( EStatsReplyRequest eRequest, SteamNetworkingMicroseconds usecNow, const char *pszReason ) override;
+	virtual void GetDetailedConnectionStatus( SteamNetworkingDetailedConnectionStatus &stats, SteamNetworkingMicroseconds usecNow ) override;
 
 protected:
 	void Received_Data( const uint8 *pPkt, int cbPkt, SteamNetworkingMicroseconds usecNow );
@@ -157,7 +158,7 @@ class CConnectionTransportUDP final : public CConnectionTransportUDPBase
 public:
 	CConnectionTransportUDP( CSteamNetworkConnectionUDP &connection );
 
-	// Implements CSteamNetworkConnectionTransport
+	// Implements CConnectionTransport
 	virtual void TransportFreeResources() override;
 	virtual bool BCanSendEndToEndConnectRequest() const override;
 	virtual bool BCanSendEndToEndData() const override;

src/steamnetworkingsockets/steamnetworking_stats.h

@@ -11,6 +11,7 @@
 #endif
 
 #include <steam/steamnetworkingtypes.h>
+#include "steamnetworkingsockets_internal.h"
 
 #pragma pack(push)
 #pragma pack(8)
@@ -328,6 +329,9 @@ struct SteamNetworkingDetailedConnectionStatus
 	/// Basic connection info
 	SteamNetConnectionInfo_t m_info;
 
+	/// What kind of transport us being used?
+	ESteamNetTransportKind m_eTransportKind;
+
 	/// Do we have a valid network configuration?  We cannot do anything without this.
 	ESteamNetworkingAvailability m_eAvailNetworkConfig;
 

src/steamnetworkingsockets/steamnetworkingsockets_internal.h

@@ -70,6 +70,21 @@
 	#endif
 #endif
 
+/// Enumerate different kinds of transport that can be used
+enum ESteamNetTransportKind
+{
+	k_ESteamNetTransport_Unknown = 0,
+	k_ESteamNetTransport_LoopbackBuffers = 1, // Internal buffers, not using OS network stack
+	k_ESteamNetTransport_LocalHost = 2, // Using OS network stack to talk to localhost address
+	k_ESteamNetTransport_UDP = 3, // Ordinary UDP connection.
+	k_ESteamNetTransport_UDPProbablyLocal = 4, // Ordinary UDP connection over a route that appears to be "local", meaning we think it is probably fast.  This is just a guess: VPNs and IPv6 make this pretty fuzzy.
+	k_ESteamNetTransport_TURN = 5, // Relayed over TURN server
+	k_ESteamNetTransport_SDRP2P = 6, // P2P connection relayed over Steam Datagram Relay
+	k_ESteamNetTransport_SDRHostedServer = 7, // Connection to a server hosted in a known data center via Steam Datagram Relay
+
+	k_ESteamNetTransport_Force32Bit = 0x7fffffff
+};
+
 // Redefine the macros for byte-swapping, to sure the correct
 // argument size.  We probably should move this into platform.h,
 // but I suspect we'd find a bunch of "bugs" which currently don't