642 lines
26 KiB
C++
642 lines
26 KiB
C++
//====== 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
|