//====== Copyright Valve Corporation, All rights reserved. ==================== // // Purpose: A low level API similar to Berkeley socket, to send messages // between hosts over the Steam network and addressed using Steam IDs. // //============================================================================= #ifndef ISTEAMNETWORKINGSOCKETS #define ISTEAMNETWORKINGSOCKETS #ifdef _WIN32 #pragma once #endif #include "steamnetworkingtypes.h" // #KLUDGE! This is so we don't have to link with steam_api.lib #include #include //----------------------------------------------------------------------------- /// Lower level networking interface that more closely mirrors the standard /// Berkeley sockets model. Sockets are hard! You should probably only use /// this interface under the existing circumstances: /// /// - You have an existing socket-based codebase you want to port, or coexist with. /// - You want to be able to connect based on IP address, rather than (just) Steam ID. /// - You need low-level control of bandwidth utilization, when to drop packets, etc. /// /// Note that neither of the terms "connection" and "socket" will correspond /// one-to-one with an underlying UDP socket. An attempt has been made to /// keep the semantics as similar to the standard socket model when appropriate, /// but some deviations do exist. class ISteamSocketNetworking { public: /// Creates a "server" socket that listens for clients to connect to, either by calling /// ConnectSocketBySteamID or ConnectSocketByIPv4Address. /// /// nSteamConnectVirtualPort specifies how clients can connect to this socket using /// ConnectBySteamID. A negative value indicates that this functionality is /// disabled and clients must connect by IP address. It's very common for applications /// to only have one listening socket; in that case, use zero. If you need to open /// multiple listen sockets and have clients be able to connect to one or the other, then /// nSteamConnectVirtualPort should be a small integer constant unique to each listen socket /// you create. /// /// If you want clients to connect to you by your IPv4 addresses using /// ConnectByIPv4Address, then you must set nPort to be nonzero. Steam will /// bind a UDP socket to the specified local port, and clients will send packets using /// ordinary IP routing. It's up to you to take care of NAT, protecting your server /// from DoS, etc. If you don't need clients to connect to you by IP, then set nPort=0. /// Use nIP if you wish to bind to a particular local interface. Typically you will use 0, /// which means to listen on all interfaces, and accept the default outbound IP address. /// If nPort is zero, then nIP must also be zero. /// /// A SocketStatusCallback_t callback when another client attempts a connection. virtual HSteamListenSocket CreateListenSocket( int nSteamConnectVirtualPort, uint32 nIP, uint16 nPort ) = 0; /// Creates a connection and begins talking to a remote destination. The remote host /// must be listening with the appropriate call to CreateListenSocket. /// /// Use ConnectBySteamID to connect using the SteamID (client or game server) as the network address. /// Use ConnectByIPv4Address to connect by IP address. /// /// On success, a SocketStatusCallback_t callback is triggered. /// On failure or timeout, a SocketStatusCallback_t callback with a failure code in m_eSNetSocketState virtual HSteamNetConnection ConnectBySteamID( CSteamID steamIDTarget, int nVirtualPort, int nTimeoutSec ) = 0; virtual HSteamNetConnection ConnectByIPv4Address( uint32 nIP, uint16 nPort, int nTimeoutSec ) = 0; /// Accept an incoming connection that has been received on a listen socket. /// /// When a connection attempt is received (perhaps after a few basic handshake /// packets have been exchanged to prevent trivial spoofing), a connection interface /// object is created in the k_ESteamNetworkingConnectionState_Connecting state /// and a SteamNetConnectionStatusChangedCallback_t is posted. At this point, your /// application MUST either accept or close the connection. (It may not ignore it.) /// Accepting the connection will transition it into the connected state. /// /// You should take action within a few seconds, because accepting the connection is /// what actually sends the reply notifying the client that they are connected. If you /// delay taking action, from the client's perspective it is the same as the network /// being unresponsive, and the client may timeout the connection attempt. In other /// words, the client cannot distinguish between a delay caused by network problems /// and a delay caused by the application. /// /// This means that if your application goes for more than a few seconds without /// processing callbacks, then there is a chance that a client may attempt to connect /// in that interval, and timeout. /// /// If the application does not respond to the connection attempt in a timely manner, /// and we stop receiving communication from the client, the connection attempt will /// be timed out locally, transitioning the connection to the /// k_ESteamNetworkingConnectionState_ProblemDetectedLocally state. The client may also /// close the connection before it is accepted and a transition to the /// k_ESteamNetworkingConnectionState_ClosedByPeer is also possible. /// /// Returns k_EResultInvalidParam if the handle is invalid. /// Returns k_EResultInvalidState if the connection is not in the appropriate state. /// (Remember that the connection state could change in between the time that the /// notification being posted to the queue and when it is received by the application.) virtual EResult AcceptConnection( HSteamNetConnection hConn ) = 0; /// Disconnects from the remote host and invalidates the connection handle. /// Any unread data on the connection is discarded. /// /// nReason is an application defined code that will be received on the other /// end and recorded (when possible) in backend analytics. The value should /// come from a restricted range. (See ESteamNetConnectionEnd.) If you don't need /// to communicate any information to the remote host, and do not want analytics to /// be able to distinguish "normal" connection terminations from "exceptional" ones, /// You may pass zero, in which case the generic value of /// k_ESteamNetConnectionEnd_App_Generic will be used. /// /// pszDebug is an optional human-readable diagnostic string that will be received /// by the remote host and recorded (when possible) in backend analytics. /// /// If you wish to put the socket into a "linger" state, where an attempt is made to /// flush any remaining sent data, use bEnableLinger=true. Otherwise reliable data /// is not flushed. /// /// If the connection has already ended and you are just freeing up the /// connection interface, the reason code, debug string, and linger flag are /// ignored. virtual bool CloseConnection( HSteamNetConnection hPeer, int nReason, const char *pszDebug, bool bEnableLinger ) = 0; /// Destroy a listen socket, and all the client sockets generated by accepting connections /// on the listen socket. /// /// pszNotifyRemoteReason determines what cleanup actions are performed on the client /// sockets being destroyed. (See DestroySocket for more details.) /// /// Note that if cleanup is requested and you have requested the listen socket bound to a /// particular local port to facilitate direct UDP/IPv4 connections, then the underlying UDP /// socket must remain open until all clients have been cleaned up. virtual bool CloseListenSocket( HSteamListenSocket hSocket, const char *pszNotifyRemoteReason ) = 0; /// Set connection user data. Returns false if the handle is invalid. virtual bool SetConnectionUserData( HSteamNetConnection hPeer, int64 nUserData ) = 0; /// Fetch connection user data. Returns -1 if handle is invalid /// or if you haven't set any userdata on the connection. virtual int64 GetConnectionUserData( HSteamNetConnection hPeer ) = 0; /// Set a name for the connection, used mostly for debugging virtual void SetConnectionName( HSteamNetConnection hPeer, const char *pszName ) = 0; /// Fetch connection user data. Returns -1 if handle is invalid /// or if you haven't set any userdata on the connection. virtual void GetConnectionName( HSteamNetConnection hPeer, char *ppszName, int nMaxLen ) = 0; /// Send a message to the remote host on the connected socket. /// /// eSendType determines the delivery guarantees that will be provided, /// when data should be buffered, etc. /// /// Note that the semantics we use for messages are not precisely /// the same as the semantics of a standard "stream" socket. /// (SOCK_STREAM) For an ordinary stream socket, the boundaries /// between chunks are not considered relevant, and the sizes of /// the chunks of data written will not necessarily match up to /// the sizes of the chunks that are returned by the reads on /// the other end. The remote host might read a partial chunk, /// or chunks might be coalesced. For the message semantics /// used here, however, the sizes WILL match. Each send call /// will match a successful read call on the remote host /// one-for-one. If you are porting existing stream-oriented /// code to the semantics of reliable messages, your code should /// work the same, since reliable message semantics are more /// strict than stream semantics. The only caveat is related to /// performance: there is per-message overhead to retain the /// messages sizes, and so if your code sends many small chunks /// of data, performance will suffer. Any code based on stream /// sockets that does not write excessively small chunks will /// work without any changes. virtual EResult SendMessageToConnection( HSteamNetConnection hConn, const void *pData, uint32 cbData, ESteamNetworkingSendType eSendType ) = 0; /// Fetch the next available message(s) from the socket, if any. /// Returns the number of messages returned into your array, up to nMaxMessages. /// If the connection handle is invalid, -1 is returned. /// /// The order of the messages returned in the array is relevant. /// Reliable messages will be received in the order they were sent (and with the /// same sizes --- see SendMessageToConnection for on this subtle difference from a stream socket). /// /// FIXME - We're still debating the exact set of guarantees for unreliable, so this might change. /// Unreliable messages may not be received. The order of delivery of unreliable messages /// is NOT specified. They may be received out of order with respect to each other or /// reliable messages. They may be received multiple times! /// /// If any messages are returned, you MUST call Release() to each of them free up resources /// after you are done. It is safe to keep the object alive for a little while (put it /// into some queue, etc), and you may call Release() from any thread. virtual int ReceiveMessagesOnConnection( HSteamNetConnection hConn, ISteamNetworkingMessage **ppOutMessages, int nMaxMessages ) = 0; /// Same as ReceiveMessagesOnConnection, but will return the next message available /// on any client socket that was accepted through the specified listen socket. Use /// ISteamNetworkingMessage::GetConnection to know which client connection. /// /// Delivery order of messages among different clients is not defined. They may /// be returned in an order different from what they were actually received. (Delivery /// order of messages from the same client is well defined, and thus the order of the /// messages is relevant!) virtual int ReceiveMessagesOnListenSocket( HSteamListenSocket hSocket, ISteamNetworkingMessage **ppOutMessages, int nMaxMessages ) = 0; /// Returns information about the specified connection. virtual bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo_t *pInfo ) = 0; /// Returns brief set of connection status that you might want to display /// to the user in game. virtual bool GetQuickConnectionStatus( HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus *pStats ) = 0; /// Returns detailed connection stats in text format. Useful /// for dumping to a log, etc. /// /// Returns: /// -1 failure (bad connection handle) /// 0 OK, your buffer was filled in and '\0'-terminated /// >0 Your buffer was either nullptr, or it was too small and the text got truncated. Try again with a buffer of at least N bytes. virtual int GetDetailedConnectionStatus( HSteamNetConnection hConn, char *pszBuf, int cbBuf ) = 0; /// Returns information about the listen socket. /// /// *pnIP and *pnPort will be 0 if the socket is set to listen for connections based /// on SteamID only. If your listen socket accepts connections on IPv4, then both /// fields will return nonzero, even if you originally passed a zero IP. However, /// note that the address returned may be a private address (e.g. 10.0.0.x or 192.168.x.x), /// and may not be reachable by a general host on the Internet. virtual bool GetListenSocketInfo( HSteamListenSocket hSocket, uint32 *pnIP, uint16 *pnPort ) = 0; // // Special SDR connections involved with servers hosted in Valve data centers // virtual bool SetHostedDedicatedServerCertificate( const void *pCert, int cbCert, void *pPrivateKey, int cbPrivateKey ) = 0; virtual HSteamListenSocket CreateHostedDedicatedServerListenSocket( uint16 nPort ) = 0; virtual HSteamNetConnection ConnectToHostedDedicatedServer( CSteamID steamIDTarget ) = 0; // // Gets some debug text from the connection // virtual bool GetConnectionDebugText( HSteamNetConnection hConn, char *pOut, int nOutCCH ) = 0; // // Set and get configuration values, see ESteamNetworkingConfigurationValue for individual descriptions. // // Returns the value or -1 is eConfigValue is invalid virtual int32 GetConfigurationValue( ESteamNetworkingConfigurationValue eConfigValue ) = 0; // Returns true if successfully set virtual bool SetConfigurationValue( ESteamNetworkingConfigurationValue eConfigValue, int32 nValue ) = 0; // Return the name of an int configuration value, or NULL if config value isn't known virtual const char *GetConfigurationValueName( ESteamNetworkingConfigurationValue eConfigValue ) = 0; // // Set and get configuration strings, see ESteamNetworkingConfigurationString for individual descriptions. // // Get the configuration string, returns length of string needed if pDest is nullpr or destSize is 0 // returns -1 if the eConfigValue is invalid virtual int32 GetConfigurationString( ESteamNetworkingConfigurationString eConfigString, char *pDest, int32 destSize ) = 0; virtual bool SetConfigurationString( ESteamNetworkingConfigurationString eConfigString, const char *pString ) = 0; // Return the name of a string configuration value, or NULL if config value isn't known virtual const char *GetConfigurationStringName( ESteamNetworkingConfigurationString eConfigString ) = 0; }; #define STEAMSOCKETNETWORKING_VERSION "SteamSocketNetworking001" // Notification struct used to notify when a connection has changed state struct SteamNetConnectionStatusChangedCallback_t { HSteamNetConnection m_hConn; //< Connection handle SteamNetConnectionInfo_t m_info; //< Full connection info int m_eOldState; //< ESNetSocketState. (Current stats is in m_info) }; // Temporary global accessor. This will be moved to steam_api.h STEAMDATAGRAMLIB_INTERFACE ISteamSocketNetworking *SteamSocketNetworking(); typedef void * ( S_CALLTYPE *FSteamInternal_CreateInterface )( const char *); typedef void ( S_CALLTYPE *FSteamAPI_RegisterCallResult)( class CCallbackBase *pCallback, SteamAPICall_t hAPICall ); typedef void ( S_CALLTYPE *FSteamAPI_UnregisterCallResult)( class CCallbackBase *pCallback, SteamAPICall_t hAPICall ); /// !KLUDGE! Glue code that will go away when we move everything into /// the ISteamNetwork interfaces STEAMDATAGRAMLIB_INTERFACE void SteamDatagramClient_Internal_SteamAPIKludge( FSteamAPI_RegisterCallResult fnRegisterCallResult, FSteamAPI_UnregisterCallResult fnUnregisterCallResult ); STEAMDATAGRAMLIB_INTERFACE bool SteamDatagramClient_Init_Internal( const char *pszCacheDirectory, /* ESteamDatagramPartner */ int ePartner, int iPartnerMask, SteamDatagramErrMsg &errMsg, ISteamClient *pClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe ); inline bool SteamDatagramClient_Init( const char *pszCacheDirectory, /* ESteamDatagramPartner */ int ePartner, int iPartnerMask, SteamDatagramErrMsg &errMsg ) { SteamDatagramClient_Internal_SteamAPIKludge( &::SteamAPI_RegisterCallResult, &::SteamAPI_UnregisterCallResult ); return SteamDatagramClient_Init_Internal( pszCacheDirectory, ePartner, iPartnerMask, errMsg, ::SteamClient(), ::SteamAPI_GetHSteamUser(), ::SteamAPI_GetHSteamPipe() ); } /// Shutdown all clients and close all sockets STEAMDATAGRAMLIB_INTERFACE void SteamDatagramClient_Kill(); /// Initialize the game server interface STEAMDATAGRAMLIB_INTERFACE bool SteamDatagramServer_Init_Internal( SteamDatagramErrMsg &errMsg, ISteamClient *pClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe ); // KLUDGE TF is using an old version of the SDK, which doesn't have this. TF doesn't need this, so just comment it out. // We'll need to upgrade the Steamworks SDK if we want to actually use SDR //inline bool SteamDatagramServer_Init( SteamDatagramErrMsg &errMsg ) //{ // SteamDatagramClient_Internal_SteamAPIKludge( &::SteamAPI_RegisterCallResult, &::SteamAPI_UnregisterCallResult ); // return SteamDatagramServer_Init_Internal( errMsg, ::SteamGameServerClient(), ::SteamGameServer_GetHSteamUser(), ::SteamGameServer_GetHSteamPipe() ); //} /// Shutdown the game server interface STEAMDATAGRAMLIB_INTERFACE void SteamDatagramServer_Kill( ); // !KLUDGE! Check for connections that have changed status, and post callbacks. // This is temporary we can hook this up using the ordinary steam CCallback mechanism typedef void (*FSteamNetConnectionStatusChangedCallback)( SteamNetConnectionStatusChangedCallback_t *pInfo ); STEAMDATAGRAMLIB_INTERFACE void Temp_DispatchsSteamNetConnectionStatusChangedCallbacks( FSteamNetConnectionStatusChangedCallback fnCallback ); enum ESteamDatagramDebugOutputType { k_ESteamDatagramDebugOutputType_None, k_ESteamDatagramDebugOutputType_Error, k_ESteamDatagramDebugOutputType_Important, // Nothing is wrong, but this is an important notification k_ESteamDatagramDebugOutputType_Warning, k_ESteamDatagramDebugOutputType_Msg, // Recommended amount k_ESteamDatagramDebugOutputType_Verbose, // Quite a bit k_ESteamDatagramDebugOutputType_Debug, // Practically everything }; /// Setup callback for debug output, and the desired verbosity you want. typedef void (*FSteamDatagramDebugOutput)( /* ESteamDatagramDebugOutputType */ int nType, const char *pszMsg ); STEAMDATAGRAMLIB_INTERFACE void SteamDatagram_SetDebugOutputFunction( /* ESteamDatagramDebugOutputType */ int eDetailLevel, FSteamDatagramDebugOutput pfnFunc ); #endif // ISTEAMNETWORKINGSOCKETS