1 #ifndef VG_STEAM_NETWORKING_H
2 #define VG_STEAM_NETWORKING_H
6 #ifdef VALVE_CALLBACK_PACK_SMALL
13 enum ESteamNetworkingConfigScope
15 k_ESteamNetworkingConfig_Global
= 1,
16 k_ESteamNetworkingConfig_SocketsInterface
= 2,
17 k_ESteamNetworkingConfig_ListenSocket
= 3,
18 k_ESteamNetworkingConfig_Connection
= 4,
19 k_ESteamNetworkingConfigScope__Force32Bit
= 0x7fffffff
21 typedef enum ESteamNetworkingConfigScope ESteamNetworkingConfigScope
;
23 enum ESteamNetworkingConfigDataType
25 k_ESteamNetworkingConfig_Int32
= 1,
26 k_ESteamNetworkingConfig_Int64
= 2,
27 k_ESteamNetworkingConfig_Float
= 3,
28 k_ESteamNetworkingConfig_String
= 4,
29 k_ESteamNetworkingConfig_Ptr
= 5,
31 k_ESteamNetworkingConfigDataType__Force32Bit
= 0x7fffffff
33 typedef enum ESteamNetworkingConfigDataType ESteamNetworkingConfigDataType
;
35 enum ESteamNetworkingConfigValue
37 k_ESteamNetworkingConfig_Invalid
= 0,
38 k_ESteamNetworkingConfig_TimeoutInitial
= 24,
39 k_ESteamNetworkingConfig_TimeoutConnected
= 25,
40 k_ESteamNetworkingConfig_SendBufferSize
= 9,
41 k_ESteamNetworkingConfig_ConnectionUserData
= 40,
42 k_ESteamNetworkingConfig_SendRateMin
= 10,
43 k_ESteamNetworkingConfig_SendRateMax
= 11,
44 k_ESteamNetworkingConfig_NagleTime
= 12,
45 k_ESteamNetworkingConfig_IP_AllowWithoutAuth
= 23,
46 k_ESteamNetworkingConfig_MTU_PacketSize
= 32,
47 k_ESteamNetworkingConfig_MTU_DataSize
= 33,
48 k_ESteamNetworkingConfig_Unencrypted
= 34,
49 k_ESteamNetworkingConfig_SymmetricConnect
= 37,
50 k_ESteamNetworkingConfig_LocalVirtualPort
= 38,
51 k_ESteamNetworkingConfig_DualWifi_Enable
= 39,
52 k_ESteamNetworkingConfig_EnableDiagnosticsUI
= 46,
53 k_ESteamNetworkingConfig_FakePacketLoss_Send
= 2,
54 k_ESteamNetworkingConfig_FakePacketLoss_Recv
= 3,
55 k_ESteamNetworkingConfig_FakePacketLag_Send
= 4,
56 k_ESteamNetworkingConfig_FakePacketLag_Recv
= 5,
57 k_ESteamNetworkingConfig_FakePacketReorder_Send
= 6,
58 k_ESteamNetworkingConfig_FakePacketReorder_Recv
= 7,
59 k_ESteamNetworkingConfig_FakePacketReorder_Time
= 8,
60 k_ESteamNetworkingConfig_FakePacketDup_Send
= 26,
61 k_ESteamNetworkingConfig_FakePacketDup_Recv
= 27,
62 k_ESteamNetworkingConfig_FakePacketDup_TimeMax
= 28,
63 k_ESteamNetworkingConfig_PacketTraceMaxBytes
= 41,
64 k_ESteamNetworkingConfig_FakeRateLimit_Send_Rate
= 42,
65 k_ESteamNetworkingConfig_FakeRateLimit_Send_Burst
= 43,
66 k_ESteamNetworkingConfig_FakeRateLimit_Recv_Rate
= 44,
67 k_ESteamNetworkingConfig_FakeRateLimit_Recv_Burst
= 45,
68 k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged
= 201,
69 k_ESteamNetworkingConfig_Callback_AuthStatusChanged
= 202,
70 k_ESteamNetworkingConfig_Callback_RelayNetworkStatusChanged
= 203,
71 k_ESteamNetworkingConfig_Callback_MessagesSessionRequest
= 204,
72 k_ESteamNetworkingConfig_Callback_MessagesSessionFailed
= 205,
73 k_ESteamNetworkingConfig_Callback_CreateConnectionSignaling
= 206,
74 k_ESteamNetworkingConfig_Callback_FakeIPResult
= 207,
75 k_ESteamNetworkingConfig_P2P_STUN_ServerList
= 103,
76 k_ESteamNetworkingConfig_P2P_Transport_ICE_Enable
= 104,
77 k_ESteamNetworkingConfig_P2P_Transport_ICE_Penalty
= 105,
78 k_ESteamNetworkingConfig_P2P_Transport_SDR_Penalty
= 106,
79 k_ESteamNetworkingConfig_SDRClient_ConsecutitivePingTimeoutsFailInitial
= 19,
80 k_ESteamNetworkingConfig_SDRClient_ConsecutitivePingTimeoutsFail
= 20,
81 k_ESteamNetworkingConfig_SDRClient_MinPingsBeforePingAccurate
= 21,
82 k_ESteamNetworkingConfig_SDRClient_SingleSocket
= 22,
83 k_ESteamNetworkingConfig_SDRClient_ForceRelayCluster
= 29,
84 k_ESteamNetworkingConfig_SDRClient_DebugTicketAddress
= 30,
85 k_ESteamNetworkingConfig_SDRClient_ForceProxyAddr
= 31,
86 k_ESteamNetworkingConfig_SDRClient_FakeClusterPing
= 36,
87 k_ESteamNetworkingConfig_LogLevel_AckRTT
= 13,
88 k_ESteamNetworkingConfig_LogLevel_PacketDecode
= 14,
89 k_ESteamNetworkingConfig_LogLevel_Message
= 15,
90 k_ESteamNetworkingConfig_LogLevel_PacketGaps
= 16,
91 k_ESteamNetworkingConfig_LogLevel_P2PRendezvous
= 17,
92 k_ESteamNetworkingConfig_LogLevel_SDRRelayPings
= 18,
93 k_ESteamNetworkingConfig_DELETED_EnumerateDevVars
= 35,
94 k_ESteamNetworkingConfigValue__Force32Bit
= 0x7fffffff
96 typedef enum ESteamNetworkingConfigValue ESteamNetworkingConfigValue
;
99 enum ESteamNetworkingConnectionState
101 k_ESteamNetworkingConnectionState_None
= 0,
102 k_ESteamNetworkingConnectionState_Connecting
= 1,
103 k_ESteamNetworkingConnectionState_FindingRoute
= 2,
104 k_ESteamNetworkingConnectionState_Connected
= 3,
105 k_ESteamNetworkingConnectionState_ClosedByPeer
= 4,
106 k_ESteamNetworkingConnectionState_ProblemDetectedLocally
= 5,
107 k_ESteamNetworkingConnectionState_FinWait
= -1,
108 k_ESteamNetworkingConnectionState_Linger
= -2,
109 k_ESteamNetworkingConnectionState_Dead
= -3,
110 k_ESteamNetworkingConnectionState__Force32Bit
= 0x7fffffff
112 typedef enum ESteamNetworkingConnectionState ESteamNetworkingConnectionState
;
114 enum ESteamNetConnectionEnd
116 k_ESteamNetConnectionEnd_Invalid
= 0,
117 k_ESteamNetConnectionEnd_App_Min
= 1000,
118 k_ESteamNetConnectionEnd_App_Generic
= k_ESteamNetConnectionEnd_App_Min
,
119 k_ESteamNetConnectionEnd_App_Max
= 1999,
120 k_ESteamNetConnectionEnd_AppException_Min
= 2000,
121 k_ESteamNetConnectionEnd_AppException_Generic
=
122 k_ESteamNetConnectionEnd_AppException_Min
,
123 k_ESteamNetConnectionEnd_AppException_Max
= 2999,
124 k_ESteamNetConnectionEnd_Local_Min
= 3000,
125 k_ESteamNetConnectionEnd_Local_OfflineMode
= 3001,
126 k_ESteamNetConnectionEnd_Local_ManyRelayConnectivity
= 3002,
127 k_ESteamNetConnectionEnd_Local_HostedServerPrimaryRelay
= 3003,
128 k_ESteamNetConnectionEnd_Local_NetworkConfig
= 3004,
129 k_ESteamNetConnectionEnd_Local_Rights
= 3005,
130 k_ESteamNetConnectionEnd_Local_P2P_ICE_NoPublicAddresses
= 3006,
132 k_ESteamNetConnectionEnd_Local_Max
= 3999,
133 k_ESteamNetConnectionEnd_Remote_Min
= 4000,
134 k_ESteamNetConnectionEnd_Remote_Timeout
= 4001,
135 k_ESteamNetConnectionEnd_Remote_BadCrypt
= 4002,
136 k_ESteamNetConnectionEnd_Remote_BadCert
= 4003,
137 k_ESteamNetConnectionEnd_Remote_BadProtocolVersion
= 4006,
138 k_ESteamNetConnectionEnd_Remote_P2P_ICE_NoPublicAddresses
= 4007,
140 k_ESteamNetConnectionEnd_Remote_Max
= 4999,
142 k_ESteamNetConnectionEnd_Misc_Min
= 5000,
143 k_ESteamNetConnectionEnd_Misc_Generic
= 5001,
144 k_ESteamNetConnectionEnd_Misc_InternalError
= 5002,
145 k_ESteamNetConnectionEnd_Misc_Timeout
= 5003,
146 k_ESteamNetConnectionEnd_Misc_SteamConnectivity
= 5005,
147 k_ESteamNetConnectionEnd_Misc_NoRelaySessionsToClient
= 5006,
148 k_ESteamNetConnectionEnd_Misc_P2P_Rendezvous
= 5008,
149 k_ESteamNetConnectionEnd_Misc_P2P_NAT_Firewall
= 5009,
150 k_ESteamNetConnectionEnd_Misc_PeerSentNoConnection
= 5010,
152 k_ESteamNetConnectionEnd_Misc_Max
= 5999,
153 k_ESteamNetConnectionEnd__Force32Bit
= 0x7fffffff
155 typedef enum ESteamNetConnectionEnd ESteamNetConnectionEnd
;
157 enum ESteamNetworkingIdentityType
159 k_ESteamNetworkingIdentityType_Invalid
= 0,
160 k_ESteamNetworkingIdentityType_SteamID
= 16,
161 k_ESteamNetworkingIdentityType_IPAddress
= 1,
162 k_ESteamNetworkingIdentityType_GenericString
= 2,
163 k_ESteamNetworkingIdentityType_GenericBytes
= 3,
164 k_ESteamNetworkingIdentityType_UnknownType
= 4,
165 k_ESteamNetworkingIdentityType__Force32bit
= 0x7fffffff,
167 typedef enum ESteamNetworkingIdentityType ESteamNetworkingIdentityType
;
169 enum ESteamNetworkingAvailability
171 k_ESteamNetworkingAvailability_CannotTry
= -102,
172 k_ESteamNetworkingAvailability_Failed
= -101,
173 k_ESteamNetworkingAvailability_Previously
= -100,
174 k_ESteamNetworkingAvailability_Retrying
= -10,
175 k_ESteamNetworkingAvailability_NeverTried
= 1,
176 k_ESteamNetworkingAvailability_Waiting
= 2,
177 k_ESteamNetworkingAvailability_Attempting
= 3,
178 k_ESteamNetworkingAvailability_Current
= 100,
179 k_ESteamNetworkingAvailability_Unknown
= 0,
180 k_ESteamNetworkingAvailability__Force32bit
= 0x7fffffff,
182 typedef enum ESteamNetworkingAvailability ESteamNetworkingAvailability
;
184 /* Handle used to identify a connection to a remote host. */
185 typedef u32 HSteamNetConnection
;
186 HSteamNetConnection
const k_HSteamNetConnection_Invalid
= 0;
189 * Handle used to identify a "listen socket". Unlike traditional
190 * Berkeley sockets, a listen socket and a connection are two
191 * different abstractions.
193 typedef u32 HSteamListenSocket
;
194 HSteamListenSocket
const k_HSteamListenSocket_Invalid
= 0;
196 typedef u32 SteamNetworkingPOPID
;
197 typedef i64 SteamNetworkingMicroseconds
;
200 /* Store an IP and port. IPv6 is always used; IPv4 is represented using
201 * "IPv4-mapped" addresses: IPv4 aa.bb.cc.dd => IPv6 ::ffff:aabb:ccdd
202 * (RFC 4291 section 2.5.5.2.)
204 typedef struct SteamNetworkingIPAddr SteamNetworkingIPAddr
;
205 struct SteamNetworkingIPAddr
211 /* RFC4038, section 4.2 */
212 struct IPv4MappedAddress
217 u8 m_ip
[ 4 ]; /* NOTE: As bytes, i.e. network byte order */
222 u16 m_port
; // Host byte order
225 typedef struct SteamNetworkingIdentity SteamNetworkingIdentity
;
226 struct SteamNetworkingIdentity
228 ESteamNetworkingIdentityType m_eType
;
234 char m_szGenericString
[ 32 ];
235 u8 m_genericBytes
[ 32 ];
236 char m_szUnknownRawString
[ 128 ];
237 SteamNetworkingIPAddr m_ip
;
238 u32 m_reserved
[ 32 ];
245 * "Fake IPs" are assigned to hosts, to make it easier to interface with
246 * older code that assumed all hosts will have an IPv4 address
248 enum ESteamNetworkingFakeIPType
250 k_ESteamNetworkingFakeIPType_Invalid
,
251 k_ESteamNetworkingFakeIPType_NotFake
,
252 k_ESteamNetworkingFakeIPType_GlobalIPv4
,
253 k_ESteamNetworkingFakeIPType_LocalIPv4
,
254 k_ESteamNetworkingFakeIPType__Force32Bit
= 0x7fffffff
256 typedef enum ESteamNetworkingFakeIPType ESteamNetworkingFakeIPType
;
258 /* Set everything to zero. E.g. [::]:0 */
259 void SteamAPI_SteamNetworkingIPAddr_Clear( SteamNetworkingIPAddr
* self
);
261 /* Returns true if the IP is ::0. (Doesn't check port.) */
262 int SteamAPI_SteamNetworkingIPAddr_IsIPv6AllZeros(
263 SteamNetworkingIPAddr
* self
);
266 * Set IPv6 address. IP is interpreted as bytes, so there are no endian issues.
267 * (Same as inaddr_in6.) The IP can be a mapped IPv4 address
269 void SteamAPI_SteamNetworkingIPAddr_SetIPv6( SteamNetworkingIPAddr
* self
,
270 u8
*ipv6
, u16 nPort
);
272 /* Sets to IPv4 mapped address. IP and port are in host byte order. */
273 void SteamAPI_SteamNetworkingIPAddr_SetIPv4( SteamNetworkingIPAddr
* self
,
274 u32 nIP
, u16 nPort
);
276 /* Return true if IP is mapped IPv4 */
278 SteamAPI_SteamNetworkingIPAddr_IsIPv4( SteamNetworkingIPAddr
*self
);
281 * Returns IP in host byte order (e.g. aa.bb.cc.dd as 0xaabbccdd).
282 * Returns 0 if IP is not mapped IPv4.
284 u32
SteamAPI_SteamNetworkingIPAddr_GetIPv4( SteamNetworkingIPAddr
* self
);
286 /* Set to the IPv6 localhost address ::1, and the specified port. */
287 void SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost(
288 SteamNetworkingIPAddr
* self
, u16 nPort
);
291 * Return true if this identity is localhost.
292 * (Either IPv6 ::1, or IPv4 127.0.0.1)
294 steamapi_bool
SteamAPI_SteamNetworkingIPAddr_IsLocalHost(
295 SteamNetworkingIPAddr
* self
);
298 * Print to a string, with or without the port. Mapped IPv4 addresses are
299 * printed as dotted decimal (12.34.56.78), otherwise this will print the
300 * canonical form according to RFC5952. If you include the port, IPv6 will be
301 * surrounded by brackets, e.g. [::1:2]:80. Your buffer should be at least
302 * k_cchMaxString bytes to avoid truncation
304 * See also SteamNetworkingIdentityRender
306 void SteamAPI_SteamNetworkingIPAddr_ToString( SteamNetworkingIPAddr
* self
,
307 char *buf
, u32 cbBuf
, steamapi_bool bWithPort
);
310 * Parse an IP address and optional port. If a port is not present, it is set
312 * (This means that you cannot tell if a zero port was explicitly specified.)
314 steamapi_bool
SteamAPI_SteamNetworkingIPAddr_ParseString(
315 SteamNetworkingIPAddr
* self
, const char *pszStr
);
317 /* See if two addresses are identical */
318 steamapi_bool
SteamAPI_SteamNetworkingIPAddr_IsEqualTo(
319 SteamNetworkingIPAddr
*self
, SteamNetworkingIPAddr
*x
);
322 * Classify address as FakeIP. This function never returns
323 * k_ESteamNetworkingFakeIPType_Invalid.
325 ESteamNetworkingFakeIPType
SteamAPI_SteamNetworkingIPAddr_GetFakeIPType(
326 SteamNetworkingIPAddr
* self
);
328 /* Return true if we are a FakeIP */
329 steamapi_bool
SteamAPI_SteamNetworkingIPAddr_IsFakeIP( SteamNetworkingIPAddr
* self
);
332 * In a few places we need to set configuration options on listen sockets and
333 * connections, and have them take effect *before* the listen socket or
334 * connection really starts doing anything. Creating the object and then setting
335 * the options "immediately" after creation doesn't work completely, because
336 * network packets could be received between the time the object is created and
337 * when the options are applied. To set options at creation time in a reliable
338 * way, they must be passed to the creation function. This structure is used to
339 * pass those options.
341 * For the meaning of these fields, see ISteamNetworkingUtils::SetConfigValue.
342 * Basically when the object is created, we just iterate over the list of
343 * options and call ISteamNetworkingUtils::SetConfigValueStruct, where the scope
344 * arguments are supplied by the object being created.
346 typedef struct SteamNetworkingConfigValue_t SteamNetworkingConfigValue_t
;
347 struct SteamNetworkingConfigValue_t
349 /* Which option is being set */
350 ESteamNetworkingConfigValue m_eValue
;
352 /// Which field below did you fill in?
353 ESteamNetworkingConfigDataType m_eDataType
;
361 const char *m_string
; // Points to your '\0'-terminated buffer
366 void SteamAPI_SteamNetworkingConfigValue_t_SetInt32(
367 SteamNetworkingConfigValue_t
* self
,
368 ESteamNetworkingConfigValue eVal
, i32 data
);
370 void SteamAPI_SteamNetworkingConfigValue_t_SetInt64(
371 SteamNetworkingConfigValue_t
* self
,
372 ESteamNetworkingConfigValue eVal
, i64 data
);
374 void SteamAPI_SteamNetworkingConfigValue_t_SetFloat(
375 SteamNetworkingConfigValue_t
* self
,
376 ESteamNetworkingConfigValue eVal
, float data
);
378 void SteamAPI_SteamNetworkingConfigValue_t_SetPtr(
379 SteamNetworkingConfigValue_t
* self
,
380 ESteamNetworkingConfigValue eVal
, void *data
);
382 void SteamAPI_SteamNetworkingConfigValue_t_SetString(
383 SteamNetworkingConfigValue_t
* self
, ESteamNetworkingConfigValue eVal
,
386 typedef void ISteamNetworkingSockets
;
387 typedef struct SteamNetworkingMessage_t SteamNetworkingMessage_t
;
388 typedef struct SteamNetConnectionInfo_t SteamNetConnectionInfo_t
;
392 * Handle used to identify a poll group, used to query many
393 * connections at once efficiently.
395 typedef u32 HSteamNetPollGroup
;
396 HSteamNetPollGroup
const k_HSteamNetPollGroup_Invalid
= 0;
398 ISteamNetworkingSockets
399 *SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012(void);
401 ISteamNetworkingSockets
402 *SteamAPI_SteamGameServerNetworkingSockets_SteamAPI(void)
404 return SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012();
408 ISteamNetworkingSockets
*SteamAPI_SteamNetworkingSockets_SteamAPI_v012();
409 ISteamNetworkingSockets
*SteamAPI_SteamNetworkingSockets_SteamAPI()
411 return SteamAPI_SteamNetworkingSockets_SteamAPI_v012();
416 * Send the message unreliably. Can be lost. Messages *can* be larger than a
417 * single MTU (UDP packet), but there is no retransmission, so if any piece
418 * of the message is lost, the entire message will be dropped.
420 * The sending API does have some knowledge of the underlying connection, so
421 * if there is no NAT-traversal accomplished or there is a recognized adjustment
422 * happening on the connection, the packet will be batched until the connection
425 * Migration note: This is not exactly the same as k_EP2PSendUnreliable! You
426 * probably want k_ESteamNetworkingSendType_UnreliableNoNagle
428 const int k_nSteamNetworkingSend_Unreliable
= 0;
431 * Disable Nagle's algorithm.
432 * By default, Nagle's algorithm is applied to all outbound messages. This means
433 * that the message will NOT be sent immediately, in case further messages are
434 * sent soon after you send this, which can be grouped together. Any time there
435 * is enough buffered data to fill a packet, the packets will be pushed out
436 * immediately, but partially-full packets not be sent until the Nagle timer
437 * expires. See ISteamNetworkingSockets::FlushMessagesOnConnection,
438 * ISteamNetworkingMessages::FlushMessagesToUser
440 * NOTE: Don't just send every message without Nagle because you want packets to
441 * get there quicker. Make sure you understand the problem that Nagle is
442 * solving before disabling it. If you are sending small messages, often many at
443 * the same time, then it is very likely that it will be more efficient to leave
444 * Nagle enabled. A typical proper use of this flag is when you are sending
445 * what you know will be the last message sent for a while (e.g. the last in the
446 * server simulation tick to a particular client), and you use this flag to
447 * flush all messages.
449 const int k_nSteamNetworkingSend_NoNagle
= 1;
452 * Send a message unreliably, bypassing Nagle's algorithm for this message and
453 * any messages currently pending on the Nagle timer. This is equivalent to
454 * using k_ESteamNetworkingSend_Unreliable and then immediately flushing the
455 * messages using ISteamNetworkingSockets::FlushMessagesOnConnection or
456 * ISteamNetworkingMessages::FlushMessagesToUser. (But using this flag is more
457 * efficient since you only make one API call.)
459 const int k_nSteamNetworkingSend_UnreliableNoNagle
=
460 k_nSteamNetworkingSend_Unreliable
|
461 k_nSteamNetworkingSend_NoNagle
;
463 * If the message cannot be sent very soon (because the connection is still
464 * doing some initial handshaking, route negotiations, etc), then just drop it.
465 * This is only applicable for unreliable messages. Using this flag on reliable
466 * messages is invalid.
468 const int k_nSteamNetworkingSend_NoDelay
= 4;
471 * Send an unreliable message, but if it cannot be sent relatively quickly, just
472 * drop it instead of queuing it. This is useful for messages that are not
473 * useful if they are excessively delayed, such as voice data.
474 * NOTE: The Nagle algorithm is not used, and if the message is not dropped, any
475 * messages waiting on the Nagle timer are immediately flushed.
477 * A message will be dropped under the following circumstances:
478 * - the connection is not fully connected. (E.g. the "Connecting" or
479 * "FindingRoute" states)
480 * - there is a sufficiently large number of messages queued up already such
481 * that the current message will not be placed on the wire in the next
484 * If a message is dropped for these reasons, k_EResultIgnored will be returned.
486 const int k_nSteamNetworkingSend_UnreliableNoDelay
=
487 k_nSteamNetworkingSend_Unreliable
|
488 k_nSteamNetworkingSend_NoDelay
|
489 k_nSteamNetworkingSend_NoNagle
;
492 * Reliable message send. Can send up to
493 * k_cbMaxSteamNetworkingSocketsMessageSizeSend bytes in a single message.
494 * Does fragmentation/re-assembly of messages under the hood, as well as a
495 * sliding window for efficient sends of large chunks of data.
496 * The Nagle algorithm is used. See notes on
497 * k_ESteamNetworkingSendType_Unreliable for more details.
498 * See k_ESteamNetworkingSendType_ReliableNoNagle,
499 * ISteamNetworkingSockets::FlushMessagesOnConnection,
500 * ISteamNetworkingMessages::FlushMessagesToUser
502 * Migration note: This is NOT the same as k_EP2PSendReliable, it's more like
503 * k_EP2PSendReliableWithBuffering
505 const int k_nSteamNetworkingSend_Reliable
= 8;
508 * Send a message reliably, but bypass Nagle's algorithm.
510 * Migration note: This is equivalent to k_EP2PSendReliable
512 const int k_nSteamNetworkingSend_ReliableNoNagle
=
513 k_nSteamNetworkingSend_Reliable
|
514 k_nSteamNetworkingSend_NoNagle
;
517 HSteamListenSocket
SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP(
518 ISteamNetworkingSockets
*self
,
519 SteamNetworkingIPAddr
*localAddress
, int nOptions
,
520 SteamNetworkingConfigValue_t
*pOptions
);
522 HSteamNetConnection
SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
523 ISteamNetworkingSockets
*self
,
524 SteamNetworkingIPAddr
*address
, int nOptions
,
525 SteamNetworkingConfigValue_t
*pOptions
);
528 EResult
SteamAPI_ISteamNetworkingSockets_AcceptConnection(
529 ISteamNetworkingSockets
*self
,
530 HSteamNetConnection hConn
);
532 steamapi_bool
SteamAPI_ISteamNetworkingSockets_CloseConnection(
533 ISteamNetworkingSockets
*self
,
534 HSteamNetConnection hPeer
, int nReason
, const char *pszDebug
,
535 steamapi_bool bEnableLinger
);
537 steamapi_bool
SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress(
538 ISteamNetworkingSockets
*self
, HSteamListenSocket hSocket
,
539 SteamNetworkingIPAddr
*address
);
541 steamapi_bool
SteamAPI_ISteamNetworkingSockets_CloseConnection(
542 ISteamNetworkingSockets
*self
,
543 HSteamNetConnection hPeer
, int nReason
, const char *pszDebug
,
544 steamapi_bool bEnableLinger
);
546 steamapi_bool
SteamAPI_ISteamNetworkingSockets_CloseListenSocket(
547 ISteamNetworkingSockets
*self
, HSteamListenSocket hSocket
);
549 EResult
SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
550 ISteamNetworkingSockets
* self
,
551 HSteamNetConnection hConn
, const void *pData
, u32 cbData
, int nSendFlags
,
552 i64
* pOutMessageNumber
);
554 void SteamAPI_ISteamNetworkingSockets_SendMessages(
555 ISteamNetworkingSockets
* self
,
556 int nMessages
, SteamNetworkingMessage_t
*const *pMessages
,
557 i64
*pOutMessageNumberOrResult
);
559 EResult
SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection(
560 ISteamNetworkingSockets
* self
,
561 HSteamNetConnection hConn
);
563 int SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
564 ISteamNetworkingSockets
* self
,
565 HSteamNetConnection hConn
,
566 SteamNetworkingMessage_t
**ppOutMessages
,
573 HSteamNetPollGroup
SteamAPI_ISteamNetworkingSockets_CreatePollGroup(
574 ISteamNetworkingSockets
*self
);
576 steamapi_bool
SteamAPI_ISteamNetworkingSockets_DestroyPollGroup(
577 ISteamNetworkingSockets
*self
,
578 HSteamNetPollGroup hPollGroup
);
580 steamapi_bool
SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup(
581 ISteamNetworkingSockets
*self
,
582 HSteamNetConnection hConn
, HSteamNetPollGroup hPollGroup
);
584 int SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup(
585 ISteamNetworkingSockets
*self
,
586 HSteamNetPollGroup hPollGroup
, SteamNetworkingMessage_t
**ppOutMessages
,
589 * Returns basic information about the high-level state of the connection.
590 * Returns false if the connection handle is invalid.
592 steamapi_bool
SteamAPI_ISteamNetworkingSockets_GetConnectionInfo(
593 ISteamNetworkingSockets
* self
,
594 HSteamNetConnection hConn
, SteamNetConnectionInfo_t
* pInfo
);
596 int SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus(
597 ISteamNetworkingSockets
* self
,
598 HSteamNetConnection hConn
, char *pszBuf
, int cbBuf
);
600 steamapi_bool
SteamAPI_ISteamNetworkingSockets_SetConnectionUserData(
601 ISteamNetworkingSockets
* self
, HSteamNetConnection hPeer
, i64 nUserData
);
603 i64
SteamAPI_ISteamNetworkingSockets_GetConnectionUserData(
604 ISteamNetworkingSockets
* self
, HSteamNetConnection hPeer
);
606 steamapi_bool
SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress(
607 ISteamNetworkingSockets
* self
,
608 HSteamListenSocket hSocket
, SteamNetworkingIPAddr
*address
);
610 enum{ k_cchSteamNetworkingMaxConnectionCloseReason
= 128 };
611 enum{ k_cchSteamNetworkingMaxConnectionDescription
= 128 };
612 enum{ k_cchSteamNetworkingMaxConnectionAppName
= 32 };
613 enum{ k_nSteamNetworkConnectionInfoFlags_Unauthenticated
= 1 };
614 enum{ k_nSteamNetworkConnectionInfoFlags_Unencrypted
= 2 };
615 enum{ k_nSteamNetworkConnectionInfoFlags_LoopbackBuffers
= 4 };
616 enum{ k_nSteamNetworkConnectionInfoFlags_Fast
= 8 };
617 enum{ k_nSteamNetworkConnectionInfoFlags_Relayed
= 16 };
618 enum{ k_nSteamNetworkConnectionInfoFlags_DualWifi
= 32 };
620 /* Describe the state of a connection. */
621 struct SteamNetConnectionInfo_t
624 * Who is on the other end? Depending on the connection type and phase of the
625 * connection, we might not know
627 SteamNetworkingIdentity m_identityRemote
;
629 /* Arbitrary user data set by the local application code */
633 * Handle to listen socket this was connected on, or
634 * k_HSteamListenSocket_Invalid if we initiated the connection
636 HSteamListenSocket m_hListenSocket
;
639 * Remote address. Might be all 0's if we don't know it, or if this is N/A.
640 * (E.g. Basically everything except direct UDP connection.)
642 SteamNetworkingIPAddr m_addrRemote
;
645 /* What data center is the remote host in? (0 if we don't know.) */
646 SteamNetworkingPOPID m_idPOPRemote
;
649 * What relay are we using to communicate with the remote host?
650 * (0 if not applicable.)
652 SteamNetworkingPOPID m_idPOPRelay
;
654 /* High level state of the connection */
655 ESteamNetworkingConnectionState m_eState
;
658 * Basic cause of the connection termination or problem.
659 * See ESteamNetConnectionEnd for the values used
664 * Human-readable, but non-localized explanation for connection
665 * termination or problem. This is intended for debugging /
666 * diagnostic purposes only, not to display to users. It might
667 * have some details specific to the issue.
669 char m_szEndDebug
[ k_cchSteamNetworkingMaxConnectionCloseReason
];
672 * Debug description. This includes the internal connection ID,
673 * connection type (and peer information), and any name
674 * given to the connection by the app. This string is used in various
675 * internal logging messages.
677 * Note that the connection ID *usually* matches the HSteamNetConnection
678 * handle, but in certain cases with symmetric connections it might not.
680 char m_szConnectionDescription
681 [ k_cchSteamNetworkingMaxConnectionDescription
];
683 /* Misc flags. Bitmask of k_nSteamNetworkConnectionInfoFlags_Xxxx */
686 /* Internal stuff, room to change API easily */
691 * Quick connection state, pared down to something you could call
692 * more frequently without it being too big of a perf hit.
694 struct SteamNetConnectionRealTimeStatus_t
696 /* High level state of the connection */
697 ESteamNetworkingConnectionState m_eState
;
699 /* Current ping (ms) */
703 * Connection quality measured locally, 0...1.
704 * (Percentage of packets delivered end-to-end in order).
706 float m_flConnectionQualityLocal
;
708 /* Packet delivery success rate as observed from remote host */
709 float m_flConnectionQualityRemote
;
711 /* Current data rates from recent history. */
712 float m_flOutPacketsPerSec
;
713 float m_flOutBytesPerSec
;
714 float m_flInPacketsPerSec
;
715 float m_flInBytesPerSec
;
718 * Estimate rate that we believe that we can send data to our peer.
719 * Note that this could be significantly higher than m_flOutBytesPerSec,
720 * meaning the capacity of the channel is higher than you are sending data.
723 int m_nSendRateBytesPerSecond
;
726 * Number of bytes pending to be sent. This is data that you have recently
727 * requested to be sent but has not yet actually been put on the wire. The
728 * reliable number ALSO includes data that was previously placed on the wire,
729 * but has now been scheduled for re-transmission. Thus, it's possible to
730 * observe m_cbPendingReliable increasing between two checks, even if no
731 * calls were made to send reliable data between the checks. Data that is
732 * awaiting the Nagle delay will appear in these numbers.
734 int m_cbPendingUnreliable
;
735 int m_cbPendingReliable
;
738 * Number of bytes of reliable data that has been placed the wire, but
739 * for which we have not yet received an acknowledgment, and thus we may
740 * have to re-transmit.
742 int m_cbSentUnackedReliable
;
745 * If you queued a message right now, approximately how long would that
746 * message wait in the queue before we actually started putting its data on
747 * the wire in a packet?
749 * In general, data that is sent by the application is limited by the
750 * bandwidth of the channel. If you send data faster than this, it must be
751 * queued and put on the wire at a metered rate. Even sending a small amount
752 * of data (e.g. a few MTU, say ~3k) will require some of the data to be
755 * Ignoring multiple lanes,the estimated delay will be approximately equal to
757 * ( m_cbPendingUnreliable+m_cbPendingReliable ) /
758 * m_nSendRateBytesPerSecond
760 * plus or minus one MTU. It depends on how much time has elapsed since the
761 * last packet was put on the wire. For example, the queue might have *just*
762 * been emptied, and the last packet placed on the wire, and we are exactly
763 * up against the send rate limit. In that case we might need to wait for
764 * one packet's worth of time to elapse before we can send again. On the
765 * other extreme, the queue might have data in it waiting for Nagle. (This
766 * will always be less than one packet, because as soon as we have a complete
767 * packet we would send it.) In that case, we might be ready to send data
768 * now, and this value will be 0.
770 * This value is only valid if multiple lanes are not used. If multiple lanes
771 * are in use, then the queue time will be different for each lane, and you
772 * must use the value in SteamNetConnectionRealTimeLaneStatus_t.
774 * Nagle delay is ignored for the purposes of this calculation.
776 SteamNetworkingMicroseconds m_usecQueueTime
;
778 // Internal stuff, room to change API easily
786 enum { k_iSteamNetConnectionStatusChangedCallBack
=
787 k_iSteamNetworkingSocketsCallbacks
+ 1 };
789 typedef struct SteamNetConnectionStatusChangedCallback_t
790 SteamNetConnectionStatusChangedCallback_t
;
791 struct SteamNetConnectionStatusChangedCallback_t
793 /// Connection handle
794 HSteamNetConnection m_hConn
;
796 /// Full connection info
797 SteamNetConnectionInfo_t m_info
;
799 /// Previous state. (Current state is in m_info.m_eState)
800 ESteamNetworkingConnectionState m_eOldState
;
803 enum { k_iSteamNetAuthenticationStatus
=
804 k_iSteamNetworkingSocketsCallbacks
+ 2 };
806 typedef struct SteamNetAuthenticationStatus_t SteamNetAuthenticationStatus_t
;
807 struct SteamNetAuthenticationStatus_t
810 ESteamNetworkingAvailability m_eAvail
;
812 /// Non-localized English language status. For diagnostic/debugging
814 char m_debugMsg
[ 256 ];
819 /* This does not have packing specified in the steamnetworkingtypes.h, it seems
821 struct SteamNetworkingMessage_t
829 * Size of the payload.
833 HSteamNetConnection m_conn
;
836 * For inbound messages: Who sent this to us?
837 * For outbound messages on connections: not used.
838 * For outbound messages on the ad-hoc ISteamNetworkingMessages interface:
839 * who should we send this to?
841 SteamNetworkingIdentity m_identityPeer
;
844 * For messages received on connections, this is the user data
845 * associated with the connection.
847 * This is *usually* the same as calling GetConnection() and then
848 * fetching the user data associated with that connection, but for
849 * the following subtle differences:
851 * - This user data will match the connection's user data at the time
852 * is captured at the time the message is returned by the API.
853 * If you subsequently change the userdata on the connection,
854 * this won't be updated.
855 * - This is an inline call, so it's *much* faster.
856 * - You might have closed the connection, so fetching the user data
857 * would not be possible.
859 * Not used when sending messages.
864 * Local timestamp when the message was received
865 * Not used for outbound messages.
867 SteamNetworkingMicroseconds m_usecTimeReceived
;
870 * Message number assigned by the sender. This is not used for outbound
871 * messages. Note that if multiple lanes are used, each lane has its own
872 * message numbers, which are assigned sequentially, so messages from
873 * different lanes will share the same numbers.
875 i64 m_nMessageNumber
;
878 * Function used to free up m_pData. This mechanism exists so that
879 * apps can create messages with buffers allocated from their own
880 * heap, and pass them into the library. This function will
881 * usually be something like:
883 * free( pMsg->m_pData );
885 void (*m_pfnFreeData
)( SteamNetworkingMessage_t
*pMsg
);
888 * Function to used to decrement the internal reference count and, if
889 * it's zero, release the message. You should not set this function pointer,
890 * or need to access this directly! Use the Release() function instead!
892 void (*m_pfnRelease
)( SteamNetworkingMessage_t
*pMsg
);
895 * When using ISteamNetworkingMessages, the channel number the message was
896 * received on (Not used for messages sent or received on "connections")
901 * Bitmask of k_nSteamNetworkingSend_xxx flags.
902 * For received messages, only the k_nSteamNetworkingSend_Reliable bit is
904 * For outbound messages, all bits are relevant
909 * Arbitrary user data that you can use when sending messages using
910 * ISteamNetworkingUtils::AllocateMessage and
911 * ISteamNetworkingSockets::SendMessage.
912 * (The callback you set in m_pfnFreeData might use this field.)
914 * Not used for received messages.
919 * For outbound messages, which lane to use? See
920 * ISteamNetworkingSockets::ConfigureConnectionLanes.
921 * For inbound messages, what lane was the message received on?
927 void SteamAPI_SteamNetworkingMessage_t_Release(SteamNetworkingMessage_t
* self
);
936 static const char *string_ESteamNetworkingConnectionState(
937 ESteamNetworkingConnectionState s
)
941 case k_ESteamNetworkingConnectionState_None
:
944 case k_ESteamNetworkingConnectionState_Connecting
:
947 case k_ESteamNetworkingConnectionState_FindingRoute
:
948 return "Finding route";
950 case k_ESteamNetworkingConnectionState_Connected
:
953 case k_ESteamNetworkingConnectionState_ClosedByPeer
:
954 return "Closed By Peer";
956 case k_ESteamNetworkingConnectionState_ProblemDetectedLocally
:
957 return "Problem detected locally";
959 case k_ESteamNetworkingConnectionState_FinWait
:
962 case k_ESteamNetworkingConnectionState_Linger
:
965 case k_ESteamNetworkingConnectionState_Dead
:
968 case k_ESteamNetworkingConnectionState__Force32Bit
:
969 return "Force 32 Bit";
976 static const char *string_ESteamNetworkingAvailability(
977 ESteamNetworkingAvailability s
)
981 case k_ESteamNetworkingAvailability_CannotTry
:
984 case k_ESteamNetworkingAvailability_Failed
:
987 case k_ESteamNetworkingAvailability_Previously
:
990 case k_ESteamNetworkingAvailability_Retrying
:
993 case k_ESteamNetworkingAvailability_NeverTried
:
994 return "Never tried";
996 case k_ESteamNetworkingAvailability_Waiting
:
999 case k_ESteamNetworkingAvailability_Attempting
:
1000 return "Attempting";
1002 case k_ESteamNetworkingAvailability_Current
:
1005 case k_ESteamNetworkingAvailability_Unknown
:
1014 #endif /* VG_STEAM_NETWORKING_H */