You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
641 lines
26 KiB
641 lines
26 KiB
//====== 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
|
|
|