mirror of
https://github.com/Jous99/F4MP.git
synced 2026-01-13 05:20:54 +01:00
208 lines
12 KiB
C++
208 lines
12 KiB
C++
//====== Copyright Valve Corporation, All rights reserved. ====================
|
|
//
|
|
// Purpose: misc networking utilities
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef ISTEAMNETWORKINGUTILS
|
|
#define ISTEAMNETWORKINGUTILS
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include <stdint.h>
|
|
|
|
#include "steamnetworkingtypes.h"
|
|
struct SteamDatagramRelayAuthTicket;
|
|
struct SteamRelayNetworkStatus_t;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/// Misc networking utilities for checking the local networking environment
|
|
/// and estimating pings.
|
|
class ISteamNetworkingUtils
|
|
{
|
|
public:
|
|
//
|
|
// Efficient message sending
|
|
//
|
|
|
|
/// Allocate and initialize a message object. Usually the reason
|
|
/// you call this is to pass it to ISteamNetworkingSockets::SendMessages.
|
|
/// The returned object will have all of the relevant fields cleared to zero.
|
|
///
|
|
/// Optionally you can also request that this system allocate space to
|
|
/// hold the payload itself. If cbAllocateBuffer is nonzero, the system
|
|
/// will allocate memory to hold a payload of at least cbAllocateBuffer bytes.
|
|
/// m_pData will point to the allocated buffer, m_cbSize will be set to the
|
|
/// size, and m_pfnFreeData will be set to the proper function to free up
|
|
/// the buffer.
|
|
///
|
|
/// If cbAllocateBuffer=0, then no buffer is allocated. m_pData will be NULL,
|
|
/// m_cbSize will be zero, and m_pfnFreeData will be NULL. You will need to
|
|
/// set each of these.
|
|
virtual SteamNetworkingMessage_t *AllocateMessage( int cbAllocateBuffer ) = 0;
|
|
|
|
//
|
|
// Access to Steam Datagram Relay (SDR) network
|
|
//
|
|
|
|
#ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
|
|
// Ping measurement utilities using Valve's relay network
|
|
#endif // #ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
|
|
|
|
//
|
|
// Misc
|
|
//
|
|
|
|
/// Fetch current timestamp. This timer has the following properties:
|
|
///
|
|
/// - Monotonicity is guaranteed.
|
|
/// - The initial value will be at least 24*3600*30*1e6, i.e. about
|
|
/// 30 days worth of microseconds. In this way, the timestamp value of
|
|
/// 0 will always be at least "30 days ago". Also, negative numbers
|
|
/// will never be returned.
|
|
/// - Wraparound / overflow is not a practical concern.
|
|
///
|
|
/// If you are running under the debugger and stop the process, the clock
|
|
/// might not advance the full wall clock time that has elapsed between
|
|
/// calls. If the process is not blocked from normal operation, the
|
|
/// timestamp values will track wall clock time, even if you don't call
|
|
/// the function frequently.
|
|
///
|
|
/// The value is only meaningful for this run of the process. Don't compare
|
|
/// it to values obtained on another computer, or other runs of the same process.
|
|
virtual SteamNetworkingMicroseconds GetLocalTimestamp() = 0;
|
|
|
|
/// Set a function to receive network-related information that is useful for debugging.
|
|
/// This can be very useful during development, but it can also be useful for troubleshooting
|
|
/// problems with tech savvy end users. If you have a console or other log that customers
|
|
/// can examine, these log messages can often be helpful to troubleshoot network issues.
|
|
/// (Especially any warning/error messages.)
|
|
///
|
|
/// The detail level indicates what message to invoke your callback on. Lower numeric
|
|
/// value means more important, and the value you pass is the lowest priority (highest
|
|
/// numeric value) you wish to receive callbacks for.
|
|
///
|
|
/// Except when debugging, you should only use k_ESteamNetworkingSocketsDebugOutputType_Msg
|
|
/// or k_ESteamNetworkingSocketsDebugOutputType_Warning. For best performance, do NOT
|
|
/// request a high detail level and then filter out messages in your callback. This incurs
|
|
/// all of the expense of formatting the messages, which are then discarded. Setting a high
|
|
/// priority value (low numeric value) here allows the library to avoid doing this work.
|
|
///
|
|
/// IMPORTANT: This may be called from a service thread, while we own a mutex, etc.
|
|
/// Your output function must be threadsafe and fast! Do not make any other
|
|
/// Steamworks calls from within the handler.
|
|
virtual void SetDebugOutputFunction( ESteamNetworkingSocketsDebugOutputType eDetailLevel, FSteamNetworkingSocketsDebugOutput pfnFunc ) = 0;
|
|
|
|
//
|
|
// Set and get configuration values, see ESteamNetworkingConfigValue for individual descriptions.
|
|
//
|
|
|
|
// Shortcuts for common cases. (Implemented as inline functions below)
|
|
bool SetGlobalConfigValueInt32( ESteamNetworkingConfigValue eValue, int32 val );
|
|
bool SetGlobalConfigValueFloat( ESteamNetworkingConfigValue eValue, float val );
|
|
bool SetGlobalConfigValueString( ESteamNetworkingConfigValue eValue, const char *val );
|
|
bool SetConnectionConfigValueInt32( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, int32 val );
|
|
bool SetConnectionConfigValueFloat( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, float val );
|
|
bool SetConnectionConfigValueString( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, const char *val );
|
|
|
|
/// Set a configuration value.
|
|
/// - eValue: which value is being set
|
|
/// - eScope: Onto what type of object are you applying the setting?
|
|
/// - scopeArg: Which object you want to change? (Ignored for global scope). E.g. connection handle, listen socket handle, interface pointer, etc.
|
|
/// - eDataType: What type of data is in the buffer at pValue? This must match the type of the variable exactly!
|
|
/// - pArg: Value to set it to. You can pass NULL to remove a non-global setting at this scope,
|
|
/// causing the value for that object to use global defaults. Or at global scope, passing NULL
|
|
/// will reset any custom value and restore it to the system default.
|
|
/// NOTE: When setting callback functions, do not pass the function pointer directly.
|
|
/// Your argument should be a pointer to a function pointer.
|
|
virtual bool SetConfigValue( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj,
|
|
ESteamNetworkingConfigDataType eDataType, const void *pArg ) = 0;
|
|
|
|
/// Set a configuration value, using a struct to pass the value.
|
|
/// (This is just a convenience shortcut; see below for the implementation and
|
|
/// a little insight into how SteamNetworkingConfigValue_t is used when
|
|
/// setting config options during listen socket and connection creation.)
|
|
bool SetConfigValueStruct( const SteamNetworkingConfigValue_t &opt, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj );
|
|
|
|
/// Get a configuration value.
|
|
/// - eValue: which value to fetch
|
|
/// - eScopeType: query setting on what type of object
|
|
/// - eScopeArg: the object to query the setting for
|
|
/// - pOutDataType: If non-NULL, the data type of the value is returned.
|
|
/// - pResult: Where to put the result. Pass NULL to query the required buffer size. (k_ESteamNetworkingGetConfigValue_BufferTooSmall will be returned.)
|
|
/// - cbResult: IN: the size of your buffer. OUT: the number of bytes filled in or required.
|
|
virtual ESteamNetworkingGetConfigValueResult GetConfigValue( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj,
|
|
ESteamNetworkingConfigDataType *pOutDataType, void *pResult, size_t *cbResult ) = 0;
|
|
|
|
/// Returns info about a configuration value. Returns false if the value does not exist.
|
|
/// pOutNextValue can be used to iterate through all of the known configuration values.
|
|
/// (Use GetFirstConfigValue() to begin the iteration, will be k_ESteamNetworkingConfig_Invalid on the last value)
|
|
/// Any of the output parameters can be NULL if you do not need that information.
|
|
///
|
|
/// See k_ESteamNetworkingConfig_EnumerateDevVars for some more info about "dev" variables,
|
|
/// which are usually excluded from the set of variables enumerated using this function.
|
|
virtual bool GetConfigValueInfo( ESteamNetworkingConfigValue eValue, const char **pOutName, ESteamNetworkingConfigDataType *pOutDataType, ESteamNetworkingConfigScope *pOutScope, ESteamNetworkingConfigValue *pOutNextValue ) = 0;
|
|
|
|
/// 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
|
|
};
|
|
#define STEAMNETWORKINGUTILS_INTERFACE_VERSION "SteamNetworkingUtils003"
|
|
|
|
// Global accessor.
|
|
#ifdef STEAMNETWORKINGSOCKETS_STANDALONELIB
|
|
|
|
// Standalone lib
|
|
STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingUtils *SteamNetworkingUtils();
|
|
|
|
#else
|
|
|
|
// Steamworks SDK
|
|
inline ISteamNetworkingUtils *SteamNetworkingUtils();
|
|
STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamNetworkingUtils *, SteamNetworkingUtils,
|
|
/* Prefer user version of the interface. But if it isn't found, then use
|
|
gameserver one. Yes, this is a completely terrible hack */
|
|
SteamInternal_FindOrCreateUserInterface( 0, STEAMNETWORKINGUTILS_INTERFACE_VERSION ) ?
|
|
SteamInternal_FindOrCreateUserInterface( 0, STEAMNETWORKINGUTILS_INTERFACE_VERSION ) :
|
|
SteamInternal_FindOrCreateGameServerInterface( 0, STEAMNETWORKINGUTILS_INTERFACE_VERSION ),
|
|
"global",
|
|
STEAMNETWORKINGUTILS_INTERFACE_VERSION
|
|
)
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Internal stuff
|
|
|
|
inline bool ISteamNetworkingUtils::SetGlobalConfigValueInt32( ESteamNetworkingConfigValue eValue, int32 val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Global, 0, k_ESteamNetworkingConfig_Int32, &val ); }
|
|
inline bool ISteamNetworkingUtils::SetGlobalConfigValueFloat( ESteamNetworkingConfigValue eValue, float val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Global, 0, k_ESteamNetworkingConfig_Float, &val ); }
|
|
inline bool ISteamNetworkingUtils::SetGlobalConfigValueString( ESteamNetworkingConfigValue eValue, const char *val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Global, 0, k_ESteamNetworkingConfig_String, val ); }
|
|
inline bool ISteamNetworkingUtils::SetConnectionConfigValueInt32( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, int32 val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Connection, hConn, k_ESteamNetworkingConfig_Int32, &val ); }
|
|
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 ); }
|
|
inline bool ISteamNetworkingUtils::SetConfigValueStruct( const SteamNetworkingConfigValue_t &opt, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj )
|
|
{
|
|
// Locate the argument. Strings are a special case, since the
|
|
// "value" (the whole string buffer) doesn't fit in the struct
|
|
const void *pVal = ( opt.m_eDataType == k_ESteamNetworkingConfig_String ) ? (const void *)opt.m_val.m_string : (const void *)&opt.m_val;
|
|
return SetConfigValue( opt.m_eValue, eScopeType, scopeObj, opt.m_eDataType, pVal );
|
|
}
|
|
|
|
#if !defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) && defined( STEAMNETWORKINGSOCKETS_STEAMCLIENT )
|
|
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
|