Static Public Member Functions
static bool	AcceptP2PSessionWithUser (CSteamID steamIDRemote)

static bool	AllowP2PPacketRelay (bool bAllow)

static bool	CloseP2PChannelWithUser (CSteamID steamIDRemote, int nChannel)

static bool	CloseP2PSessionWithUser (CSteamID steamIDRemote)

static SNetSocket_t	CreateConnectionSocket (uint nIP, ushort nPort, int nTimeoutSec)

static SNetListenSocket_t	CreateListenSocket (int nVirtualP2PPort, uint nIP, ushort nPort, bool bAllowUseOfPacketRelay)

static SNetSocket_t	CreateP2PConnectionSocket (CSteamID steamIDTarget, int nVirtualPort, int nTimeoutSec, bool bAllowUseOfPacketRelay)

static bool	DestroyListenSocket (SNetListenSocket_t hSocket, bool bNotifyRemoteEnd)

static bool	DestroySocket (SNetSocket_t hSocket, bool bNotifyRemoteEnd)

static bool	GetListenSocketInfo (SNetListenSocket_t hListenSocket, out uint pnIP, out ushort pnPort)

static int	GetMaxPacketSize (SNetSocket_t hSocket)

static bool	GetP2PSessionState (CSteamID steamIDRemote, out P2PSessionState_t pConnectionState)

static ESNetSocketConnectionType	GetSocketConnectionType (SNetSocket_t hSocket)

static bool	GetSocketInfo (SNetSocket_t hSocket, out CSteamID pSteamIDRemote, out int peSocketStatus, out uint punIPRemote, out ushort punPortRemote)

static bool	IsDataAvailable (SNetListenSocket_t hListenSocket, out uint pcubMsgSize, out SNetSocket_t phSocket)

static bool	IsDataAvailableOnSocket (SNetSocket_t hSocket, out uint pcubMsgSize)

static bool	IsP2PPacketAvailable (out uint pcubMsgSize, int nChannel=0)

static bool	ReadP2PPacket (byte[] pubDest, uint cubDest, out uint pcubMsgSize, out CSteamID psteamIDRemote, int nChannel=0)

static bool	RetrieveData (SNetListenSocket_t hListenSocket, byte[] pubDest, uint cubDest, out uint pcubMsgSize, out SNetSocket_t phSocket)

static bool	RetrieveDataFromSocket (SNetSocket_t hSocket, byte[] pubDest, uint cubDest, out uint pcubMsgSize)

static bool	SendDataOnSocket (SNetSocket_t hSocket, byte[] pubData, uint cubData, bool bReliable)

static bool	SendP2PPacket (CSteamID steamIDRemote, byte[] pubData, uint cubData, EP2PSend eP2PSendType, int nChannel=0)

Member Function Documentation

static bool Steamworks.SteamNetworking.AcceptP2PSessionWithUser ( CSteamID steamIDRemote )

inlinestatic

AcceptP2PSessionWithUser() should only be called in response to a P2PSessionRequest_t callback

P2PSessionRequest_t will be posted if another user tries to send you a packet that you haven't talked to yet

if you don't want to talk to the user, just ignore the request

if the user continues to send you packets, another P2PSessionRequest_t will be posted periodically

this may be called multiple times for a single user

