make enums crash-safe. and other fixes
/*
* Hedgewars, a free turn based strategy game
* Copyright (C) 2012 Simeon Maxein <smaxein@googlemail.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "socket.h"
#include "util/logging.h"
#include "util/util.h"
#include <stdlib.h>
#include <SDL_net.h>
#include <time.h>
struct _flib_tcpsocket {
TCPsocket sock;
SDLNet_SocketSet sockset;
};
struct _flib_acceptor {
TCPsocket sock;
uint16_t port;
};
static uint32_t getPeerIp(TCPsocket sock) {
IPaddress *addr = SDLNet_TCP_GetPeerAddress(sock);
return SDLNet_Read32(&addr->host);
}
static bool connectionIsLocal(TCPsocket sock) {
return getPeerIp(sock) == (uint32_t)((127UL<<24)+1); // 127.0.0.1
}
static flib_tcpsocket *createSocket(TCPsocket sdlsock) {
flib_tcpsocket *result = flib_calloc(1, sizeof(flib_tcpsocket));
if(result) {
result->sock = sdlsock;
result->sockset = SDLNet_AllocSocketSet(1);
if(!result->sockset) {
flib_log_e("Can't allocate socket: Out of memory!");
SDLNet_FreeSocketSet(result->sockset);
free(result);
result = NULL;
} else {
SDLNet_AddSocket(result->sockset, (SDLNet_GenericSocket)result->sock);
}
}
return result;
}
TCPsocket listen(uint16_t port) {
IPaddress addr;
addr.host = INADDR_ANY;
SDLNet_Write16(port, &addr.port);
TCPsocket sock = SDLNet_TCP_Open(&addr);
if(!sock) {
flib_log_w("Unable to listen on port %u: %s", (unsigned)port, SDLNet_GetError());
}
return sock;
}
flib_acceptor *flib_acceptor_create(uint16_t port) {
flib_acceptor *result = flib_calloc(1, sizeof(flib_acceptor));
if(result) {
if(port > 0) {
result->port = port;
result->sock = listen(result->port);
} else {
/* SDL_net does not seem to have a way to listen on a random unused port
and find out which port that is, so let's try to find one ourselves. */
srand(time(NULL));
for(int i=0; !result->sock && i<1000; i++) {
// IANA suggests using ports in the range 49152-65535 for things like this
result->port = 49152+(rand()%(65536-49152));
result->sock = listen(result->port);
}
}
if(!result->sock) {
flib_log_e("Failed to create acceptor.");
free(result);
result = NULL;
}
}
return result;
}
uint16_t flib_acceptor_listenport(flib_acceptor *acceptor) {
if(!acceptor) {
flib_log_e("Call to flib_acceptor_listenport with acceptor==null");
return 0;
}
return acceptor->port;
}
void flib_acceptor_close(flib_acceptor *acceptor) {
if(acceptor) {
SDLNet_TCP_Close(acceptor->sock);
free(acceptor);
}
}
flib_tcpsocket *flib_socket_accept(flib_acceptor *acceptor, bool localOnly) {
flib_tcpsocket *result = NULL;
if(!acceptor) {
flib_log_e("Call to flib_socket_accept with acceptor==null");
} else {
TCPsocket sock = NULL;
while(!result && (sock = SDLNet_TCP_Accept(acceptor->sock))) {
if(localOnly && !connectionIsLocal(sock)) {
flib_log_i("Rejected nonlocal connection attempt from %s", flib_format_ip(getPeerIp(sock)));
} else {
result = createSocket(sock);
}
if(!result) {
SDLNet_TCP_Close(sock);
}
}
}
return result;
}
flib_tcpsocket *flib_socket_connect(const char *host, uint16_t port) {
flib_tcpsocket *result = NULL;
if(!host || port==0) {
flib_log_e("Invalid parameter in flib_socket_connect");
} else {
IPaddress ip;
if(SDLNet_ResolveHost(&ip,host,port)==-1) {
flib_log_e("SDLNet_ResolveHost: %s\n", SDLNet_GetError());
} else {
TCPsocket sock=SDLNet_TCP_Open(&ip);
if(!sock) {
flib_log_e("SDLNet_TCP_Open: %s\n", SDLNet_GetError());
} else {
result = createSocket(sock);
if(result) {
sock = NULL;
}
}
SDLNet_TCP_Close(sock);
}
}
return result;
}
void flib_socket_close(flib_tcpsocket *sock) {
if(sock) {
SDLNet_DelSocket(sock->sockset, (SDLNet_GenericSocket)sock->sock);
SDLNet_TCP_Close(sock->sock);
SDLNet_FreeSocketSet(sock->sockset);
free(sock);
}
}
int flib_socket_nbrecv(flib_tcpsocket *sock, void *data, int maxlen) {
if(!sock || (maxlen>0 && !data)) {
flib_log_e("Call to flib_socket_nbrecv with sock==null or data==null");
return -1;
}
int readySockets = SDLNet_CheckSockets(sock->sockset, 0);
if(readySockets>0) {
int size = SDLNet_TCP_Recv(sock->sock, data, maxlen);
return size>0 ? size : -1;
} else if(readySockets==0) {
return 0;
} else {
flib_log_e("Error in select system call: %s", SDLNet_GetError());
return -1;
}
}
int flib_socket_send(flib_tcpsocket *sock, const void *data, int len) {
if(!sock || (len>0 && !data)) {
flib_log_e("Call to flib_socket_send with sock==null or data==null");
return -1;
}
return SDLNet_TCP_Send(sock->sock, data, len);
}