/////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// #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__