goldberg_emulator/sdk_includes/steamnetworkingfakeip.h
2022-01-25 15:49:26 -05:00

136 lines
6.2 KiB
C++

//====== Copyright Valve Corporation, All rights reserved. ====================
#ifndef STEAMNETWORKINGFAKEIP_H
#define STEAMNETWORKINGFAKEIP_H
#include "steamnetworkingtypes.h"
#include "steam_api_common.h"
// It is HIGHLY recommended to limit messages sent via Fake UDP port to this
// value. The purpose of a Fake UDP port is to make porting ordinary ad-hoc UDP
// code easier. Although the real MTU might be higher than this, this particular
// conservative value is chosen so that fragmentation won't be occurring and
// hiding performance problems from you.
constexpr int k_cbSteamNetworkingSocketsFakeUDPPortRecommendedMTU = 1200;
// Messages larger than this size are not allowed and cannot be sent
// via Fake UDP port.
constexpr int k_cbSteamNetworkingSocketsFakeUDPPortMaxMessageSize = 4096;
//-----------------------------------------------------------------------------
/// ISteamNetworkingFakeUDPPort
///
/// Acts like a UDP port, sending and receiving datagrams addressed using
/// FakeIP addresses.
///
/// See: ISteamNetworkingSockets::CreateFakeUDPPort
class ISteamNetworkingFakeUDPPort
{
public:
/// Destroy the object and cleanup any internal connections.
/// Note that this function call is not threadsafe with respect
/// to any other method of this interface. (However, in general
/// all other operations are threadsafe with respect to each other.)
virtual void DestroyFakeUDPPort() = 0;
/// Send a datagram to the specified FakeIP.
///
/// See ISteamNetworkingSockets::SendMessageToConnection for the meaning of
/// nSendFlags and possible return codes.
///
/// Notes:
/// - datagrams larger than the underlying MTU are supported, but
/// reliable messages (k_nSteamNetworkingSend_Reliable) are not supported.
/// - You will usually want to use k_nSteamNetworkingSend_NoNagle
/// - k_EResultBusy is returned if this is a "server" port and the global
/// allocation has not yet completed.
/// - k_EResultIPNotFound will be returned if the address is a local/ephemeral
/// address and no existing connection can be found. This can happen if
/// the remote host contacted us without having a global address, and we
/// assigned them a random local address, and then the session with
/// that host timed out.
/// - When initiating communications, the first messages may be sent
/// via backend signaling, or otherwise delayed, while a route is found.
/// Expect the ping time to fluctuate during this period, and it's possible
/// that messages will be delivered out of order (which is also possible with
/// ordinary UDP).
virtual EResult SendMessageToFakeIP( const SteamNetworkingIPAddr &remoteAddress, const void *pData, uint32 cbData, int nSendFlags ) = 0;
/// Receive messages on the port.
///
/// Returns the number of messages returned into your array, up to nMaxMessages.
///
/// SteamNetworkingMessage_t::m_identity in the returned message(s) will always contain
/// a FakeIP. See ISteamNetworkingUtils::GetRealIdentityForFakeIP.
virtual int ReceiveMessages( SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0;
/// Schedule the internal connection for a given peer to be cleaned up in a few seconds.
///
/// Idle connections automatically time out, and so this is not strictly *necessary*,
/// but if you have reason to believe that you are done talking to a given peer for
/// a while, you can call this to speed up the timeout. If any remaining packets are
/// sent or received from the peer, the cleanup is canceled and the usual timeout
/// value is restored. Thus you will usually call this immediately after sending
/// or receiving application-layer "close connection" packets.
virtual void ScheduleCleanup( const SteamNetworkingIPAddr &remoteAddress ) = 0;
};
#define STEAMNETWORKINGFAKEUDPPORT_INTERFACE_VERSION "SteamNetworkingFakeUDPPort001" /* for proton codegen */
/// Callback struct used to notify when a connection has changed state
#if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 )
#else
#error "Must define VALVE_CALLBACK_PACK_SMALL or VALVE_CALLBACK_PACK_LARGE"
#endif
/// A struct used to describe a "fake IP" we have been assigned to
/// use as an identifier. This callback is posted when
/// ISteamNetworkingSoockets::BeginAsyncRequestFakeIP completes.
/// See also ISteamNetworkingSockets::GetFakeIP
struct SteamNetworkingFakeIPResult_t
{
enum { k_iCallback = k_iSteamNetworkingSocketsCallbacks + 3 };
/// Status/result of the allocation request. Possible failure values are:
/// - k_EResultBusy - you called GetFakeIP but the request has not completed.
/// - k_EResultInvalidParam - you called GetFakeIP with an invalid port index
/// - k_EResultLimitExceeded - You asked for too many ports, or made an
/// additional request after one had already succeeded
/// - k_EResultNoMatch - GetFakeIP was called, but no request has been made
///
/// Note that, with the exception of k_EResultBusy (if you are polling),
/// it is highly recommended to treat all failures as fatal.
EResult m_eResult;
/// Local identity of the ISteamNetworkingSockets object that made
/// this request and is assigned the IP. This is needed in the callback
/// in the case where there are multiple ISteamNetworkingSockets objects.
/// (E.g. one for the user, and another for the local gameserver).
SteamNetworkingIdentity m_identity;
/// Fake IPv4 IP address that we have been assigned. NOTE: this
/// IP address is not exclusively ours! Steam tries to avoid sharing
/// IP addresses, but this may not always be possible. The IP address
/// may be currently in use by another host, but with different port(s).
/// The exact same IP:port address may have been used previously.
/// Steam tries to avoid reusing ports until they have not been in use for
/// some time, but this may not always be possible.
uint32 m_unIP;
/// Port number(s) assigned to us. Only the first entries will contain
/// nonzero values. Entries corresponding to ports beyond what was
/// allocated for you will be zero.
///
/// (NOTE: At the time of this writing, the maximum number of ports you may
/// request is 4.)
enum { k_nMaxReturnPorts = 8 };
uint16 m_unPorts[k_nMaxReturnPorts];
};
#pragma pack( pop )
#endif // _H