Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-04-28 21:57:57 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
openmohaa/code/gamespy/common/gsPlatformSocket.h

655 lines
24 KiB
C
Raw Normal View History

Added gamespy SDK
2023-02-04 21:00:01 +01:00
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifndef __GSSOCKET_H__
#define __GSSOCKET_H__
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#include "gsPlatform.h"
#ifdef __cplusplus
extern "C" {
#endif
// GSI Cross Platform Socket Wrapper
// this should all inline and optimize out... I hope
// if they somehow get really complex, we need to move the implementation into the .c file.
#if defined _PS3 || defined _PSP
#define gsiSocketIsError(theReturnValue) ((theReturnValue) < 0)
#define gsiSocketIsNotError(theReturnValue) ((theReturnValue) >= 0)
#else
#define gsiSocketIsError(theReturnValue) ((theReturnValue) == -1)
#define gsiSocketIsNotError(theReturnValue) ((theReturnValue) != -1)
#endif
#if (0)
// to do for Saad and Martin, move towards this and phase out the #define jungle.
// we will trade a little speed for a lot of portability, and stability
// also out debug libs will assert all params comming in.
typedef enum
{
GS_SOCKERR_NONE = 0,
GS_SOCKERR_EWOULDBLOCK,
GS_SOCKERR_EINPROGRESS,
GS_SOCKERR_EALREADY,
GS_SOCKERR_ENOTSOCK,
GS_SOCKERR_EDESTADDRREQ,
GS_SOCKERR_EMSGSIZE,
GS_SOCKERR_EPROTOTYPE,
GS_SOCKERR_ENOPROTOOPT ,
GS_SOCKERR_EPROTONOSUPPORT ,
GS_SOCKERR_ESOCKTNOSUPPORT,
GS_SOCKERR_EOPNOTSUPP ,
GS_SOCKERR_EPFNOSUPPORT,
GS_SOCKERR_EAFNOSUPPORT,
GS_SOCKERR_EADDRINUSE ,
GS_SOCKERR_EADDRNOTAVAIL ,
GS_SOCKERR_ENETDOWN ,
GS_SOCKERR_ENETUNREACH ,
GS_SOCKERR_ENETRESET,
GS_SOCKERR_ECONNABORTED,
GS_SOCKERR_ECONNRESET ,
GS_SOCKERR_ENOBUFS ,
GS_SOCKERR_EISCONN ,
GS_SOCKERR_ENOTCONN,
GS_SOCKERR_ESHUTDOWN,
GS_SOCKERR_ETOOMANYREFS ,
GS_SOCKERR_ETIMEDOUT,
GS_SOCKERR_ECONNREFUSED,
GS_SOCKERR_ELOOP,
GS_SOCKERR_ENAMETOOLONG,
GS_SOCKERR_EHOSTDOWN ,
GS_SOCKERR_EHOSTUNREACH ,
GS_SOCKERR_ENOTEMPTY ,
GS_SOCKERR_EPROCLIM ,
GS_SOCKERR_EUSERS ,
GS_SOCKERR_EDQUOT ,
GS_SOCKERR_ESTALE ,
GS_SOCKERR_EREMOTE ,
GS_SOCKERR_EINVAL ,
GS_SOCKERR_COUNT ,
} GS_SOCKET_ERROR;
#define gsiSocketIsError(theReturnValue) ((theReturnValue) != GS_SOCKERR_NONE)
#define gsiSocketIsNotError(theReturnValue) ((theReturnValue) == GS_SOCKERR_NONE)
typedef int GSI_SOCKET;
// mj - may need to pragma pack this, otherwise, it will pad after u_short
typedef struct
{
// this is the same as the "default" winsocks
u_short sa_family; /* address family */
char sa_data[14]; /* up to 14 bytes of direct address */
} GS_SOCKADDR;
GSI_SOCKET gsiSocketAccept (GSI_SOCKET sock, GS_SOCKADDR* addr, int* len);
GS_SOCKET_ERROR gsiSocketSocket (int pf, int type, int protocol);
GS_SOCKET_ERROR gsiSocketClosesocket(GSI_SOCKET sock);
GS_SOCKET_ERROR gsiSocketShutdown (GSI_SOCKET sock, int how);
GS_SOCKET_ERROR gsiSocketBind (GSI_SOCKET sock, const GS_SOCKADDR* addr, int len);
GS_SOCKET_ERROR gsiSocketConnect (GSI_SOCKET sock, const GS_SOCKADDR* addr, int len);
GS_SOCKET_ERROR gsiSocketListen (GSI_SOCKET sock, int backlog);
GS_SOCKET_ERROR gsiSocketRecv (GSI_SOCKET sock, char* buf, int len, int flags);
GS_SOCKET_ERROR gsiSocketRecvfrom (GSI_SOCKET sock, char* buf, int len, int flags, GS_SOCKADDR* addr, int* fromlen);
GS_SOCKET_ERROR gsiSocketSend (GSI_SOCKET sock, const char* buf, int len, int flags);
GS_SOCKET_ERROR gsiSocketSendto (GSI_SOCKET sock, const char* buf, int len, int flags, const GS_SOCKADDR* addr, int tolen);
GS_SOCKET_ERROR gsiSocketGetsockopt (GSI_SOCKET sock, int level, int optname, char* optval, int* optlen);
GS_SOCKET_ERROR gsiSocketSetsockopt (GSI_SOCKET sock, int level, int optname, const char* optval, int optlen);
GS_SOCKET_ERROR gsiSocketGetsockname(GSI_SOCKET sock, GS_SOCKADDR* addr, int* len);
GS_SOCKET_ERROR GOAGetLastError (GSI_SOCKET sock);
gsiSocketGethostbyaddr(a,l,t) SOC_GetHostByAddr(a,l,t)
gsiSocketGethostbyname(n) SOC_GetHostByName(n)
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Types
#ifndef INADDR_NONE
#define INADDR_NONE 0xffffffff
#endif
#ifndef INVALID_SOCKET
#define INVALID_SOCKET (-1)
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Platform socket types
#if defined(_PSP)
#define AF_INET SCE_NET_INET_AF_INET
#define SOCK_STREAM SCE_NET_INET_SOCK_STREAM
#define SOCK_DGRAM SCE_NET_INET_SOCK_DGRAM
#define SOCK_RAW SCE_NET_INET_SOCK_RAW
#define INADDR_ANY SCE_NET_INET_INADDR_ANY
#define SOL_SOCKET SCE_NET_INET_SOL_SOCKET
#define SO_SNDBUF SCE_NET_INET_SO_SNDBUF
#define SO_RCVBUF SCE_NET_INET_SO_RCVBUF
#define SO_NBIO SCE_NET_INET_SO_NBIO
#define SO_BROADCAST SCE_NET_INET_SO_BROADCAST
#define SO_KEEPALIVE SCE_NET_INET_SO_KEEPALIVE
#define SO_REUSEADDR SCE_NET_INET_SO_REUSEADDR
#define IPPROTO_TCP SCE_NET_INET_IPPROTO_TCP // protocol defined by SOCK_STREAM
#define IPPROTO_UDP SCE_NET_INET_IPPROTO_UDP // protocol defined by SOCK_DGRAM
#define IPPROTO_ICMP SCE_NET_INET_IPPROTO_ICMP // protocol for ICMP pings
// structures
#define in_addr SceNetInetInAddr
#define sockaddr_in SceNetInetSockaddrIn
#define sockaddr SceNetInetSockaddr
// Remove FD types set in sys/types.h
// Replace with types in pspnet/sys/select.h
#if defined(_SYS_TYPES_H) && defined(FD_SET)
#undef fd_set
#undef FD_SET
#undef FD_CLR
#undef FD_ZERO
#undef timeval
#undef FD_SETSIZE
#endif
#define fd_set SceNetInetFdSet
#define timeval SceNetInetTimeval
#define FD_SET SceNetInetFD_SET
#define FD_CLR SceNetInetFD_CLR
#define FD_ZERO SceNetInetFD_ZERO
#define FD_SETSIZE SCE_NET_INET_FD_SETSIZE
// functions
#define htonl sceNetHtonl
#define ntohl sceNetNtohl
#define htons sceNetHtons
#define ntohs sceNetNtohs
#define socket sceNetInetSocket
#define shutdown sceNetInetShutdown
#define closesocket sceNetInetClose
#define setsockopt sceNetInetSetsockopt
#define getsockopt(s, l, on, ov, ol) sceNetInetGetsockopt(s, l, on, ov, (SceNetInetSocklen_t *)ol)
#define bind sceNetInetBind
#define select sceNetInetSelect
#define connect sceNetInetConnect
#define listen sceNetInetListen
#define accept(s,a,l) sceNetInetAccept(s, a, (SceNetInetSocklen_t *)l)
#define send sceNetInetSend
#define recv sceNetInetRecv
#define sendto sceNetInetSendto
#define recvfrom(s, b, l, f, fr, fl) sceNetInetRecvfrom(s, b, l, f, fr, (SceNetInetSocklen_t *)fl)
#define inet_addr sceNetInetInetAddr
// This is not the correct function for gethostname, it should get the string name of the local host
// not the sockaddr_in struct
#define gethostname // sceNetInetGetsockname
#define getsockname(s,n,l) sceNetInetGetsockname(s, n, (SceNetInetSocklen_t *)l)
#define GOAGetLastError(s) sceNetInetGetErrno()
// hostent support
struct hostent
{
char* h_name;
char** h_aliases;
gsi_u16 h_addrtype; // AF_INET
gsi_u16 h_length;
char** h_addr_list;
};
#define gethostbyname gsSocketGetHostByName
#define inet_ntoa gsSocketInetNtoa
#define GSI_RESOLVER_TIMEOUT (5*1000*1000) // 5 seconds
#define GSI_RESOLVER_RETRY (2)
struct hostent* gsSocketGetHostByName(const char* name); // gsSocketPSP.c
const char* gsSocketInetNtoa(struct in_addr in);
#endif // _PSP
// XBOX doesn't have host lookup
#if defined(_XBOX)
#if defined(_X360)
// hostent support
struct hostent
{
char* h_name;
char** h_aliases;
gsi_u16 h_addrtype; // AF_INET
gsi_u16 h_length;
char** h_addr_list;
};
typedef struct hostent HOSTENT;
struct hostent * gethostbyname(const char* name);
#else
typedef int HOSTENT;
#endif
char * inet_ntoa(IN_ADDR in_addr);
#endif
#if defined(SN_SYSTEMS)
#define IPPROTO_TCP PF_INET
#define IPPROTO_UDP PF_INET
#define FD_SETSIZE SN_MAX_SOCKETS
#endif
// SOCKET ERROR CODES
#if defined(_REVOLUTION) //not sure if Wii uses this or _REV
#define WSAEWOULDBLOCK SO_EWOULDBLOCK
#define WSAEINPROGRESS SO_EINPROGRESS
#define WSAEALREADY SO_EALREADY
#define WSAENOTSOCK SO_ENOTSOCK
#define WSAEDESTADDRREQ SO_EDESTADDRREQ
#define WSAEMSGSIZE SO_EMSGSIZE
#define WSAEPROTOTYPE SO_EPROTOTYPE
#define WSAENOPROTOOPT SO_ENOPROTOOPT
#define WSAEPROTONOSUPPORT SO_EPROTONOSUPPORT
#define WSAEOPNOTSUPP SO_EOPNOTSUPP
#define WSAEAFNOSUPPORT SO_EAFNOSUPPORT
#define WSAEADDRINUSE SO_EADDRINUSE
#define WSAEADDRNOTAVAIL SO_EADDRNOTAVAIL
#define WSAENETDOWN SO_ENETDOWN
#define WSAENETUNREACH SO_ENETUNREACH
#define WSAENETRESET SO_ENETRESET
#define WSAECONNABORTED SO_ECONNABORTED
#define WSAECONNRESET SO_ECONNRESET
#define WSAENOBUFS SO_ENOBUFS
#define WSAEISCONN SO_EISCONN
#define WSAENOTCONN SO_ENOTCONN
#define WSAETIMEDOUT SO_ETIMEDOUT
#define WSAECONNREFUSED SO_ECONNREFUSED
#define WSAELOOP SO_ELOOP
#define WSAENAMETOOLONG SO_ENAMETOOLONG
#define WSAEHOSTUNREACH SO_EHOSTUNREACH
#define WSAENOTEMPTY SO_ENOTEMPTY
#define WSAEDQUOT SO_EDQUOT
#define WSAESTALE SO_ESTALE
#define WSAEINVAL SO_EINVAL
#elif defined(_NITRO)
#define WSAEWOULDBLOCK SOC_EWOULDBLOCK
#define WSAEINPROGRESS SOC_EINPROGRESS
#define WSAEALREADY SOC_EALREADY
#define WSAENOTSOCK SOC_ENOTSOCK
#define WSAEDESTADDRREQ SOC_EDESTADDRREQ
#define WSAEMSGSIZE SOC_EMSGSIZE
#define WSAEPROTOTYPE SOC_EPROTOTYPE
#define WSAENOPROTOOPT SOC_ENOPROTOOPT
#define WSAEPROTONOSUPPORT SOC_EPROTONOSUPPORT
#define WSAEOPNOTSUPP SOC_EOPNOTSUPP
#define WSAEAFNOSUPPORT SOC_EAFNOSUPPORT
#define WSAEADDRINUSE SOC_EADDRINUSE
#define WSAEADDRNOTAVAIL SOC_EADDRNOTAVAIL
#define WSAENETDOWN SOC_ENETDOWN
#define WSAENETUNREACH SOC_ENETUNREACH
#define WSAENETRESET SOC_ENETRESET
#define WSAECONNABORTED SOC_ECONNABORTED
#define WSAECONNRESET SOC_ECONNRESET
#define WSAENOBUFS SOC_ENOBUFS
#define WSAEISCONN SOC_EISCONN
#define WSAENOTCONN SOC_ENOTCONN
#define WSAETIMEDOUT SOC_ETIMEDOUT
#define WSAECONNREFUSED SOC_ECONNREFUSED
#define WSAELOOP SOC_ELOOP
#define WSAENAMETOOLONG SOC_ENAMETOOLONG
#define WSAEHOSTUNREACH SOC_EHOSTUNREACH
#define WSAENOTEMPTY SOC_ENOTEMPTY
#define WSAEDQUOT SOC_EDQUOT
#define WSAESTALE SOC_ESTALE
#define WSAEINVAL SOC_EINVAL
#elif defined(_PS3)
#define WSAEWOULDBLOCK SYS_NET_EWOULDBLOCK
#define WSAEINPROGRESS SYS_NET_EINPROGRESS //SYS_NET_ERROR_EINPROGRESS
#define WSAEALREADY SYS_NET_EALREADY
#define WSAENOTSOCK SYS_NET_ENOTSOCK
#define WSAEDESTADDRREQ SYS_NET_EDESTADDRREQ
#define WSAEMSGSIZE SYS_NET_EMSGSIZE
#define WSAEPROTOTYPE SYS_NET_EPROTOTYPE
#define WSAENOPROTOOPT SYS_NET_ENOPROTOOPT
#define WSAEPROTONOSUPPORT SYS_NET_EPROTONOSUPPORT
#define WSAESOCKTNOSUPPORT SYS_NET_ESOCKTNOSUPPORT
#define WSAEOPNOTSUPP SYS_NET_EOPNOTSUPP
#define WSAEPFNOSUPPORT SYS_NET_EPFNOSUPPORT
#define WSAEAFNOSUPPORT SYS_NET_EAFNOSUPPORT
#define WSAEADDRINUSE SYS_NET_EADDRINUSE
#define WSAEADDRNOTAVAIL SYS_NET_EADDRNOTAVAIL
#define WSAENETDOWN SYS_NET_ENETDOWN
#define WSAENETUNREACH SYS_NET_ENETUNREACH
#define WSAENETRESET SYS_NET_ENETRESET
#define WSAECONNABORTED SYS_NET_ECONNABORTED
#define WSAECONNRESET SYS_NET_ECONNRESET // SYS_NET_ERROR_ECONNRESET
#define WSAENOBUFS SYS_NET_ENOBUFS // SYS_NET_ERROR_ENOBUFS
#define WSAEISCONN SYS_NET_EISCONN
#define WSAENOTCONN SYS_NET_ENOTCONN
#define WSAESHUTDOWN SYS_NET_ESHUTDOWN
#define WSAETOOMANYREFS SYS_NET_ETOOMANYREFS
#define WSAETIMEDOUT SYS_NET_ERROR_ETIMEDOUT
#define WSAECONNREFUSED SYS_NET_ECONNREFUSED
#define WSAELOOP SYS_NET_ELOOP
#define WSAENAMETOOLONG SYS_NET_ENAMETOOLONG
#define WSAEHOSTDOWN SYS_NET_EHOSTDOWN
#define WSAEHOSTUNREACH SYS_NET_EHOSTUNREACH
#define WSAENOTEMPTY SYS_NET_ENOTEMPTY
#define WSAEPROCLIM SYS_NET_EPROCLIM
#define WSAEUSERS SYS_NET_EUSERS
#define WSAEDQUOT SYS_NET_EDQUOT
#define WSAESTALE SYS_NET_ESTALE
#define WSAEREMOTE SYS_NET_EREMOTE
#define WSAEINVAL SYS_NET_EINVAL
#elif !defined(_WIN32)
#define WSAEWOULDBLOCK EWOULDBLOCK
#define WSAEINPROGRESS EINPROGRESS
#define WSAEALREADY EALREADY
#define WSAENOTSOCK ENOTSOCK
#define WSAEDESTADDRREQ EDESTADDRREQ
#define WSAEMSGSIZE EMSGSIZE
#define WSAEPROTOTYPE EPROTOTYPE
#define WSAENOPROTOOPT ENOPROTOOPT
#define WSAEPROTONOSUPPORT EPROTONOSUPPORT
#define WSAESOCKTNOSUPPORT ESOCKTNOSUPPORT
#define WSAEOPNOTSUPP EOPNOTSUPP
#define WSAEPFNOSUPPORT EPFNOSUPPORT
#define WSAEAFNOSUPPORT EAFNOSUPPORT
#define WSAEADDRINUSE EADDRINUSE
#define WSAEADDRNOTAVAIL EADDRNOTAVAIL
#define WSAENETDOWN ENETDOWN
#define WSAENETUNREACH ENETUNREACH
#define WSAENETRESET ENETRESET
#define WSAECONNABORTED ECONNABORTED
#define WSAECONNRESET ECONNRESET
#define WSAENOBUFS ENOBUFS
#define WSAEISCONN EISCONN
#define WSAENOTCONN ENOTCONN
#define WSAESHUTDOWN ESHUTDOWN
#define WSAETOOMANYREFS ETOOMANYREFS
#define WSAETIMEDOUT ETIMEDOUT
#define WSAECONNREFUSED ECONNREFUSED
#define WSAELOOP ELOOP
#define WSAENAMETOOLONG ENAMETOOLONG
#define WSAEHOSTDOWN EHOSTDOWN
#define WSAEHOSTUNREACH EHOSTUNREACH
#define WSAENOTEMPTY ENOTEMPTY
#define WSAEPROCLIM EPROCLIM
#define WSAEUSERS EUSERS
#define WSAEDQUOT EDQUOT
#define WSAESTALE ESTALE
#define WSAEREMOTE EREMOTE
#define WSAEINVAL EINVAL
#endif
// make caps types interchangeable on all platforms
#if !defined(_WIN32) && !defined(_NITRO) && !defined(_REVOLUTION) // necessary for Wii??
typedef int SOCKET;
typedef struct sockaddr SOCKADDR;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct in_addr IN_ADDR;
typedef struct hostent HOSTENT;
typedef struct timeval TIMEVAL;
#endif
#ifdef EENET
#define GOAGetLastError(s) sceEENetErrno
#define closesocket sceEENetClose
#endif
#ifdef INSOCK
//#define NETBUFSIZE (sceLIBNET_BUFFERSIZE)
#define NETBUFSIZE (32768) // buffer size for our samples
// used in place of shutdown function to avoid blocking shutdown call
int gsiShutdown(SOCKET s, int how);
#define GOAGetLastError(s) sceInsockErrno // not implemented
#define closesocket(s) gsiShutdown(s,SCE_INSOCK_SHUT_RDWR)
#undef shutdown
#define shutdown(s,h) gsiShutdown(s,h)
#endif
#ifdef _UNIX
#define GOAGetLastError(s) errno
#define closesocket close //on unix
#endif
#if !defined(_WIN32)
#define ioctlsocket ioctl
#endif
#if defined(_WIN32)
#define GOAGetLastError(s) WSAGetLastError()
#endif
#if defined(_REVOLUTION)
#define AF_INET SO_PF_INET
#define SOCK_DGRAM SO_SOCK_DGRAM
#define SOCK_STREAM SO_SOCK_STREAM
#define IPPROTO_UDP SO_IPPROTO_UDP
#define IPPROTO_TCP SO_IPPROTO_TCP
#define INADDR_ANY SO_INADDR_ANY
#define SOL_SOCKET SO_SOL_SOCKET
#define SO_SNDBUF SO_SO_SNDBUF
#define SO_RCVBUF SO_SO_RCVBUF
#define SO_REUSEADDR SO_SO_REUSEADDR
typedef int SOCKET;
typedef struct SOSockAddr SOCKADDR;
#define sockaddr SOSockAddr
typedef struct SOSockAddrIn SOCKADDR_IN;
#define sockaddr_in SOSockAddrIn
#define sin_family family
#define sin_port port
#define sin_addr addr
typedef struct SOInAddr IN_ADDR;
#define in_addr SOInAddr
#define s_addr addr
typedef struct SOHostEnt HOSTENT;
#define hostent SOHostEnt
#define h_name name
#define h_aliases aliases
#define h_addrtype addrType
#define h_length length
#define h_addr_list addrList
#define h_addr addrList[0]
int socket(int pf, int type, int protocol);
int closesocket(SOCKET sock);
int shutdown(SOCKET sock, int how);
int bind(SOCKET sock, const SOCKADDR* addr, int len);
int connect(SOCKET sock, const SOCKADDR* addr, int len);
int listen(SOCKET sock, int backlog);
SOCKET accept(SOCKET sock, SOCKADDR* addr, int* len);
int recv(SOCKET sock, char* buf, int len, int flags);
int recvfrom(SOCKET sock, char* buf, int len, int flags, SOCKADDR* addr, int* fromlen);
int send(SOCKET sock, const char* buf, int len, int flags);
int sendto(SOCKET sock, const char* buf, int len, int flags, const SOCKADDR* addr, int tolen);
int getsockopt(SOCKET sock, int level, int optname, char* optval, int* optlen);
int setsockopt(SOCKET sock, int level, int optname, const char* optval, int optlen);
#define gethostbyaddr(a,l,t) SOGetHostByAddr(a,l,t)
#define gethostbyname(n) SOGetHostByName(n)
// thread safe DNS lookups
#define getaddrinfo(n,s,h,r) SOGetAddrInfo(n,s,h,r)
#define freeaddrinfo(a) SOFreeAddrInfo(a)
int getsockname(SOCKET sock, SOCKADDR* addr, int* len);
#define htonl(l) SOHtoNl((u32)l)
#define ntohl(l) SONtoHl((u32)l)
#define htons(s) SOHtoNs((u16)s)
#define ntohs(s) SONtoHs((u16)s)
#define inet_ntoa(n) SOInetNtoA(n)
unsigned long inet_addr(const char * name);
int GOAGetLastError(SOCKET sock);
#endif
#if defined(_NITRO)
#define AF_INET SOC_PF_INET
#define SOCK_DGRAM SOC_SOCK_DGRAM
#define SOCK_STREAM SOC_SOCK_STREAM
#define IPPROTO_UDP 0
#define IPPROTO_TCP 0
#define INADDR_ANY SOC_INADDR_ANY
#define SOL_SOCKET SOC_SOL_SOCKET
#define SO_SNDBUF SOC_SO_SNDBUF
#define SO_RCVBUF SOC_SO_RCVBUF
#define SO_REUSEADDR SOC_SO_REUSEADDR
typedef int SOCKET;
typedef struct SOSockAddr SOCKADDR;
#define sockaddr SOSockAddr
typedef struct SOSockAddrIn SOCKADDR_IN;
#define sockaddr_in SOSockAddrIn
#define sin_family family
#define sin_port port
#define sin_addr addr
typedef struct SOInAddr IN_ADDR;
#define in_addr SOInAddr
#define s_addr addr
typedef struct SOHostEnt HOSTENT;
#define hostent SOHostEnt
#define h_name name
#define h_aliases aliases
#define h_addrtype addrType
#define h_length length
#define h_addr_list addrList
#define h_addr addrList[0]
int socket(int pf, int type, int protocol);
int closesocket(SOCKET sock);
int shutdown(SOCKET sock, int how);
int bind(SOCKET sock, const SOCKADDR* addr, int len);
int connect(SOCKET sock, const SOCKADDR* addr, int len);
int listen(SOCKET sock, int backlog);
SOCKET accept(SOCKET sock, SOCKADDR* addr, int* len);
int recv(SOCKET sock, char* buf, int len, int flags);
int recvfrom(SOCKET sock, char* buf, int len, int flags, SOCKADDR* addr, int* fromlen);
int send(SOCKET sock, const char* buf, int len, int flags);
int sendto(SOCKET sock, const char* buf, int len, int flags, const SOCKADDR* addr, int tolen);
int getsockopt(SOCKET sock, int level, int optname, char* optval, int* optlen);
int setsockopt(SOCKET sock, int level, int optname, const char* optval, int optlen);
#define gethostbyaddr(a,l,t) SOC_GetHostByAddr(a,l,t)
#define gethostbyname(n) SOC_GetHostByName(n)
int getsockname(SOCKET sock, SOCKADDR* addr, int* len);
#define htonl(l) SOC_HtoNl(l)
#define ntohl(l) SOC_NtoHl(l)
#define htons(s) SOC_HtoNs(s)
#define ntohs(s) SOC_NtoHs(s)
#define inet_ntoa(n) SOC_InetNtoA(n)
unsigned long inet_addr(const char * name);
int GOAGetLastError(SOCKET sock);
#endif
#if defined(_PS3)
#define accept(s,a,al) accept(s,a,(socklen_t*)(al))
#define bind(s,a,al) bind(s,a,(socklen_t)(al))
#define connect(s,a,al) connect(s,a,(socklen_t)(al))
#define getpeername(s,a,al) getpeername(s,a,(socklen_t*)(al))
#define getsockname(s,a,al) getsockname(s,a,(socklen_t*)(al))
#define getsockopt(s,l,o,v,vl) getsockopt(s,l,o,v,(socklen_t*)(vl))
#define recvfrom(s,b,l,f,a,al) recvfrom(s,b,l,f,a,(socklen_t*)(al))
#define sendto(s,b,l,f,a,al) sendto(s,b,l,f,a,(socklen_t)(al))
#define setsockopt(s,l,o,v,vl) setsockopt(s,l,o,v,(socklen_t)(vl))
#define closesocket socketclose
#define GOAGetLastError(s) sys_net_errno
#define EWOULDBLOCK sceNET_EWOULDBLOCK
#endif
#if defined(_MACOSX)
#define accept(s,a,al) accept(s,a,(socklen_t*)(al))
#define bind(s,a,al) bind(s,a,(socklen_t)(al))
#define connect(s,a,al) connect(s,a,(socklen_t)(al))
#define getpeername(s,a,al) getpeername(s,a,(socklen_t*)(al))
#define getsockname(s,a,al) getsockname(s,a,(socklen_t*)(al))
#define getsockopt(s,l,o,v,vl) getsockopt(s,l,o,v,(socklen_t*)(vl))
#define recvfrom(s,b,l,f,a,al) recvfrom(s,b,l,f,a,(socklen_t*)(al))
#define sendto(s,b,l,f,a,al) sendto(s,b,l,f,a,(socklen_t)(al))
#define setsockopt(s,l,o,v,vl) setsockopt(s,l,o,v,(socklen_t)(vl))
#endif
#if defined(SN_SYSTEMS)
int GOAGetLastError(SOCKET s);
#if !defined(__MWERKS__)
#define send(s,b,l,f) (int)send(s,b,(unsigned long)l,f)
#define recv(s,b,l,f) (int)recv(s,b,(unsigned long)l,f)
#define sendto(s,b,l,f,a,al) (int)sendto(s,b,(unsigned long)l,f,a,al)
#define recvfrom(s,b,l,f,a,al) (int)recvfrom(s,b,(unsigned long)l,f,a,al)
#endif
#endif
// SN Systems doesn't support gethostbyaddr
#if defined(SN_SYSTEMS)
#define gethostbyaddr(a,b,c) NULL
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Functions
int SetSockBlocking(SOCKET sock, int isblocking);
int SetSockBroadcast(SOCKET sock);
int DisableNagle(SOCKET sock);
int SetReceiveBufferSize(SOCKET sock, int size);
int SetSendBufferSize(SOCKET sock, int size);
int GetReceiveBufferSize(SOCKET sock);
int GetSendBufferSize(SOCKET sock);
int CanReceiveOnSocket(SOCKET sock);
int CanSendOnSocket(SOCKET sock);
int GSISocketSelect(SOCKET theSocket, int* theReadFlag, int* theWriteFlag, int* theExceptFlag);
void SocketStartUp();
void SocketShutDown();
HOSTENT * getlocalhost(void);
int IsPrivateIP(IN_ADDR * addr);
gsi_u32 gsiGetBroadcastIP(void);
#if defined(_PSP)
#define gethostbyaddr(a,b,c) NULL
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif // __GSSOCKET_H__
Reference in a new issue Copy permalink