From 1107fdb67b22e62b6860d45e2a7026e840191876 Mon Sep 17 00:00:00 2001 From: "alexey.lysiuk" Date: Mon, 11 May 2020 16:31:01 +0300 Subject: [PATCH] add sdl2_net 2.0.1 --- deps/sdl2/include/SDL2/SDL_net.h | 443 +++++++++++++++++++++++++++++++ deps/sdl2/lib/libSDL2_net.a | Bin 0 -> 20576 bytes 2 files changed, 443 insertions(+) create mode 100644 deps/sdl2/include/SDL2/SDL_net.h create mode 100644 deps/sdl2/lib/libSDL2_net.a diff --git a/deps/sdl2/include/SDL2/SDL_net.h b/deps/sdl2/include/SDL2/SDL_net.h new file mode 100644 index 00000000..bd5ec7f7 --- /dev/null +++ b/deps/sdl2/include/SDL2/SDL_net.h @@ -0,0 +1,443 @@ +/* + SDL_net: An example cross-platform network library for use with SDL + Copyright (C) 1997-2016 Sam Lantinga + Copyright (C) 2012 Simeon Maxein + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* $Id$ */ + +#ifndef _SDL_NET_H +#define _SDL_NET_H + +#ifdef WITHOUT_SDL +#include +typedef uint8_t Uint8; +typedef uint16_t Uint16; +typedef uint32_t Uint32; + +typedef struct SDLNet_version { + Uint8 major; + Uint8 minor; + Uint8 patch; +} SDLNet_version; + +#else /* WITHOUT_SDL */ + +#include "SDL.h" +#include "SDL_endian.h" +#include "SDL_version.h" + +typedef SDL_version SDLNet_version; + +#endif /* WITHOUT_SDL */ + +#include "begin_code.h" + +/* Set up for C function definitions, even when using C++ */ +#ifdef __cplusplus +extern "C" { +#endif + +/* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL +*/ +#define SDL_NET_MAJOR_VERSION 2 +#define SDL_NET_MINOR_VERSION 0 +#define SDL_NET_PATCHLEVEL 1 + +/* This macro can be used to fill a version structure with the compile-time + * version of the SDL_net library. + */ +#define SDL_NET_VERSION(X) \ +{ \ + (X)->major = SDL_NET_MAJOR_VERSION; \ + (X)->minor = SDL_NET_MINOR_VERSION; \ + (X)->patch = SDL_NET_PATCHLEVEL; \ +} + +/* This function gets the version of the dynamically linked SDL_net library. + it should NOT be used to fill a version structure, instead you should + use the SDL_NET_VERSION() macro. + */ +extern DECLSPEC const SDLNet_version * SDLCALL SDLNet_Linked_Version(void); + +/* Initialize/Cleanup the network API + SDL must be initialized before calls to functions in this library, + because this library uses utility functions from the SDL library. +*/ +extern DECLSPEC int SDLCALL SDLNet_Init(void); +extern DECLSPEC void SDLCALL SDLNet_Quit(void); + +/***********************************************************************/ +/* IPv4 hostname resolution API */ +/***********************************************************************/ + +typedef struct { + Uint32 host; /* 32-bit IPv4 host address */ + Uint16 port; /* 16-bit protocol port */ +} IPaddress; + +/* Resolve a host name and port to an IP address in network form. + If the function succeeds, it will return 0. + If the host couldn't be resolved, the host portion of the returned + address will be INADDR_NONE, and the function will return -1. + If 'host' is NULL, the resolved host will be set to INADDR_ANY. + */ +#ifndef INADDR_ANY +#define INADDR_ANY 0x00000000 +#endif +#ifndef INADDR_NONE +#define INADDR_NONE 0xFFFFFFFF +#endif +#ifndef INADDR_LOOPBACK +#define INADDR_LOOPBACK 0x7f000001 +#endif +#ifndef INADDR_BROADCAST +#define INADDR_BROADCAST 0xFFFFFFFF +#endif +extern DECLSPEC int SDLCALL SDLNet_ResolveHost(IPaddress *address, const char *host, Uint16 port); + +/* Resolve an ip address to a host name in canonical form. + If the ip couldn't be resolved, this function returns NULL, + otherwise a pointer to a static buffer containing the hostname + is returned. Note that this function is not thread-safe. +*/ +extern DECLSPEC const char * SDLCALL SDLNet_ResolveIP(const IPaddress *ip); + +/* Get the addresses of network interfaces on this system. + This returns the number of addresses saved in 'addresses' + */ +extern DECLSPEC int SDLCALL SDLNet_GetLocalAddresses(IPaddress *addresses, int maxcount); + +/***********************************************************************/ +/* TCP network API */ +/***********************************************************************/ + +typedef struct _TCPsocket *TCPsocket; + +/* Open a TCP network socket + If ip.host is INADDR_NONE or INADDR_ANY, this creates a local server + socket on the given port, otherwise a TCP connection to the remote + host and port is attempted. The address passed in should already be + swapped to network byte order (addresses returned from + SDLNet_ResolveHost() are already in the correct form). + The newly created socket is returned, or NULL if there was an error. +*/ +extern DECLSPEC TCPsocket SDLCALL SDLNet_TCP_Open(IPaddress *ip); + +/* Accept an incoming connection on the given server socket. + The newly created socket is returned, or NULL if there was an error. +*/ +extern DECLSPEC TCPsocket SDLCALL SDLNet_TCP_Accept(TCPsocket server); + +/* Get the IP address of the remote system associated with the socket. + If the socket is a server socket, this function returns NULL. +*/ +extern DECLSPEC IPaddress * SDLCALL SDLNet_TCP_GetPeerAddress(TCPsocket sock); + +/* Send 'len' bytes of 'data' over the non-server socket 'sock' + This function returns the actual amount of data sent. If the return value + is less than the amount of data sent, then either the remote connection was + closed, or an unknown socket error occurred. +*/ +extern DECLSPEC int SDLCALL SDLNet_TCP_Send(TCPsocket sock, const void *data, + int len); + +/* Receive up to 'maxlen' bytes of data over the non-server socket 'sock', + and store them in the buffer pointed to by 'data'. + This function returns the actual amount of data received. If the return + value is less than or equal to zero, then either the remote connection was + closed, or an unknown socket error occurred. +*/ +extern DECLSPEC int SDLCALL SDLNet_TCP_Recv(TCPsocket sock, void *data, int maxlen); + +/* Close a TCP network socket */ +extern DECLSPEC void SDLCALL SDLNet_TCP_Close(TCPsocket sock); + + +/***********************************************************************/ +/* UDP network API */ +/***********************************************************************/ + +/* The maximum channels on a a UDP socket */ +#define SDLNET_MAX_UDPCHANNELS 32 +/* The maximum addresses bound to a single UDP socket channel */ +#define SDLNET_MAX_UDPADDRESSES 4 + +typedef struct _UDPsocket *UDPsocket; +typedef struct { + int channel; /* The src/dst channel of the packet */ + Uint8 *data; /* The packet data */ + int len; /* The length of the packet data */ + int maxlen; /* The size of the data buffer */ + int status; /* packet status after sending */ + IPaddress address; /* The source/dest address of an incoming/outgoing packet */ +} UDPpacket; + +/* Allocate/resize/free a single UDP packet 'size' bytes long. + The new packet is returned, or NULL if the function ran out of memory. + */ +extern DECLSPEC UDPpacket * SDLCALL SDLNet_AllocPacket(int size); +extern DECLSPEC int SDLCALL SDLNet_ResizePacket(UDPpacket *packet, int newsize); +extern DECLSPEC void SDLCALL SDLNet_FreePacket(UDPpacket *packet); + +/* Allocate/Free a UDP packet vector (array of packets) of 'howmany' packets, + each 'size' bytes long. + A pointer to the first packet in the array is returned, or NULL if the + function ran out of memory. + */ +extern DECLSPEC UDPpacket ** SDLCALL SDLNet_AllocPacketV(int howmany, int size); +extern DECLSPEC void SDLCALL SDLNet_FreePacketV(UDPpacket **packetV); + + +/* Open a UDP network socket + If 'port' is non-zero, the UDP socket is bound to a local port. + The 'port' should be given in native byte order, but is used + internally in network (big endian) byte order, in addresses, etc. + This allows other systems to send to this socket via a known port. +*/ +extern DECLSPEC UDPsocket SDLCALL SDLNet_UDP_Open(Uint16 port); + +/* Set the percentage of simulated packet loss for packets sent on the socket. +*/ +extern DECLSPEC void SDLCALL SDLNet_UDP_SetPacketLoss(UDPsocket sock, int percent); + +/* Bind the address 'address' to the requested channel on the UDP socket. + If the channel is -1, then the first unbound channel that has not yet + been bound to the maximum number of addresses will be bound with + the given address as it's primary address. + If the channel is already bound, this new address will be added to the + list of valid source addresses for packets arriving on the channel. + If the channel is not already bound, then the address becomes the primary + address, to which all outbound packets on the channel are sent. + This function returns the channel which was bound, or -1 on error. +*/ +extern DECLSPEC int SDLCALL SDLNet_UDP_Bind(UDPsocket sock, int channel, const IPaddress *address); + +/* Unbind all addresses from the given channel */ +extern DECLSPEC void SDLCALL SDLNet_UDP_Unbind(UDPsocket sock, int channel); + +/* Get the primary IP address of the remote system associated with the + socket and channel. If the channel is -1, then the primary IP port + of the UDP socket is returned -- this is only meaningful for sockets + opened with a specific port. + If the channel is not bound and not -1, this function returns NULL. + */ +extern DECLSPEC IPaddress * SDLCALL SDLNet_UDP_GetPeerAddress(UDPsocket sock, int channel); + +/* Send a vector of packets to the the channels specified within the packet. + If the channel specified in the packet is -1, the packet will be sent to + the address in the 'src' member of the packet. + Each packet will be updated with the status of the packet after it has + been sent, -1 if the packet send failed. + This function returns the number of packets sent. +*/ +extern DECLSPEC int SDLCALL SDLNet_UDP_SendV(UDPsocket sock, UDPpacket **packets, int npackets); + +/* Send a single packet to the specified channel. + If the channel specified in the packet is -1, the packet will be sent to + the address in the 'src' member of the packet. + The packet will be updated with the status of the packet after it has + been sent. + This function returns 1 if the packet was sent, or 0 on error. + + NOTE: + The maximum size of the packet is limited by the MTU (Maximum Transfer Unit) + of the transport medium. It can be as low as 250 bytes for some PPP links, + and as high as 1500 bytes for ethernet. +*/ +extern DECLSPEC int SDLCALL SDLNet_UDP_Send(UDPsocket sock, int channel, UDPpacket *packet); + +/* Receive a vector of pending packets from the UDP socket. + The returned packets contain the source address and the channel they arrived + on. If they did not arrive on a bound channel, the the channel will be set + to -1. + The channels are checked in highest to lowest order, so if an address is + bound to multiple channels, the highest channel with the source address + bound will be returned. + This function returns the number of packets read from the network, or -1 + on error. This function does not block, so can return 0 packets pending. +*/ +extern DECLSPEC int SDLCALL SDLNet_UDP_RecvV(UDPsocket sock, UDPpacket **packets); + +/* Receive a single packet from the UDP socket. + The returned packet contains the source address and the channel it arrived + on. If it did not arrive on a bound channel, the the channel will be set + to -1. + The channels are checked in highest to lowest order, so if an address is + bound to multiple channels, the highest channel with the source address + bound will be returned. + This function returns the number of packets read from the network, or -1 + on error. This function does not block, so can return 0 packets pending. +*/ +extern DECLSPEC int SDLCALL SDLNet_UDP_Recv(UDPsocket sock, UDPpacket *packet); + +/* Close a UDP network socket */ +extern DECLSPEC void SDLCALL SDLNet_UDP_Close(UDPsocket sock); + + +/***********************************************************************/ +/* Hooks for checking sockets for available data */ +/***********************************************************************/ + +typedef struct _SDLNet_SocketSet *SDLNet_SocketSet; + +/* Any network socket can be safely cast to this socket type */ +typedef struct _SDLNet_GenericSocket { + int ready; +} *SDLNet_GenericSocket; + +/* Allocate a socket set for use with SDLNet_CheckSockets() + This returns a socket set for up to 'maxsockets' sockets, or NULL if + the function ran out of memory. + */ +extern DECLSPEC SDLNet_SocketSet SDLCALL SDLNet_AllocSocketSet(int maxsockets); + +/* Add a socket to a set of sockets to be checked for available data */ +extern DECLSPEC int SDLCALL SDLNet_AddSocket(SDLNet_SocketSet set, SDLNet_GenericSocket sock); +SDL_FORCE_INLINE int SDLNet_TCP_AddSocket(SDLNet_SocketSet set, TCPsocket sock) +{ + return SDLNet_AddSocket(set, (SDLNet_GenericSocket)sock); +} +SDL_FORCE_INLINE int SDLNet_UDP_AddSocket(SDLNet_SocketSet set, UDPsocket sock) +{ + return SDLNet_AddSocket(set, (SDLNet_GenericSocket)sock); +} + + +/* Remove a socket from a set of sockets to be checked for available data */ +extern DECLSPEC int SDLCALL SDLNet_DelSocket(SDLNet_SocketSet set, SDLNet_GenericSocket sock); +SDL_FORCE_INLINE int SDLNet_TCP_DelSocket(SDLNet_SocketSet set, TCPsocket sock) +{ + return SDLNet_DelSocket(set, (SDLNet_GenericSocket)sock); +} +SDL_FORCE_INLINE int SDLNet_UDP_DelSocket(SDLNet_SocketSet set, UDPsocket sock) +{ + return SDLNet_DelSocket(set, (SDLNet_GenericSocket)sock); +} + +/* This function checks to see if data is available for reading on the + given set of sockets. If 'timeout' is 0, it performs a quick poll, + otherwise the function returns when either data is available for + reading, or the timeout in milliseconds has elapsed, which ever occurs + first. This function returns the number of sockets ready for reading, + or -1 if there was an error with the select() system call. +*/ +extern DECLSPEC int SDLCALL SDLNet_CheckSockets(SDLNet_SocketSet set, Uint32 timeout); + +/* After calling SDLNet_CheckSockets(), you can use this function on a + socket that was in the socket set, to find out if data is available + for reading. +*/ +#define SDLNet_SocketReady(sock) _SDLNet_SocketReady((SDLNet_GenericSocket)(sock)) +SDL_FORCE_INLINE int _SDLNet_SocketReady(SDLNet_GenericSocket sock) +{ + return (sock != NULL) && (sock->ready); +} + +/* Free a set of sockets allocated by SDL_NetAllocSocketSet() */ +extern DECLSPEC void SDLCALL SDLNet_FreeSocketSet(SDLNet_SocketSet set); + +/***********************************************************************/ +/* Error reporting functions */ +/***********************************************************************/ + +extern DECLSPEC void SDLCALL SDLNet_SetError(const char *fmt, ...); +extern DECLSPEC const char * SDLCALL SDLNet_GetError(void); + +/***********************************************************************/ +/* Inline functions to read/write network data */ +/***********************************************************************/ + +/* Warning, some systems have data access alignment restrictions */ +#if defined(sparc) || defined(mips) || defined(__arm__) +#define SDL_DATA_ALIGNED 1 +#endif +#ifndef SDL_DATA_ALIGNED +#define SDL_DATA_ALIGNED 0 +#endif + +/* Write a 16/32-bit value to network packet buffer */ +#define SDLNet_Write16(value, areap) _SDLNet_Write16(value, areap) +#define SDLNet_Write32(value, areap) _SDLNet_Write32(value, areap) + +/* Read a 16/32-bit value from network packet buffer */ +#define SDLNet_Read16(areap) _SDLNet_Read16(areap) +#define SDLNet_Read32(areap) _SDLNet_Read32(areap) + +#if !defined(WITHOUT_SDL) && !SDL_DATA_ALIGNED + +SDL_FORCE_INLINE void _SDLNet_Write16(Uint16 value, void *areap) +{ + *(Uint16 *)areap = SDL_SwapBE16(value); +} + +SDL_FORCE_INLINE void _SDLNet_Write32(Uint32 value, void *areap) +{ + *(Uint32 *)areap = SDL_SwapBE32(value); +} + +SDL_FORCE_INLINE Uint16 _SDLNet_Read16(const void *areap) +{ + return SDL_SwapBE16(*(const Uint16 *)areap); +} + +SDL_FORCE_INLINE Uint32 _SDLNet_Read32(const void *areap) +{ + return SDL_SwapBE32(*(const Uint32 *)areap); +} + +#else /* !defined(WITHOUT_SDL) && !SDL_DATA_ALIGNED */ + +SDL_FORCE_INLINE void _SDLNet_Write16(Uint16 value, void *areap) +{ + Uint8 *area = (Uint8*)areap; + area[0] = (value >> 8) & 0xFF; + area[1] = value & 0xFF; +} + +SDL_FORCE_INLINE void _SDLNet_Write32(Uint32 value, void *areap) +{ + Uint8 *area = (Uint8*)areap; + area[0] = (value >> 24) & 0xFF; + area[1] = (value >> 16) & 0xFF; + area[2] = (value >> 8) & 0xFF; + area[3] = value & 0xFF; +} + +SDL_FORCE_INLINE Uint16 _SDLNet_Read16(void *areap) +{ + Uint8 *area = (Uint8*)areap; + return ((Uint16)area[0]) << 8 | ((Uint16)area[1]); +} + +SDL_FORCE_INLINE Uint32 _SDLNet_Read32(const void *areap) +{ + const Uint8 *area = (const Uint8*)areap; + return ((Uint32)area[0]) << 24 | ((Uint32)area[1]) << 16 | ((Uint32)area[2]) << 8 | ((Uint32)area[3]); +} + +#endif /* !defined(WITHOUT_SDL) && !SDL_DATA_ALIGNED */ + +/* Ends C function definitions when using C++ */ +#ifdef __cplusplus +} +#endif +#include "close_code.h" + +#endif /* _SDL_NET_H */ diff --git a/deps/sdl2/lib/libSDL2_net.a b/deps/sdl2/lib/libSDL2_net.a new file mode 100644 index 0000000000000000000000000000000000000000..a867ad2dc89199ce549e1a6a2f38b2237f392d60 GIT binary patch literal 20576 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 literal 0 HcmV?d00001