(if you've called SendP2PPacket() on the other user, this implicitly accepts the session request)

static bool Steamworks.SteamNetworking.AllowP2PPacketRelay ( bool bAllow )

inlinestatic

Allow P2P connections to fall back to being relayed through the Steam servers if a direct connection

or NAT-traversal cannot be established. Only applies to connections created after setting this value,

or to existing connections that need to automatically reconnect after this value is set.

P2P packet relay is allowed by default

static bool Steamworks.SteamNetworking.CloseP2PChannelWithUser	(	CSteamID	steamIDRemote,
		int	nChannel
	)

inlinestatic

call CloseP2PChannelWithUser() when you're done talking to a user on a specific channel. Once all channels

open channels to a user have been closed, the open session to the user will be closed and new data from this

user will trigger a P2PSessionRequest_t callback

static bool Steamworks.SteamNetworking.CloseP2PSessionWithUser ( CSteamID steamIDRemote )

inlinestatic

call CloseP2PSessionWithUser() when you're done talking to a user, will free up resources under-the-hood

if the remote user tries to send data to you again, another P2PSessionRequest_t callback will be posted

static SNetSocket_t Steamworks.SteamNetworking.CreateConnectionSocket	(	uint	nIP,
		ushort	nPort,
		int	nTimeoutSec
	)

inlinestatic

static SNetListenSocket_t Steamworks.SteamNetworking.CreateListenSocket	(	int	nVirtualP2PPort,
		uint	nIP,
		ushort	nPort,
		bool	bAllowUseOfPacketRelay
	)

inlinestatic

//////////////////////////////////////////////////////////////////////////////////////////

LISTEN / CONNECT style interface functions

This is an older set of functions designed around the Berkeley TCP sockets model

it's preferential that you use the above P2P functions, they're more robust

and these older functions will be removed eventually

//////////////////////////////////////////////////////////////////////////////////////////

creates a socket and listens others to connect

will trigger a SocketStatusCallback_t callback on another client connecting

nVirtualP2PPort is the unique ID that the client will connect to, in case you have multiple ports

this can usually just be 0 unless you want multiple sets of connections

unIP is the local IP address to bind to

pass in 0 if you just want the default local IP

unPort is the port to use

pass in 0 if you don't want users to be able to connect via IP/Port, but expect to be always peer-to-peer connections only

static SNetSocket_t Steamworks.SteamNetworking.CreateP2PConnectionSocket	(	CSteamID	steamIDTarget,
		int	nVirtualPort,
		int	nTimeoutSec,
		bool	bAllowUseOfPacketRelay
	)

inlinestatic

creates a socket and begin connection to a remote destination

can connect via a known steamID (client or game server), or directly to an IP

on success will trigger a SocketStatusCallback_t callback

on failure or timeout will trigger a SocketStatusCallback_t callback with a failure code in m_eSNetSocketState

static bool Steamworks.SteamNetworking.DestroyListenSocket	(	SNetListenSocket_t	hSocket,
		bool	bNotifyRemoteEnd
	)

inlinestatic

destroying a listen socket will automatically kill all the regular sockets generated from it

static bool Steamworks.SteamNetworking.DestroySocket	(	SNetSocket_t	hSocket,
		bool	bNotifyRemoteEnd
	)

inlinestatic

disconnects the connection to the socket, if any, and invalidates the handle

any unread data on the socket will be thrown away

if bNotifyRemoteEnd is set, socket will not be completely destroyed until the remote end acknowledges the disconnect

static bool Steamworks.SteamNetworking.GetListenSocketInfo	(	SNetListenSocket_t	hListenSocket,
		out uint	pnIP,
		out ushort	pnPort
	)

inlinestatic

returns which local port the listen socket is bound to

*pnIP and *pnPort will be 0 if the socket is set to listen for P2P connections only

static int Steamworks.SteamNetworking.GetMaxPacketSize ( SNetSocket_t hSocket )

inlinestatic

max packet size, in bytes

static bool Steamworks.SteamNetworking.GetP2PSessionState	(	CSteamID	steamIDRemote,
		out P2PSessionState_t	pConnectionState
	)

inlinestatic

fills out P2PSessionState_t structure with details about the underlying connection to the user

should only needed for debugging purposes

returns false if no connection exists to the specified user

static ESNetSocketConnectionType Steamworks.SteamNetworking.GetSocketConnectionType ( SNetSocket_t hSocket )

inlinestatic

returns true to describe how the socket ended up connecting

static bool Steamworks.SteamNetworking.GetSocketInfo	(	SNetSocket_t	hSocket,
		out CSteamID	pSteamIDRemote,
		out int	peSocketStatus,
		out uint	punIPRemote,
		out ushort	punPortRemote
	)

inlinestatic

returns information about the specified socket, filling out the contents of the pointers

static bool Steamworks.SteamNetworking.IsDataAvailable	(	SNetListenSocket_t	hListenSocket,
		out uint	pcubMsgSize,
		out SNetSocket_t	phSocket
	)

inlinestatic

checks for data from any socket that has been connected off this listen socket

returns false if there is no data remaining

fills out *pcubMsgSize with the size of the next message, in bytes

fills out *phSocket with the socket that data is available on

static bool Steamworks.SteamNetworking.IsDataAvailableOnSocket	(	SNetSocket_t	hSocket,
		out uint	pcubMsgSize
	)

inlinestatic

receiving data

returns false if there is no data remaining

fills out *pcubMsgSize with the size of the next message, in bytes

static bool Steamworks.SteamNetworking.IsP2PPacketAvailable	(	out uint	pcubMsgSize,
		int	nChannel = `0`
	)

inlinestatic

returns true if any data is available for read, and the amount of data that will need to be read

static bool Steamworks.SteamNetworking.ReadP2PPacket	(	byte[]	pubDest,
		uint	cubDest,
		out uint	pcubMsgSize,
		out CSteamID	psteamIDRemote,
		int	nChannel = `0`
	)

inlinestatic

reads in a packet that has been sent from another user via SendP2PPacket()

returns the size of the message and the steamID of the user who sent it in the last two parameters

if the buffer passed in is too small, the message will be truncated

this call is not blocking, and will return false if no data is available

static bool Steamworks.SteamNetworking.RetrieveData	(	SNetListenSocket_t	hListenSocket,
		byte[]	pubDest,
		uint	cubDest,
		out uint	pcubMsgSize,
		out SNetSocket_t	phSocket
	)

inlinestatic

retrieves data from any socket that has been connected off this listen socket

fills in pubDest with the contents of the message

messages are always complete, of the same size as was sent (i.e. packetized, not streaming)

if *pcubMsgSize < cubDest, only partial data is written

returns false if no data is available

fills out *phSocket with the socket that data is available on

static bool Steamworks.SteamNetworking.RetrieveDataFromSocket	(	SNetSocket_t	hSocket,
		byte[]	pubDest,
		uint	cubDest,
		out uint	pcubMsgSize
	)

inlinestatic

fills in pubDest with the contents of the message

messages are always complete, of the same size as was sent (i.e. packetized, not streaming)

if *pcubMsgSize < cubDest, only partial data is written

returns false if no data is available

static bool Steamworks.SteamNetworking.SendDataOnSocket	(	SNetSocket_t	hSocket,
		byte[]	pubData,
		uint	cubData,
		bool	bReliable
	)

inlinestatic

sending data

must be a handle to a connected socket

data is all sent via UDP, and thus send sizes are limited to 1200 bytes; after this, many routers will start dropping packets

use the reliable flag with caution; although the resend rate is pretty aggressive,

it can still cause stalls in receiving data (like TCP)

static bool Steamworks.SteamNetworking.SendP2PPacket	(	CSteamID	steamIDRemote,
		byte[]	pubData,
		uint	cubData,
		EP2PSend	eP2PSendType,
		int	nChannel = `0`
	)

inlinestatic

//////////////////////////////////////////////////////////////////////////////////////////

Session-less connection functions

automatically establishes NAT-traversing or Relay server connections

Sends a P2P packet to the specified user

UDP-like, unreliable and a max packet size of 1200 bytes

the first packet send may be delayed as the NAT-traversal code runs

if we can't get through to the user, an error will be posted via the callback P2PSessionConnectFail_t

see EP2PSend enum above for the descriptions of the different ways of sending packets

nChannel is a routing number you can use to help route message to different systems - you'll have to call ReadP2PPacket()

with the same channel number in order to retrieve the data on the other end

using different channels to talk to the same user will still use the same underlying p2p connection, saving on resources

The documentation for this class was generated from the following file:

KSP/Assets/Plugins/Steamworks.NET/autogen/isteamnetworking.cs

Static Public Member Functions

Member Function Documentation