mirror of
https://github.com/bulletphysics/bullet3
synced 2024-12-13 21:30:09 +00:00
ab8f16961e
Apply clang-format-all.sh using the _clang-format file through all the cpp/.h files. make sure not to apply it to certain serialization structures, since some parser expects the * as part of the name, instead of type. This commit contains no other changes aside from adding and applying clang-format-all.sh
459 lines
9.3 KiB
C
459 lines
9.3 KiB
C
/**
|
|
@file unix.c
|
|
@brief ENet Unix system specific functions
|
|
*/
|
|
#ifndef WIN32
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/time.h>
|
|
#include <arpa/inet.h>
|
|
#include <netdb.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <time.h>
|
|
|
|
#define ENET_BUILDING_LIB 1
|
|
#include "enet/enet.h"
|
|
|
|
#ifdef __APPLE__
|
|
#ifdef HAS_POLL
|
|
#undef HAS_POLL
|
|
#endif
|
|
#ifndef HAS_FCNTL
|
|
#define HAS_FCNTL 1
|
|
#endif
|
|
#ifndef HAS_INET_PTON
|
|
#define HAS_INET_PTON 1
|
|
#endif
|
|
#ifndef HAS_INET_NTOP
|
|
#define HAS_INET_NTOP 1
|
|
#endif
|
|
#ifndef HAS_MSGHDR_FLAGS
|
|
#define HAS_MSGHDR_FLAGS 1
|
|
#endif
|
|
#ifndef HAS_SOCKLEN_T
|
|
#define HAS_SOCKLEN_T 1
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef HAS_FCNTL
|
|
#include <fcntl.h>
|
|
#endif
|
|
|
|
#ifdef HAS_POLL
|
|
#include <sys/poll.h>
|
|
#endif
|
|
|
|
#ifndef HAS_SOCKLEN_T
|
|
typedef int socklen_t;
|
|
#endif
|
|
|
|
#ifndef MSG_NOSIGNAL
|
|
#define MSG_NOSIGNAL 0
|
|
#endif
|
|
|
|
static enet_uint32 timeBase = 0;
|
|
|
|
int enet_initialize(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void enet_deinitialize(void)
|
|
{
|
|
}
|
|
|
|
enet_uint32
|
|
enet_time_get(void)
|
|
{
|
|
struct timeval timeVal;
|
|
|
|
gettimeofday(&timeVal, NULL);
|
|
|
|
return timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - timeBase;
|
|
}
|
|
|
|
void enet_time_set(enet_uint32 newTimeBase)
|
|
{
|
|
struct timeval timeVal;
|
|
|
|
gettimeofday(&timeVal, NULL);
|
|
|
|
timeBase = timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - newTimeBase;
|
|
}
|
|
|
|
int enet_address_set_host(ENetAddress *address, const char *name)
|
|
{
|
|
struct hostent *hostEntry = NULL;
|
|
#ifdef HAS_GETHOSTBYNAME_R
|
|
struct hostent hostData;
|
|
char buffer[2048];
|
|
int errnum;
|
|
|
|
#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
|
|
gethostbyname_r(name, &hostData, buffer, sizeof(buffer), &hostEntry, &errnum);
|
|
#else
|
|
hostEntry = gethostbyname_r(name, &hostData, buffer, sizeof(buffer), &errnum);
|
|
#endif
|
|
#else
|
|
hostEntry = gethostbyname(name);
|
|
#endif
|
|
|
|
if (hostEntry == NULL ||
|
|
hostEntry->h_addrtype != AF_INET)
|
|
{
|
|
#ifdef HAS_INET_PTON
|
|
if (!inet_pton(AF_INET, name, &address->host))
|
|
#else
|
|
if (!inet_aton(name, (struct in_addr *)&address->host))
|
|
#endif
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
address->host = *(enet_uint32 *)hostEntry->h_addr_list[0];
|
|
|
|
return 0;
|
|
}
|
|
|
|
int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength)
|
|
{
|
|
#ifdef HAS_INET_NTOP
|
|
if (inet_ntop(AF_INET, &address->host, name, nameLength) == NULL)
|
|
#else
|
|
char *addr = inet_ntoa(*(struct in_addr *)&address->host);
|
|
if (addr != NULL)
|
|
strncpy(name, addr, nameLength);
|
|
else
|
|
#endif
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength)
|
|
{
|
|
struct in_addr in;
|
|
struct hostent *hostEntry = NULL;
|
|
#ifdef HAS_GETHOSTBYADDR_R
|
|
struct hostent hostData;
|
|
char buffer[2048];
|
|
int errnum;
|
|
|
|
in.s_addr = address->host;
|
|
|
|
#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
|
|
gethostbyaddr_r((char *)&in, sizeof(struct in_addr), AF_INET, &hostData, buffer, sizeof(buffer), &hostEntry, &errnum);
|
|
#else
|
|
hostEntry = gethostbyaddr_r((char *)&in, sizeof(struct in_addr), AF_INET, &hostData, buffer, sizeof(buffer), &errnum);
|
|
#endif
|
|
#else
|
|
in.s_addr = address->host;
|
|
|
|
hostEntry = gethostbyaddr((char *)&in, sizeof(struct in_addr), AF_INET);
|
|
#endif
|
|
|
|
if (hostEntry == NULL)
|
|
return enet_address_get_host_ip(address, name, nameLength);
|
|
|
|
strncpy(name, hostEntry->h_name, nameLength);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int enet_socket_bind(ENetSocket socket, const ENetAddress *address)
|
|
{
|
|
struct sockaddr_in sin;
|
|
|
|
memset(&sin, 0, sizeof(struct sockaddr_in));
|
|
|
|
sin.sin_family = AF_INET;
|
|
|
|
if (address != NULL)
|
|
{
|
|
sin.sin_port = ENET_HOST_TO_NET_16(address->port);
|
|
sin.sin_addr.s_addr = address->host;
|
|
}
|
|
else
|
|
{
|
|
sin.sin_port = 0;
|
|
sin.sin_addr.s_addr = INADDR_ANY;
|
|
}
|
|
|
|
return bind(socket,
|
|
(struct sockaddr *)&sin,
|
|
sizeof(struct sockaddr_in));
|
|
}
|
|
|
|
int enet_socket_listen(ENetSocket socket, int backlog)
|
|
{
|
|
return listen(socket, backlog < 0 ? SOMAXCONN : backlog);
|
|
}
|
|
|
|
ENetSocket
|
|
enet_socket_create(ENetSocketType type)
|
|
{
|
|
return socket(PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
|
|
}
|
|
|
|
int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value)
|
|
{
|
|
int result = -1;
|
|
switch (option)
|
|
{
|
|
case ENET_SOCKOPT_NONBLOCK:
|
|
#ifdef HAS_FCNTL
|
|
result = fcntl(socket, F_SETFL, O_NONBLOCK | fcntl(socket, F_GETFL));
|
|
#else
|
|
result = ioctl(socket, FIONBIO, &value);
|
|
#endif
|
|
break;
|
|
|
|
case ENET_SOCKOPT_BROADCAST:
|
|
result = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&value, sizeof(int));
|
|
break;
|
|
|
|
case ENET_SOCKOPT_REUSEADDR:
|
|
result = setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *)&value, sizeof(int));
|
|
break;
|
|
|
|
case ENET_SOCKOPT_RCVBUF:
|
|
result = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *)&value, sizeof(int));
|
|
break;
|
|
|
|
case ENET_SOCKOPT_SNDBUF:
|
|
result = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *)&value, sizeof(int));
|
|
break;
|
|
|
|
case ENET_SOCKOPT_RCVTIMEO:
|
|
result = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&value, sizeof(int));
|
|
break;
|
|
|
|
case ENET_SOCKOPT_SNDTIMEO:
|
|
result = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&value, sizeof(int));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return result == -1 ? -1 : 0;
|
|
}
|
|
|
|
int enet_socket_connect(ENetSocket socket, const ENetAddress *address)
|
|
{
|
|
struct sockaddr_in sin;
|
|
int result;
|
|
|
|
memset(&sin, 0, sizeof(struct sockaddr_in));
|
|
|
|
sin.sin_family = AF_INET;
|
|
sin.sin_port = ENET_HOST_TO_NET_16(address->port);
|
|
sin.sin_addr.s_addr = address->host;
|
|
|
|
result = connect(socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in));
|
|
if (result == -1 && errno == EINPROGRESS)
|
|
return 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
ENetSocket
|
|
enet_socket_accept(ENetSocket socket, ENetAddress *address)
|
|
{
|
|
int result;
|
|
struct sockaddr_in sin;
|
|
socklen_t sinLength = sizeof(struct sockaddr_in);
|
|
|
|
result = accept(socket,
|
|
address != NULL ? (struct sockaddr *)&sin : NULL,
|
|
address != NULL ? &sinLength : NULL);
|
|
|
|
if (result == -1)
|
|
return ENET_SOCKET_NULL;
|
|
|
|
if (address != NULL)
|
|
{
|
|
address->host = (enet_uint32)sin.sin_addr.s_addr;
|
|
address->port = ENET_NET_TO_HOST_16(sin.sin_port);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int enet_socket_shutdown(ENetSocket socket, ENetSocketShutdown how)
|
|
{
|
|
return shutdown(socket, (int)how);
|
|
}
|
|
|
|
void enet_socket_destroy(ENetSocket socket)
|
|
{
|
|
if (socket != -1)
|
|
close(socket);
|
|
}
|
|
|
|
int enet_socket_send(ENetSocket socket,
|
|
const ENetAddress *address,
|
|
const ENetBuffer *buffers,
|
|
size_t bufferCount)
|
|
{
|
|
struct msghdr msgHdr;
|
|
struct sockaddr_in sin;
|
|
int sentLength;
|
|
|
|
memset(&msgHdr, 0, sizeof(struct msghdr));
|
|
|
|
if (address != NULL)
|
|
{
|
|
memset(&sin, 0, sizeof(struct sockaddr_in));
|
|
|
|
sin.sin_family = AF_INET;
|
|
sin.sin_port = ENET_HOST_TO_NET_16(address->port);
|
|
sin.sin_addr.s_addr = address->host;
|
|
|
|
msgHdr.msg_name = &sin;
|
|
msgHdr.msg_namelen = sizeof(struct sockaddr_in);
|
|
}
|
|
|
|
msgHdr.msg_iov = (struct iovec *)buffers;
|
|
msgHdr.msg_iovlen = bufferCount;
|
|
|
|
sentLength = sendmsg(socket, &msgHdr, MSG_NOSIGNAL);
|
|
|
|
if (sentLength == -1)
|
|
{
|
|
if (errno == EWOULDBLOCK)
|
|
return 0;
|
|
|
|
return -1;
|
|
}
|
|
|
|
return sentLength;
|
|
}
|
|
|
|
int enet_socket_receive(ENetSocket socket,
|
|
ENetAddress *address,
|
|
ENetBuffer *buffers,
|
|
size_t bufferCount)
|
|
{
|
|
struct msghdr msgHdr;
|
|
struct sockaddr_in sin;
|
|
int recvLength;
|
|
|
|
memset(&msgHdr, 0, sizeof(struct msghdr));
|
|
|
|
if (address != NULL)
|
|
{
|
|
msgHdr.msg_name = &sin;
|
|
msgHdr.msg_namelen = sizeof(struct sockaddr_in);
|
|
}
|
|
|
|
msgHdr.msg_iov = (struct iovec *)buffers;
|
|
msgHdr.msg_iovlen = bufferCount;
|
|
|
|
recvLength = recvmsg(socket, &msgHdr, MSG_NOSIGNAL);
|
|
|
|
if (recvLength == -1)
|
|
{
|
|
if (errno == EWOULDBLOCK)
|
|
return 0;
|
|
|
|
return -1;
|
|
}
|
|
|
|
#ifdef HAS_MSGHDR_FLAGS
|
|
if (msgHdr.msg_flags & MSG_TRUNC)
|
|
return -1;
|
|
#endif
|
|
|
|
if (address != NULL)
|
|
{
|
|
address->host = (enet_uint32)sin.sin_addr.s_addr;
|
|
address->port = ENET_NET_TO_HOST_16(sin.sin_port);
|
|
}
|
|
|
|
return recvLength;
|
|
}
|
|
|
|
int enet_socketset_select(ENetSocket maxSocket, ENetSocketSet *readSet, ENetSocketSet *writeSet, enet_uint32 timeout)
|
|
{
|
|
struct timeval timeVal;
|
|
|
|
timeVal.tv_sec = timeout / 1000;
|
|
timeVal.tv_usec = (timeout % 1000) * 1000;
|
|
|
|
return select(maxSocket + 1, readSet, writeSet, NULL, &timeVal);
|
|
}
|
|
|
|
int enet_socket_wait(ENetSocket socket, enet_uint32 *condition, enet_uint32 timeout)
|
|
{
|
|
#ifdef HAS_POLL
|
|
struct pollfd pollSocket;
|
|
int pollCount;
|
|
|
|
pollSocket.fd = socket;
|
|
pollSocket.events = 0;
|
|
|
|
if (*condition & ENET_SOCKET_WAIT_SEND)
|
|
pollSocket.events |= POLLOUT;
|
|
|
|
if (*condition & ENET_SOCKET_WAIT_RECEIVE)
|
|
pollSocket.events |= POLLIN;
|
|
|
|
pollCount = poll(&pollSocket, 1, timeout);
|
|
|
|
if (pollCount < 0)
|
|
return -1;
|
|
|
|
*condition = ENET_SOCKET_WAIT_NONE;
|
|
|
|
if (pollCount == 0)
|
|
return 0;
|
|
|
|
if (pollSocket.revents & POLLOUT)
|
|
*condition |= ENET_SOCKET_WAIT_SEND;
|
|
|
|
if (pollSocket.revents & POLLIN)
|
|
*condition |= ENET_SOCKET_WAIT_RECEIVE;
|
|
|
|
return 0;
|
|
#else
|
|
fd_set readSet, writeSet;
|
|
struct timeval timeVal;
|
|
int selectCount;
|
|
|
|
timeVal.tv_sec = timeout / 1000;
|
|
timeVal.tv_usec = (timeout % 1000) * 1000;
|
|
|
|
FD_ZERO(&readSet);
|
|
FD_ZERO(&writeSet);
|
|
|
|
if (*condition & ENET_SOCKET_WAIT_SEND)
|
|
FD_SET(socket, &writeSet);
|
|
|
|
if (*condition & ENET_SOCKET_WAIT_RECEIVE)
|
|
FD_SET(socket, &readSet);
|
|
|
|
selectCount = select(socket + 1, &readSet, &writeSet, NULL, &timeVal);
|
|
|
|
if (selectCount < 0)
|
|
return -1;
|
|
|
|
*condition = ENET_SOCKET_WAIT_NONE;
|
|
|
|
if (selectCount == 0)
|
|
return 0;
|
|
|
|
if (FD_ISSET(socket, &writeSet))
|
|
*condition |= ENET_SOCKET_WAIT_SEND;
|
|
|
|
if (FD_ISSET(socket, &readSet))
|
|
*condition |= ENET_SOCKET_WAIT_RECEIVE;
|
|
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
#endif
|