diff options
Diffstat (limited to 'public/steamnetworkingsockets/steamnetworkingtypes.h')
| -rw-r--r-- | public/steamnetworkingsockets/steamnetworkingtypes.h | 641 |
1 files changed, 641 insertions, 0 deletions
diff --git a/public/steamnetworkingsockets/steamnetworkingtypes.h b/public/steamnetworkingsockets/steamnetworkingtypes.h new file mode 100644 index 0000000..2fd1baa --- /dev/null +++ b/public/steamnetworkingsockets/steamnetworkingtypes.h @@ -0,0 +1,641 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== +// +// Purpose: misc networking utilities +// +//============================================================================= + +#ifndef STEAMNETWORKINGTYPES +#define STEAMNETWORKINGTYPES +#ifdef _WIN32 +#pragma once +#endif + +#include "steam/steamtypes.h" +#include "steam/steamclientpublic.h" +#include "tier0/platform.h" + +#if defined( STEAMDATAGRAMLIB_STATIC_LINK ) + #define STEAMDATAGRAMLIB_INTERFACE extern +#elif defined( STEAMDATAGRAMLIB_FOREXPORT ) + #define STEAMDATAGRAMLIB_INTERFACE DLL_EXPORT +#else + #define STEAMDATAGRAMLIB_INTERFACE DLL_IMPORT +#endif + +#pragma pack( push, 8 ) + +struct SteamNetworkPingLocation_t; +class ISteamNetworkingMessage; +struct SteamDatagramLinkStats; +struct SteamDatagramLinkLifetimeStats; +struct SteamDatagramLinkInstantaneousStats; +struct SteamNetworkingDetailedConnectionStatus; + +/// Handle used to identify a connection to a remote host. +typedef uint32 HSteamNetConnection; +const HSteamNetConnection k_HSteamNetConnection_Invalid = 0; + +/// Handle used to identify a "listen socket". +typedef uint32 HSteamListenSocket; +const HSteamListenSocket k_HSteamListenSocket_Invalid = 0; + +/// Configuration values for Steam networking. +/// +/// Most of these are for controlling extend logging or features +/// of various subsystems +enum ESteamNetworkingConfigurationValue +{ + // Set to true (non-zero) to use Steam Network Protocol for message + // delivery. + // SNP is a protocol for sending a mix of reliable and unreliable message + // payloads and handles retransmission of reliable messages and also + // manages transfer rate congestion control. Defaults to 1 (on). + k_ESteamNetworkingConfigurationValue_SNP = 0, + + // 0-100 Randomly discard N pct of unreliable messages instead of sending + // Defaults to 0 (no loss). + k_ESteamNetworkingConfigurationValue_FakeMessageLoss_Send = 1, + + // 0-100 Randomly discard N pct of unreliable messages upon receive + // Defaults to 0 (no loss). + k_ESteamNetworkingConfigurationValue_FakeMessageLoss_Recv = 2, + + // 0-100 Randomly discard N pct of packets instead of sending + k_ESteamNetworkingConfigurationValue_FakePacketLoss_Send = 3, + + // 0-100 Randomly discard N pct of packets received + k_ESteamNetworkingConfigurationValue_FakePacketLoss_Recv = 4, + + // Set to true (non-zero) to open up a seperate debug window showing SNP + // state for all current connections. Only works on Windows. + // Defaults to 0 (off) + k_ESteamNetworkingConfigurationValue_SNP_DebugWindow = 5, + + // Upper limit of buffered pending bytes to be sent, if this is reached + // SendMessage will return k_EResultPending + // Default is 512k (524288 bytes) + k_ESteamNetworkingConfigurationValue_SNP_SendBufferSize = 6, + + // Maximum send rate clamp, 0 is no limit + // This value will control the maximum allowed sending rate that congestion + // is allowed to reach. Default is 0 (no-limit) + k_ESteamNetworkingConfigurationValue_SNP_MaxRate = 7, + + // Minimum send rate clamp, 0 is no limit + // This value will control the minimum allowed sending rate that congestion + // is allowed to reach. Default is 0 (no-limit) + k_ESteamNetworkingConfigurationValue_SNP_MinRate = 8, + + // Set to true (non-zero) to enable logging of SNP RTT + // Default is 0 (off) + k_ESteamNetworkingConfigurationValue_SNP_Log_RTT = 9, + + // Set to true (non-zero) to enable logging of SNP Packet + // Default is 0 (off) + k_ESteamNetworkingConfigurationValue_SNP_Log_Packet = 10, + + // Set to true (non-zero) to enable logging of SNP Segments + // Default is 0 (off) + k_ESteamNetworkingConfigurationValue_SNP_Log_Segments = 11, + + // Set to true (non-zero) to enable logging of SNP Feedback + // Default is 0 (off) + k_ESteamNetworkingConfigurationValue_SNP_Log_Feedback = 12, + + // Set to true (non-zero) to enable logging of SNP Relible + // Default is 0 (off) + k_ESteamNetworkingConfigurationValue_SNP_Log_Reliable = 13, + + // Set to true (non-zero) to enable logging of SNP Messages + // Default is 0 (off) + k_ESteamNetworkingConfigurationValue_SNP_Log_Message = 14, + + // Set to true (non-zero) to enable logging of SNP Loss + // Default is 0 (off) + k_ESteamNetworkingConfigurationValue_SNP_Log_Loss = 15, + + // Set to true (non-zero) to enable logging of SNP Throughput + // Default is 0 (off) + k_ESteamNetworkingConfigurationValue_SNP_Log_X = 16, + + // If the first N pings to a port all fail, mark that port as unavailable for + // a while, and try a different one. Some ISPs and routers may drop the first + // packet, so setting this to 1 may greatly disrupt communications. + k_ESteamNetworkingConfigurationValue_ClientConsecutitivePingTimeoutsFailInitial = 17, + + // If N consecutive pings to a port fail, after having received successful + // communication, mark that port as unavailable for a while, and try a + // different one. + k_ESteamNetworkingConfigurationValue_ClientConsecutitivePingTimeoutsFail = 18, + + /// Minimum number of lifetime pings we need to send, before we think our estimate + /// is solid. The first ping to each cluster is very often delayed because of NAT, + /// routers not having the best route, etc. Until we've sent a sufficient number + /// of pings, our estimate is often inaccurate. Keep pinging until we get this + /// many pings. + k_ESteamNetworkingConfigurationValue_ClientMinPingsBeforePingAccurate = 19, + + // Set all steam datagram traffic to originate from the same local port. + // By default, we open up a new UDP socket (on a different local port) + // for each relay. This is not optimal, but it works around some + // routers that don't implement NAT properly. If you have intermittent + // problems talking to relays that might be NAT related, try toggling + // this flag + k_ESteamNetworkingConfigurationValue_ClientSingleSocket = 20, + + // Globally delay all outbound packets by N ms before sending + k_ESteamNetworkingConfigurationValue_FakePacketLag_Send = 21, + + // Globally delay all received packets by N ms before processing + k_ESteamNetworkingConfigurationValue_FakePacketLag_Recv = 22, + + // Don't automatically fail IP connections that don't have strong auth. + // On clients, this means we will attempt the connection even if we don't + // know our SteamID or can't get a cert. On the server, it means that we won't + // automatically reject a connection due to a failure to authenticate. + // (You can examine the incoming connection and decide whether to accept it.) + k_ESteamNetworkingConfigurationValue_IP_Allow_Without_Auth = 23, + + // Number of k_ESteamNetworkingConfigurationValue defines + k_ESteamNetworkingConfigurationValue_Count, +}; + +/// Configuration strings for Steam networking. +/// +/// Most of these are for controlling extend logging or features +/// of various subsystems +enum ESteamNetworkingConfigurationString +{ + // Code of relay cluster to use. If not empty, we will only use relays in that cluster. E.g. 'iad' + k_ESteamNetworkingConfigurationString_ClientForceRelayCluster = 0, + + // For debugging, generate our own (unsigned) ticket, using the specified + // gameserver address. Router must be configured to accept unsigned tickets. + k_ESteamNetworkingConfigurationString_ClientDebugTicketAddress = 1, + + // For debugging. Override list of relays from the config with this set + // (maybe just one). Comma-separated list. + k_ESteamNetworkingConfigurationString_ClientForceProxyAddr = 2, + + // Number of k_ESteamNetworkingConfigurationString defines + k_ESteamNetworkingConfigurationString_Count = k_ESteamNetworkingConfigurationString_ClientForceProxyAddr + 1, +}; + +/// Basically a duplicate of EP2PSend. +enum ESteamNetworkingSendType +{ + // Send an unreliable message. Can be lost. + // The sending API does have some knowledge of the underlying connection, so if there is no NAT-traversal accomplished or + // there is a recognized adjustment happening on the connection, the packet will be batched until the connection is open again. + k_ESteamNetworkingSendType_Unreliable = 0, + + // Reliable message send. Can send up to 512kb of data in a single message. + // Does fragmentation/re-assembly of messages under the hood, as well as a sliding window for efficient sends of large chunks of data. + k_ESteamNetworkingSendType_Reliable = 1, +}; + +/// High level connection status +enum ESteamNetworkingConnectionState +{ + + /// Dummy value used to indicate an error condition in the API. + /// Specified connection doesn't exist or has already been closed. + k_ESteamNetworkingConnectionState_None = 0, + + /// - For connections on the "client" side (initiated locally): + /// We're in the process of trying to establish a connection. + /// Depending on the socket type, we might not even know who they are. + /// Note that it is not possible to tell if we are waiting on the + /// network to complete handshake packets, or for the application layer + /// to accept the connection. + /// + /// - For connections on the "server" side (accepted through listen socket): + /// We have completed a series of basic handshake packets, and the connection + /// is ready to be accepted using AcceptConnection. + /// + /// In either case, any unreliable packets sent now are almost certain + /// to be dropped. Attempts to receive packets are guaranteed to fail. + /// You may send messages if the send mode allows for them to be queued. + /// but if you close the connection before the connection is actually + /// established, any queued messages will be discarded immediately. + /// (We will not attempt to flush the queue and confirm delivery to the + /// remote host, which ordinarily happens when a connection is closed.) + k_ESteamNetworkingConnectionState_Connecting = 1, + + /// We've received communications from our peer (and we know + /// who they are) and are all good. If you close the connection now, + /// we will make our best effort to flush out any reliable sent data that + /// has not been acknowledged by the peer. (But note that this happens + /// from within the application process, so unlike a TCP connection, you are + /// not totally handing it off to the operating system to deal with it.) + k_ESteamNetworkingConnectionState_Connected = 2, + + /// Connection has been closed by our peer, but not closed locally. + /// The connection still exists from an API perspective. You must close the + /// handle to free up resources. If there are any messages in the inbound queue, + /// you may retrieve them. Otherwise, nothing may be done with the connection + /// except to close it. + /// + /// This stats is similar to CLOSE_WAIT in the TCP state machine. + k_ESteamNetworkingConnectionState_ClosedByPeer = 3, + + /// A disruption in the connection has been detected locally. (E.g. timeout, + /// local internet connection disrupted, etc.) + /// + /// The connection still exists from an API perspective. You must close the + /// handle to free up resources. + /// + /// Attempts to send further messages will fail. Any remaining received messages + /// in the queue are available. + k_ESteamNetworkingConnectionState_ProblemDetectedLocally = 4, + +// +// The following values are used internally and will not be returned by any API. +// We document them here to provide a little insight into the state machine that is used +// under the hood. +// + + /// We've disconnected on our side, and from an API perspective the connection is closed. + /// No more data may be sent or received. All reliable data has been flushed, or else + /// we've given up and discarded it. We do not yet know for sure that the client knows + /// the connection has been closed, however, so we're just hanging around so that if we do + /// get a packet from them, we can send them the appropriate packets so that they can + /// know why the connection was closed (and not have to rely on a timeout, which makes + /// it appear as if something is wrong). + /// + /// Note that, unlike TCP connections, Steam networking sessions have additional + /// session identifiers that make the TIME_WAIT state unnecessary. (If another connection + /// is established on the same port, and we get packets from an old session, we are able to + /// identify this and either ignore those packets, or inform the remote host that the old + /// session has been closed, if appropriate). + k_ESteamNetworkingConnectionState_FinWait = -1, + + /// We've disconnected on our side, and from an API perspective the connection is closed. + /// No more data may be sent or received. From a network perspective, however, on the wire, + /// we have not yet given any indication to the peer that the connection is closed. + /// We are in the process of flushing out the last bit of reliable data. Once that is done, + /// we will inform the peer that the connection has been closed, and transition to the + /// FinWait state. + /// + /// Note that no indication is given to the remote host that we have closed the connection, + /// until the data has been flushed. If the remote host attempts to send us data, we will + /// do whatever is necessary to keep the connection alive until it can be closed properly. + /// But in fact the data will be discarded, since there is no way for the application to + /// read it back. Typically this is not a problem, as application protocols that utilize + /// the lingering functionality are designed for the remote host to wait for the response + /// before sending any more data. + k_ESteamNetworkingConnectionState_Linger = -2, + + /// Connection is completely inactive and ready to be destroyed + k_ESteamNetworkingConnectionState_Dead = -3, +}; + +/// Identifier used for a network location point of presence. +/// Typically you won't need to directly manipulate these. +typedef uint32 SteamNetworkingPOPID; + +/// Convert 3- or 4-character ID to 32-bit int. +inline SteamNetworkingPOPID CalculateSteamNetworkingPOPIDFromString( const char *pszCode ) +{ + // OK we made a bad decision when we decided how to pack 3-character codes into a uint32. We'd like to support + // 4-character codes, but we don't want to break compatibility. The migration path has some subtleties that make + // this nontrivial, and there are already some IDs stored in SQL. Ug, so the 4 character code "abcd" will + // be encoded with the digits like "0xddaabbcc" + return + ( uint32(pszCode[3]) << 24U ) + | ( uint32(pszCode[0]) << 16U ) + | ( uint32(pszCode[1]) << 8U ) + | uint32(pszCode[2]); +} + +/// Unpack integer to string representation, including terminating '\0' +template <int N> +inline void GetSteamNetworkingLocationPOPStringFromID( SteamNetworkingPOPID id, char (&szCode)[N] ) +{ + COMPILE_TIME_ASSERT( N >= 5 ); + szCode[0] = ( id >> 16U ); + szCode[1] = ( id >> 8U ); + szCode[2] = ( id ); + szCode[3] = ( id >> 24U ); // See comment above about deep regret and sadness + szCode[4] = 0; +} + +/// A local timestamp. You can subtract two timestamps to get the number of elapsed +/// microseconds. This is guaranteed to increase over time during the lifetime +/// of a process, but not globally across runs. You don't need to worry about +/// the value wrapping around. Note that the underlying clock might not actually have +/// microsecond *resolution*. +typedef int64 SteamNetworkingMicroseconds; + +/// A sequence number. Used to indentify packets and messages +/// and other segments. Typically this is 64 bit internally and +/// has the last 16 bits networked +typedef int64 SteamNetworkingSequenceNumber; + +// maximum amount of pending buffered messages allows +const int k_cbMaxSteamDatagramMessageSize = 512 * 1024; + +/// A message that has been received. +class ISteamNetworkingMessage +{ +public: + + /// You MUST call this when you're done with the object, + /// to free up memory, etc. + virtual void Release() = 0; + + /// Get size of the payload. + inline uint32 GetSize() const { return m_cbSize; } + + /// Get message payload + inline const void *GetData() const { return m_pData; } + + /// Return SteamID that sent this to us. + inline CSteamID GetSenderSteamID() const { return m_steamIDSender; } + + /// Return the channel number the message was received on. + /// (Not used for messages received on "connections" + inline int GetChannel() const { return m_nChannel; } + + /// The socket this came from. (Not used when using the P2P calls) + inline HSteamNetConnection GetConnection() const { return m_conn; } + + /// Get the user data associated with the connection. + /// + /// This is *usually* the same as calling GetConnection() and then + /// fetching the user data associated with that connection, but for + /// the following subtle differences: + /// + /// - This user data will match the connection's user data at the time + /// is captured at the time the message is returned by the API. + /// If you subsequently change the userdata on the connection, + /// this won't be updated. + /// - This is an inline call, so it's *much* faster. + /// - You might have closed the connection, so fetching the user data + /// would not be possible. + inline int64 GetConnectionUserData() const { return m_nConnUserData; } + + /// Get the time that it was received + inline SteamNetworkingMicroseconds GetTimeReceived() const { return m_usecTimeReceived; } + +protected: + CSteamID m_steamIDSender; + void *m_pData; + uint32 m_cbSize; + int m_nChannel; + HSteamNetConnection m_conn; + int64 m_nConnUserData; + SteamNetworkingMicroseconds m_usecTimeReceived; + + inline ~ISteamNetworkingMessage() {}; // Destructor hidden - use Release()! But make it inline and empty, in case you want to derive your own type that satisfies this interface for use in your code. +}; + +/// Object that describes a "location" on the Internet with sufficient +/// detail that we can reasonably estimate an upper bound on the ping between +/// the two hosts, even if a direct route between the hosts is not possible, +/// and the connection must be routed through the Steam Datagram Relay network. +/// This does not contain any information that identifies the host. Indeed, +/// if two hosts are in the same building or otherwise have nearly identical +/// networking characteristics, then it's valid to use the same location +/// object for both of them. +/// +/// NOTE: This object should only be used in memory. If you need to persist +/// it or send it over the wire, convert it to a string representation using +/// the methods in ISteamNetworkingUtils() +struct SteamNetworkPingLocation_t +{ + uint8 m_data[ 64 ]; +}; + +/// Special values that are returned by some functions that return a ping. +const int k_nSteamNetworkingPing_Failed = -1; +const int k_nSteamNetworkingPing_Unknown = -2; + +/// Enumerate various causes of connection termination. These are designed +/// to work sort of like HTTP error codes, in that the numeric range gives you +/// a ballpark as to where the problem is. +enum ESteamNetConnectionEnd +{ + // Invalid/sentinel value + k_ESteamNetConnectionEnd_Invalid = 0, + + // + // Application codes. You can use these codes if you want to + // plumb through application-specific error codes. If you don't need this + // facility, feel free to always use 0, which is a generic + // application-initiated closure. + // + // The distinction between "normal" and "exceptional" termination is + // one you may use if you find useful, but it's not necessary for you + // to do so. The only place where we distinguish between normal and + // exceptional is in connection analytics. If a significant + // proportion of connections terminates in an exceptional manner, + // this can trigger an alert. + // + + // 1xxx: Application ended the connection in a "usual" manner. + // E.g.: user intentionally disconnected from the server, + // gameplay ended normally, etc + k_ESteamNetConnectionEnd_App_Min = 1000, + k_ESteamNetConnectionEnd_App_Generic = k_ESteamNetConnectionEnd_App_Min, + // Use codes in this range for "normal" disconnection + k_ESteamNetConnectionEnd_App_Max = 1999, + + // 2xxx: Application ended the connection in some sort of exceptional + // or unusual manner that might indicate a bug or configuration + // issue. + // + k_ESteamNetConnectionEnd_AppException_Min = 2000, + k_ESteamNetConnectionEnd_AppException_Generic = k_ESteamNetConnectionEnd_AppException_Min, + // Use codes in this range for "unusual" disconnection + k_ESteamNetConnectionEnd_AppException_Max = 2999, + + // + // System codes: + // + + // 3xxx: Connection failed or ended because of problem with the + // local host or their connection to the Internet. + k_ESteamNetConnectionEnd_Local_Min = 3000, + + // You cannot do what you want to do because you're running in offline mode. + k_ESteamNetConnectionEnd_Local_OfflineMode = 3001, + + // We're having trouble contacting many (perhaps all) relays. + // Since it's unlikely that they all went offline at once, the best + // explanation is that we have a problem on our end. Note that we don't + // bother distinguishing between "many" and "all", because in practice, + // it takes time to detect a connection problem, and by the time + // the connection has timed out, we might not have been able to + // actively probe all of the relay clusters, even if we were able to + // contact them at one time. So this code just means that: + // + // * We don't have any recent successful communication with any relay. + // * We have evidence of recent failures to communicate with multiple relays. + k_ESteamNetConnectionEnd_Local_ManyRelayConnectivity = 3002, + + // A hosted server is having trouble talking to the relay + // that the client was using, so the problem is most likely + // on our end + k_ESteamNetConnectionEnd_Local_HostedServerPrimaryRelay = 3003, + + // We're not able to get the network config. This is + // *almost* always a local issue, since the network config + // comes from the CDN, which is pretty darn reliable. + k_ESteamNetConnectionEnd_Local_NetworkConfig = 3004, + + k_ESteamNetConnectionEnd_Local_Max = 3999, + + // 4xxx: Connection failed or ended, and it appears that the + // cause does NOT have to do with the local host or their + // connection to the Internet. It could be caused by the + // remote host, or it could be somewhere in between. + k_ESteamNetConnectionEnd_Remote_Min = 4000, + + // The connection was lost, and as far as we can tell our connection + // to relevant services (relays) has not been disrupted. This doesn't + // mean that the problem is "their fault", it just means that it doesn't + // appear that we are having network issues on our end. + k_ESteamNetConnectionEnd_Remote_Timeout = 4001, + + // Something was invalid with the cert or crypt handshake + // info you gave me, I don't understand or like your key types, + // etc. + k_ESteamNetConnectionEnd_Remote_BadCrypt = 4002, + + // You presented me with a cert that was technically + // valid. But the CA key was missing (and I don't accept + // unsigned certs), or the key isn't one that I trust. + k_ESteamNetConnectionEnd_Remote_CertNotTrusted = 4003, + + k_ESteamNetConnectionEnd_Remote_Max = 4999, + + // 5xxx: Connection failed for some other reason. + k_ESteamNetConnectionEnd_Misc_Min = 5000, + + // A failure that isn't necessarily the result of a software bug, + // but that should happen rarely enough that it isn't worth specifically + // writing UI or making a localized message for. + // The debug string should contain further details. + k_ESteamNetConnectionEnd_Misc_Generic = 5001, + + // Generic failure that is most likely a software bug. + k_ESteamNetConnectionEnd_Misc_InternalError = 5002, + + // The connection to the remote host timed out, but we + // don't know if the problem is on our end, in the middle, + // or on their end. + k_ESteamNetConnectionEnd_Misc_Timeout = 5003, + + // We're having trouble talking to the relevant relay. + // We don't have enough information to say whether the + // problem is on our end or not. + k_ESteamNetConnectionEnd_Misc_RelayConnectivity = 5004, + + // There's some trouble talking to Steam. + k_ESteamNetConnectionEnd_Misc_SteamConnectivity = 5005, + + // A server in a dedicated hosting situation has no relay sessions + // active with which to talk back to a client. (It's the client's + // job to open and maintain those sessions.) + k_ESteamNetConnectionEnd_Misc_NoRelaySessionsToClient = 5006, + + k_ESteamNetConnectionEnd_Misc_Max = 5999, +}; + +/// Max length of diagnostic error message +const int k_cchMaxSteamDatagramErrMsg = 1024; + +/// Used to return English-language diagnostic error messages to caller. +/// (For debugging or spewing to a console, etc. Not intended for UI.) +typedef char SteamDatagramErrMsg[ k_cchMaxSteamDatagramErrMsg ]; + +/// Max length, in bytes (including null terminator) of the reason string +/// when a connection is closed. +const int k_cchSteamNetworkingMaxConnectionCloseReason = 128; + +struct SteamNetConnectionInfo_t +{ + + /// Handle to listen socket this was connected on, or k_HSteamListenSocket_Invalid if we initiated the connection + HSteamListenSocket m_hListenSocket; + + /// Who is on the other end. Depending on the connection type and phase of the connection, we might not know + CSteamID m_steamIDRemote; + + // FIXME - some sort of connection type enum? + + /// Arbitrary user data set by the local application code + int64 m_nUserData; + + /// Remote address. Might be 0 if we don't know it + uint32 m_unIPRemote; + uint16 m_unPortRemote; + uint16 m__pad1; + + /// What data center is the remote host in? (0 if we don't know.) + SteamNetworkingPOPID m_idPOPRemote; + + /// What relay are we using to communicate with the remote host? + /// (0 if not applicable.) + SteamNetworkingPOPID m_idPOPRelay; + + /// Local port that we're bound to for this connection. Might not be applicable + /// for all connection types. + //uint16 m_unPortLocal; + + /// High level state of the connection + int /* ESteamNetworkingConnectionState */ m_eState; + + /// Basic cause of the connection termination or problem. + /// One of ESteamNetConnectionEnd + int /* ESteamNetConnectionEnd */ m_eEndReason; + + /// Human-readable, but non-localized explanation for connection + /// termination or problem. This is intended for debugging / + /// diagnostic purposes only, not to display to users. It might + /// have some details specific to the issue. + char m_szEndDebug[ k_cchSteamNetworkingMaxConnectionCloseReason ]; +}; + +/// Quick connection state, pared down to something you could call +/// more frequently without it being too big of a perf hit. +struct SteamNetworkingQuickConnectionStatus +{ + + /// High level state of the connection + int /* ESteamNetworkingConnectionState */ m_eState; + + /// Current ping (ms) + int m_nPing; + + /// Connection quality measured locally, 0...1. (Percentage of packets delivered + /// end-to-end in order) + float m_flConnectionQualityLocal; + + /// Packet delivery success rate as observed from remote host + float m_flConnectionQualityRemote; + + /// Actual current data rates + float m_flOutPacketsPerSec; + float m_flOutBytesPerSec; + float m_flInPacketsPerSec; + float m_flInBytesPerSec; + + /// Estimate bandwidth of the connection (bytes per second) + int m_nSendRate; + + /// Number of bytes pending to be sent + int m_nPendingBytes; +}; + +#pragma pack( pop ) + +enum ESteamDatagramPartner +{ + k_ESteamDatagramPartner_None = -1, + k_ESteamDatagramPartner_Steam = 0, + k_ESteamDatagramPartner_China = 1, +}; + +#endif // #ifndef STEAMNETWORKINGTYPES |