summaryrefslogtreecommitdiff
path: root/src/common/socket.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/common/socket.c')
-rw-r--r--src/common/socket.c1983
1 files changed, 1003 insertions, 980 deletions
diff --git a/src/common/socket.c b/src/common/socket.c
index 4a6e01459..d24a9c1d8 100644
--- a/src/common/socket.c
+++ b/src/common/socket.c
@@ -15,35 +15,35 @@
#include <sys/types.h>
#ifdef WIN32
-#include "../common/winapi.h"
+ #include "../common/winapi.h"
#else
-#include <errno.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <net/if.h>
-#include <unistd.h>
-#include <sys/time.h>
-#include <sys/ioctl.h>
-#include <netdb.h>
-#include <arpa/inet.h>
-
-#ifndef SIOCGIFCONF
-#include <sys/sockio.h> // SIOCGIFCONF on Solaris, maybe others? [Shinomori]
-#endif
-#ifndef FIONBIO
-#include <sys/filio.h> // FIONBIO on Solaris [FlavioJS]
-#endif
-
-#ifdef HAVE_SETRLIMIT
-#include <sys/resource.h>
-#endif
+ #include <errno.h>
+ #include <sys/socket.h>
+ #include <netinet/in.h>
+ #include <netinet/tcp.h>
+ #include <net/if.h>
+ #include <unistd.h>
+ #include <sys/time.h>
+ #include <sys/ioctl.h>
+ #include <netdb.h>
+ #include <arpa/inet.h>
+
+ #ifndef SIOCGIFCONF
+ #include <sys/sockio.h> // SIOCGIFCONF on Solaris, maybe others? [Shinomori]
+ #endif
+ #ifndef FIONBIO
+ #include <sys/filio.h> // FIONBIO on Solaris [FlavioJS]
+ #endif
+
+ #ifdef HAVE_SETRLIMIT
+ #include <sys/resource.h>
+ #endif
#endif
/////////////////////////////////////////////////////////////////////
#if defined(WIN32)
/////////////////////////////////////////////////////////////////////
-// windows portability layer
+// windows portability layer
typedef int socklen_t;
@@ -75,21 +75,21 @@ static int sock_arr_len = 0;
/// @return Fd or -1
int sock2fd(SOCKET s)
{
- int fd;
-
- // search for the socket
- for (fd = 1; fd < sock_arr_len; ++fd)
- if (sock_arr[fd] == s)
- break;// found the socket
- if (fd == sock_arr_len)
- return -1;// not found
- return fd;
+ int fd;
+
+ // search for the socket
+ for( fd = 1; fd < sock_arr_len; ++fd )
+ if( sock_arr[fd] == s )
+ break;// found the socket
+ if( fd == sock_arr_len )
+ return -1;// not found
+ return fd;
}
/// Inserts the socket into the global array of sockets.
/// Returns a new fd associated with the socket.
-/// If there are too many sockets it closes the socket, sets an error and
+/// If there are too many sockets it closes the socket, sets an error and
// returns -1 instead.
/// Since fd 0 is reserved, it returns values in the range [1,FD_SETSIZE[.
///
@@ -97,61 +97,61 @@ int sock2fd(SOCKET s)
/// @return New fd or -1
int sock2newfd(SOCKET s)
{
- int fd;
-
- // find an empty position
- for (fd = 1; fd < sock_arr_len; ++fd)
- if (sock_arr[fd] == INVALID_SOCKET)
- break;// empty position
- if (fd == ARRAYLENGTH(sock_arr)) {
- // too many sockets
- closesocket(s);
- WSASetLastError(WSAEMFILE);
- return -1;
- }
- sock_arr[fd] = s;
- if (sock_arr_len <= fd)
- sock_arr_len = fd+1;
- return fd;
+ int fd;
+
+ // find an empty position
+ for( fd = 1; fd < sock_arr_len; ++fd )
+ if( sock_arr[fd] == INVALID_SOCKET )
+ break;// empty position
+ if( fd == ARRAYLENGTH(sock_arr) )
+ {// too many sockets
+ closesocket(s);
+ WSASetLastError(WSAEMFILE);
+ return -1;
+ }
+ sock_arr[fd] = s;
+ if( sock_arr_len <= fd )
+ sock_arr_len = fd+1;
+ return fd;
}
-int sAccept(int fd, struct sockaddr *addr, int *addrlen)
+int sAccept(int fd, struct sockaddr* addr, int* addrlen)
{
- SOCKET s;
+ SOCKET s;
- // accept connection
- s = accept(fd2sock(fd), addr, addrlen);
- if (s == INVALID_SOCKET)
- return -1;// error
- return sock2newfd(s);
+ // accept connection
+ s = accept(fd2sock(fd), addr, addrlen);
+ if( s == INVALID_SOCKET )
+ return -1;// error
+ return sock2newfd(s);
}
int sClose(int fd)
{
- int ret = closesocket(fd2sock(fd));
- fd2sock(fd) = INVALID_SOCKET;
- return ret;
+ int ret = closesocket(fd2sock(fd));
+ fd2sock(fd) = INVALID_SOCKET;
+ return ret;
}
int sSocket(int af, int type, int protocol)
{
- SOCKET s;
+ SOCKET s;
- // create socket
- s = socket(af,type,protocol);
- if (s == INVALID_SOCKET)
- return -1;// error
- return sock2newfd(s);
+ // create socket
+ s = socket(af,type,protocol);
+ if( s == INVALID_SOCKET )
+ return -1;// error
+ return sock2newfd(s);
}
-char *sErr(int code)
+char* sErr(int code)
{
- static char sbuf[512];
- // strerror does not handle socket codes
- if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
- code, MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), (LPTSTR)&sbuf, sizeof(sbuf), NULL) == 0)
- snprintf(sbuf, sizeof(sbuf), "unknown error");
- return sbuf;
+ static char sbuf[512];
+ // strerror does not handle socket codes
+ if( FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
+ code, MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), (LPTSTR)&sbuf, sizeof(sbuf), NULL) == 0 )
+ snprintf(sbuf, sizeof(sbuf), "unknown error");
+ return sbuf;
}
#define sBind(fd,name,namelen) bind(fd2sock(fd),name,namelen)
@@ -205,7 +205,7 @@ char *sErr(int code)
/////////////////////////////////////////////////////////////////////
#ifndef MSG_NOSIGNAL
-#define MSG_NOSIGNAL 0
+ #define MSG_NOSIGNAL 0
#endif
fd_set readfds;
@@ -230,7 +230,7 @@ static size_t socket_max_client_packet = 24576;
// The connection is closed if it goes over the limit.
#define WFIFO_MAX (1*1024*1024)
-struct socket_data *session[FD_SETSIZE];
+struct socket_data* session[FD_SETSIZE];
#ifdef SEND_SHORTLIST
int send_shortlist_array[FD_SETSIZE];// we only support FD_SETSIZE sockets, limit the array to that
@@ -241,390 +241,387 @@ uint32 send_shortlist_set[(FD_SETSIZE+31)/32];// to know if specific fd's are al
static int create_session(int fd, RecvFunc func_recv, SendFunc func_send, ParseFunc func_parse);
#ifndef MINICORE
-int ip_rules = 1;
-static int connect_check(uint32 ip);
+ int ip_rules = 1;
+ static int connect_check(uint32 ip);
#endif
-const char *error_msg(void)
+const char* error_msg(void)
{
- static char buf[512];
- int code = sErrno;
- snprintf(buf, sizeof(buf), "error %d: %s", code, sErr(code));
- return buf;
+ static char buf[512];
+ int code = sErrno;
+ snprintf(buf, sizeof(buf), "error %d: %s", code, sErr(code));
+ return buf;
}
/*======================================
- * CORE : Default processing functions
+ * CORE : Default processing functions
*--------------------------------------*/
-int null_recv(int fd)
-{
- return 0;
-}
-int null_send(int fd)
-{
- return 0;
-}
-int null_parse(int fd)
-{
- return 0;
-}
+int null_recv(int fd) { return 0; }
+int null_send(int fd) { return 0; }
+int null_parse(int fd) { return 0; }
ParseFunc default_func_parse = null_parse;
void set_defaultparse(ParseFunc defaultparse)
{
- default_func_parse = defaultparse;
+ default_func_parse = defaultparse;
}
/*======================================
- * CORE : Socket options
+ * CORE : Socket options
*--------------------------------------*/
void set_nonblocking(int fd, unsigned long yes)
{
- // FIONBIO Use with a nonzero argp parameter to enable the nonblocking mode of socket s.
- // The argp parameter is zero if nonblocking is to be disabled.
- if (sIoctl(fd, FIONBIO, &yes) != 0)
- ShowError("set_nonblocking: Failed to set socket #%d to non-blocking mode (%s) - Please report this!!!\n", fd, error_msg());
+ // FIONBIO Use with a nonzero argp parameter to enable the nonblocking mode of socket s.
+ // The argp parameter is zero if nonblocking is to be disabled.
+ if( sIoctl(fd, FIONBIO, &yes) != 0 )
+ ShowError("set_nonblocking: Failed to set socket #%d to non-blocking mode (%s) - Please report this!!!\n", fd, error_msg());
}
void setsocketopts(int fd)
{
- int yes = 1; // reuse fix
+ int yes = 1; // reuse fix
#if !defined(WIN32)
- // set SO_REAUSEADDR to true, unix only. on windows this option causes
- // the previous owner of the socket to give up, which is not desirable
- // in most cases, neither compatible with unix.
- sSetsockopt(fd,SOL_SOCKET,SO_REUSEADDR,(char *)&yes,sizeof(yes));
+ // set SO_REAUSEADDR to true, unix only. on windows this option causes
+ // the previous owner of the socket to give up, which is not desirable
+ // in most cases, neither compatible with unix.
+ sSetsockopt(fd,SOL_SOCKET,SO_REUSEADDR,(char *)&yes,sizeof(yes));
#ifdef SO_REUSEPORT
- sSetsockopt(fd,SOL_SOCKET,SO_REUSEPORT,(char *)&yes,sizeof(yes));
+ sSetsockopt(fd,SOL_SOCKET,SO_REUSEPORT,(char *)&yes,sizeof(yes));
#endif
#endif
- // Set the socket into no-delay mode; otherwise packets get delayed for up to 200ms, likely creating server-side lag.
- // The RO protocol is mainly single-packet request/response, plus the FIFO model already does packet grouping anyway.
- sSetsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&yes, sizeof(yes));
-
- // force the socket into no-wait, graceful-close mode (should be the default, but better make sure)
- //(http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winsock/winsock/closesocket_2.asp)
- {
- struct linger opt;
- opt.l_onoff = 0; // SO_DONTLINGER
- opt.l_linger = 0; // Do not care
- if (sSetsockopt(fd, SOL_SOCKET, SO_LINGER, (char *)&opt, sizeof(opt)))
- ShowWarning("setsocketopts: Unable to set SO_LINGER mode for connection #%d!\n", fd);
- }
+ // Set the socket into no-delay mode; otherwise packets get delayed for up to 200ms, likely creating server-side lag.
+ // The RO protocol is mainly single-packet request/response, plus the FIFO model already does packet grouping anyway.
+ sSetsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&yes, sizeof(yes));
+
+ // force the socket into no-wait, graceful-close mode (should be the default, but better make sure)
+ //(http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winsock/winsock/closesocket_2.asp)
+ {
+ struct linger opt;
+ opt.l_onoff = 0; // SO_DONTLINGER
+ opt.l_linger = 0; // Do not care
+ if( sSetsockopt(fd, SOL_SOCKET, SO_LINGER, (char*)&opt, sizeof(opt)) )
+ ShowWarning("setsocketopts: Unable to set SO_LINGER mode for connection #%d!\n", fd);
+ }
}
/*======================================
- * CORE : Socket Sub Function
+ * CORE : Socket Sub Function
*--------------------------------------*/
void set_eof(int fd)
{
- if (session_isActive(fd)) {
+ if( session_isActive(fd) )
+ {
#ifdef SEND_SHORTLIST
- // Add this socket to the shortlist for eof handling.
- send_shortlist_add_fd(fd);
+ // Add this socket to the shortlist for eof handling.
+ send_shortlist_add_fd(fd);
#endif
- session[fd]->flag.eof = 1;
- }
+ session[fd]->flag.eof = 1;
+ }
}
int recv_to_fifo(int fd)
{
- int len;
-
- if (!session_isActive(fd))
- return -1;
-
- len = sRecv(fd, (char *) session[fd]->rdata + session[fd]->rdata_size, (int)RFIFOSPACE(fd), 0);
-
- if (len == SOCKET_ERROR) {
- //An exception has occured
- if (sErrno != S_EWOULDBLOCK) {
- //ShowDebug("recv_to_fifo: %s, closing connection #%d\n", error_msg(), fd);
- set_eof(fd);
- }
- return 0;
- }
-
- if (len == 0) {
- //Normal connection end.
- set_eof(fd);
- return 0;
- }
-
- session[fd]->rdata_size += len;
- session[fd]->rdata_tick = last_tick;
- return 0;
+ int len;
+
+ if( !session_isActive(fd) )
+ return -1;
+
+ len = sRecv(fd, (char *) session[fd]->rdata + session[fd]->rdata_size, (int)RFIFOSPACE(fd), 0);
+
+ if( len == SOCKET_ERROR )
+ {//An exception has occured
+ if( sErrno != S_EWOULDBLOCK ) {
+ //ShowDebug("recv_to_fifo: %s, closing connection #%d\n", error_msg(), fd);
+ set_eof(fd);
+ }
+ return 0;
+ }
+
+ if( len == 0 )
+ {//Normal connection end.
+ set_eof(fd);
+ return 0;
+ }
+
+ session[fd]->rdata_size += len;
+ session[fd]->rdata_tick = last_tick;
+ return 0;
}
int send_from_fifo(int fd)
{
- int len;
+ int len;
- if (!session_isValid(fd))
- return -1;
+ if( !session_isValid(fd) )
+ return -1;
- if (session[fd]->wdata_size == 0)
- return 0; // nothing to send
+ if( session[fd]->wdata_size == 0 )
+ return 0; // nothing to send
- len = sSend(fd, (const char *) session[fd]->wdata, (int)session[fd]->wdata_size, MSG_NOSIGNAL);
+ len = sSend(fd, (const char *) session[fd]->wdata, (int)session[fd]->wdata_size, MSG_NOSIGNAL);
- if (len == SOCKET_ERROR) {
- //An exception has occured
- if (sErrno != S_EWOULDBLOCK) {
- //ShowDebug("send_from_fifo: %s, ending connection #%d\n", error_msg(), fd);
- session[fd]->wdata_size = 0; //Clear the send queue as we can't send anymore. [Skotlex]
- set_eof(fd);
- }
- return 0;
- }
+ if( len == SOCKET_ERROR )
+ {//An exception has occured
+ if( sErrno != S_EWOULDBLOCK ) {
+ //ShowDebug("send_from_fifo: %s, ending connection #%d\n", error_msg(), fd);
+ session[fd]->wdata_size = 0; //Clear the send queue as we can't send anymore. [Skotlex]
+ set_eof(fd);
+ }
+ return 0;
+ }
- if (len > 0) {
- // some data could not be transferred?
- // shift unsent data to the beginning of the queue
- if ((size_t)len < session[fd]->wdata_size)
- memmove(session[fd]->wdata, session[fd]->wdata + len, session[fd]->wdata_size - len);
+ if( len > 0 )
+ {
+ // some data could not be transferred?
+ // shift unsent data to the beginning of the queue
+ if( (size_t)len < session[fd]->wdata_size )
+ memmove(session[fd]->wdata, session[fd]->wdata + len, session[fd]->wdata_size - len);
- session[fd]->wdata_size -= len;
- }
+ session[fd]->wdata_size -= len;
+ }
- return 0;
+ return 0;
}
/// Best effort - there's no warranty that the data will be sent.
void flush_fifo(int fd)
{
- if (session[fd] != NULL)
- session[fd]->func_send(fd);
+ if(session[fd] != NULL)
+ session[fd]->func_send(fd);
}
void flush_fifos(void)
{
- int i;
- for (i = 1; i < fd_max; i++)
- flush_fifo(i);
+ int i;
+ for(i = 1; i < fd_max; i++)
+ flush_fifo(i);
}
/*======================================
- * CORE : Connection functions
+ * CORE : Connection functions
*--------------------------------------*/
int connect_client(int listen_fd)
{
- int fd;
- struct sockaddr_in client_address;
- socklen_t len;
-
- len = sizeof(client_address);
-
- fd = sAccept(listen_fd, (struct sockaddr *)&client_address, &len);
- if (fd == -1) {
- ShowError("connect_client: accept failed (%s)!\n", error_msg());
- return -1;
- }
- if (fd == 0) {
- // reserved
- ShowError("connect_client: Socket #0 is reserved - Please report this!!!\n");
- sClose(fd);
- return -1;
- }
- if (fd >= FD_SETSIZE) {
- // socket number too big
- ShowError("connect_client: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE);
- sClose(fd);
- return -1;
- }
-
- setsocketopts(fd);
- set_nonblocking(fd, 1);
+ int fd;
+ struct sockaddr_in client_address;
+ socklen_t len;
+
+ len = sizeof(client_address);
+
+ fd = sAccept(listen_fd, (struct sockaddr*)&client_address, &len);
+ if ( fd == -1 ) {
+ ShowError("connect_client: accept failed (%s)!\n", error_msg());
+ return -1;
+ }
+ if( fd == 0 )
+ {// reserved
+ ShowError("connect_client: Socket #0 is reserved - Please report this!!!\n");
+ sClose(fd);
+ return -1;
+ }
+ if( fd >= FD_SETSIZE )
+ {// socket number too big
+ ShowError("connect_client: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE);
+ sClose(fd);
+ return -1;
+ }
+
+ setsocketopts(fd);
+ set_nonblocking(fd, 1);
#ifndef MINICORE
- if (ip_rules && !connect_check(ntohl(client_address.sin_addr.s_addr))) {
- do_close(fd);
- return -1;
- }
+ if( ip_rules && !connect_check(ntohl(client_address.sin_addr.s_addr)) ) {
+ do_close(fd);
+ return -1;
+ }
#endif
- if (fd_max <= fd) fd_max = fd + 1;
- sFD_SET(fd,&readfds);
+ if( fd_max <= fd ) fd_max = fd + 1;
+ sFD_SET(fd,&readfds);
- create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
- session[fd]->client_addr = ntohl(client_address.sin_addr.s_addr);
+ create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
+ session[fd]->client_addr = ntohl(client_address.sin_addr.s_addr);
- return fd;
+ return fd;
}
int make_listen_bind(uint32 ip, uint16 port)
{
- struct sockaddr_in server_address;
- int fd;
- int result;
-
- fd = sSocket(AF_INET, SOCK_STREAM, 0);
-
- if (fd == -1) {
- ShowError("make_listen_bind: socket creation failed (%s)!\n", error_msg());
- exit(EXIT_FAILURE);
- }
- if (fd == 0) {
- // reserved
- ShowError("make_listen_bind: Socket #0 is reserved - Please report this!!!\n");
- sClose(fd);
- return -1;
- }
- if (fd >= FD_SETSIZE) {
- // socket number too big
- ShowError("make_listen_bind: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE);
- sClose(fd);
- return -1;
- }
-
- setsocketopts(fd);
- set_nonblocking(fd, 1);
-
- server_address.sin_family = AF_INET;
- server_address.sin_addr.s_addr = htonl(ip);
- server_address.sin_port = htons(port);
-
- result = sBind(fd, (struct sockaddr *)&server_address, sizeof(server_address));
- if (result == SOCKET_ERROR) {
- ShowError("make_listen_bind: bind failed (socket #%d, %s)!\n", fd, error_msg());
- exit(EXIT_FAILURE);
- }
- result = sListen(fd,5);
- if (result == SOCKET_ERROR) {
- ShowError("make_listen_bind: listen failed (socket #%d, %s)!\n", fd, error_msg());
- exit(EXIT_FAILURE);
- }
-
- if (fd_max <= fd) fd_max = fd + 1;
- sFD_SET(fd, &readfds);
-
- create_session(fd, connect_client, null_send, null_parse);
- session[fd]->client_addr = 0; // just listens
- session[fd]->rdata_tick = 0; // disable timeouts on this socket
-
- return fd;
+ struct sockaddr_in server_address;
+ int fd;
+ int result;
+
+ fd = sSocket(AF_INET, SOCK_STREAM, 0);
+
+ if( fd == -1 )
+ {
+ ShowError("make_listen_bind: socket creation failed (%s)!\n", error_msg());
+ exit(EXIT_FAILURE);
+ }
+ if( fd == 0 )
+ {// reserved
+ ShowError("make_listen_bind: Socket #0 is reserved - Please report this!!!\n");
+ sClose(fd);
+ return -1;
+ }
+ if( fd >= FD_SETSIZE )
+ {// socket number too big
+ ShowError("make_listen_bind: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE);
+ sClose(fd);
+ return -1;
+ }
+
+ setsocketopts(fd);
+ set_nonblocking(fd, 1);
+
+ server_address.sin_family = AF_INET;
+ server_address.sin_addr.s_addr = htonl(ip);
+ server_address.sin_port = htons(port);
+
+ result = sBind(fd, (struct sockaddr*)&server_address, sizeof(server_address));
+ if( result == SOCKET_ERROR ) {
+ ShowError("make_listen_bind: bind failed (socket #%d, %s)!\n", fd, error_msg());
+ exit(EXIT_FAILURE);
+ }
+ result = sListen(fd,5);
+ if( result == SOCKET_ERROR ) {
+ ShowError("make_listen_bind: listen failed (socket #%d, %s)!\n", fd, error_msg());
+ exit(EXIT_FAILURE);
+ }
+
+ if(fd_max <= fd) fd_max = fd + 1;
+ sFD_SET(fd, &readfds);
+
+ create_session(fd, connect_client, null_send, null_parse);
+ session[fd]->client_addr = 0; // just listens
+ session[fd]->rdata_tick = 0; // disable timeouts on this socket
+
+ return fd;
}
-int make_connection(uint32 ip, uint16 port, bool silent)
-{
- struct sockaddr_in remote_address;
- int fd;
- int result;
-
- fd = sSocket(AF_INET, SOCK_STREAM, 0);
-
- if (fd == -1) {
- ShowError("make_connection: socket creation failed (%s)!\n", error_msg());
- return -1;
- }
- if (fd == 0) {
- // reserved
- ShowError("make_connection: Socket #0 is reserved - Please report this!!!\n");
- sClose(fd);
- return -1;
- }
- if (fd >= FD_SETSIZE) {
- // socket number too big
- ShowError("make_connection: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE);
- sClose(fd);
- return -1;
- }
-
- setsocketopts(fd);
-
- remote_address.sin_family = AF_INET;
- remote_address.sin_addr.s_addr = htonl(ip);
- remote_address.sin_port = htons(port);
-
- if (!silent)
- ShowStatus("Connecting to %d.%d.%d.%d:%i\n", CONVIP(ip), port);
-
- result = sConnect(fd, (struct sockaddr *)(&remote_address), sizeof(struct sockaddr_in));
- if (result == SOCKET_ERROR) {
- if (!silent)
- ShowError("make_connection: connect failed (socket #%d, %s)!\n", fd, error_msg());
- do_close(fd);
- return -1;
- }
- //Now the socket can be made non-blocking. [Skotlex]
- set_nonblocking(fd, 1);
-
- if (fd_max <= fd) fd_max = fd + 1;
- sFD_SET(fd,&readfds);
-
- create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
- session[fd]->client_addr = ntohl(remote_address.sin_addr.s_addr);
-
- return fd;
+int make_connection(uint32 ip, uint16 port, bool silent) {
+ struct sockaddr_in remote_address;
+ int fd;
+ int result;
+
+ fd = sSocket(AF_INET, SOCK_STREAM, 0);
+
+ if (fd == -1) {
+ ShowError("make_connection: socket creation failed (%s)!\n", error_msg());
+ return -1;
+ }
+ if( fd == 0 )
+ {// reserved
+ ShowError("make_connection: Socket #0 is reserved - Please report this!!!\n");
+ sClose(fd);
+ return -1;
+ }
+ if( fd >= FD_SETSIZE )
+ {// socket number too big
+ ShowError("make_connection: New socket #%d is greater than can we handle! Increase the value of FD_SETSIZE (currently %d) for your OS to fix this!\n", fd, FD_SETSIZE);
+ sClose(fd);
+ return -1;
+ }
+
+ setsocketopts(fd);
+
+ remote_address.sin_family = AF_INET;
+ remote_address.sin_addr.s_addr = htonl(ip);
+ remote_address.sin_port = htons(port);
+
+ if( !silent )
+ ShowStatus("Connecting to %d.%d.%d.%d:%i\n", CONVIP(ip), port);
+
+ result = sConnect(fd, (struct sockaddr *)(&remote_address), sizeof(struct sockaddr_in));
+ if( result == SOCKET_ERROR ) {
+ if( !silent )
+ ShowError("make_connection: connect failed (socket #%d, %s)!\n", fd, error_msg());
+ do_close(fd);
+ return -1;
+ }
+ //Now the socket can be made non-blocking. [Skotlex]
+ set_nonblocking(fd, 1);
+
+ if (fd_max <= fd) fd_max = fd + 1;
+ sFD_SET(fd,&readfds);
+
+ create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse);
+ session[fd]->client_addr = ntohl(remote_address.sin_addr.s_addr);
+
+ return fd;
}
static int create_session(int fd, RecvFunc func_recv, SendFunc func_send, ParseFunc func_parse)
{
- CREATE(session[fd], struct socket_data, 1);
- CREATE(session[fd]->rdata, unsigned char, RFIFO_SIZE);
- CREATE(session[fd]->wdata, unsigned char, WFIFO_SIZE);
- session[fd]->max_rdata = RFIFO_SIZE;
- session[fd]->max_wdata = WFIFO_SIZE;
- session[fd]->func_recv = func_recv;
- session[fd]->func_send = func_send;
- session[fd]->func_parse = func_parse;
- session[fd]->rdata_tick = last_tick;
- return 0;
+ CREATE(session[fd], struct socket_data, 1);
+ CREATE(session[fd]->rdata, unsigned char, RFIFO_SIZE);
+ CREATE(session[fd]->wdata, unsigned char, WFIFO_SIZE);
+ session[fd]->max_rdata = RFIFO_SIZE;
+ session[fd]->max_wdata = WFIFO_SIZE;
+ session[fd]->func_recv = func_recv;
+ session[fd]->func_send = func_send;
+ session[fd]->func_parse = func_parse;
+ session[fd]->rdata_tick = last_tick;
+ return 0;
}
static void delete_session(int fd)
{
- if (session_isValid(fd)) {
- aFree(session[fd]->rdata);
- aFree(session[fd]->wdata);
- aFree(session[fd]->session_data);
- aFree(session[fd]);
- session[fd] = NULL;
- }
+ if( session_isValid(fd) )
+ {
+ aFree(session[fd]->rdata);
+ aFree(session[fd]->wdata);
+ aFree(session[fd]->session_data);
+ aFree(session[fd]);
+ session[fd] = NULL;
+ }
}
int realloc_fifo(int fd, unsigned int rfifo_size, unsigned int wfifo_size)
{
- if (!session_isValid(fd))
- return 0;
-
- if (session[fd]->max_rdata != rfifo_size && session[fd]->rdata_size < rfifo_size) {
- RECREATE(session[fd]->rdata, unsigned char, rfifo_size);
- session[fd]->max_rdata = rfifo_size;
- }
-
- if (session[fd]->max_wdata != wfifo_size && session[fd]->wdata_size < wfifo_size) {
- RECREATE(session[fd]->wdata, unsigned char, wfifo_size);
- session[fd]->max_wdata = wfifo_size;
- }
- return 0;
+ if( !session_isValid(fd) )
+ return 0;
+
+ if( session[fd]->max_rdata != rfifo_size && session[fd]->rdata_size < rfifo_size) {
+ RECREATE(session[fd]->rdata, unsigned char, rfifo_size);
+ session[fd]->max_rdata = rfifo_size;
+ }
+
+ if( session[fd]->max_wdata != wfifo_size && session[fd]->wdata_size < wfifo_size) {
+ RECREATE(session[fd]->wdata, unsigned char, wfifo_size);
+ session[fd]->max_wdata = wfifo_size;
+ }
+ return 0;
}
int realloc_writefifo(int fd, size_t addition)
{
- size_t newsize;
-
- if (!session_isValid(fd)) // might not happen
- return 0;
-
- if (session[fd]->wdata_size + addition > session[fd]->max_wdata) {
- // grow rule; grow in multiples of WFIFO_SIZE
- newsize = WFIFO_SIZE;
- while (session[fd]->wdata_size + addition > newsize) newsize += WFIFO_SIZE;
- } else if (session[fd]->max_wdata >= (size_t)2*(session[fd]->flag.server?FIFOSIZE_SERVERLINK:WFIFO_SIZE)
- && (session[fd]->wdata_size+addition)*4 < session[fd]->max_wdata) {
- // shrink rule, shrink by 2 when only a quarter of the fifo is used, don't shrink below nominal size.
- newsize = session[fd]->max_wdata / 2;
- } else // no change
- return 0;
-
- RECREATE(session[fd]->wdata, unsigned char, newsize);
- session[fd]->max_wdata = newsize;
-
- return 0;
+ size_t newsize;
+
+ if( !session_isValid(fd) ) // might not happen
+ return 0;
+
+ if( session[fd]->wdata_size + addition > session[fd]->max_wdata )
+ { // grow rule; grow in multiples of WFIFO_SIZE
+ newsize = WFIFO_SIZE;
+ while( session[fd]->wdata_size + addition > newsize ) newsize += WFIFO_SIZE;
+ }
+ else
+ if( session[fd]->max_wdata >= (size_t)2*(session[fd]->flag.server?FIFOSIZE_SERVERLINK:WFIFO_SIZE)
+ && (session[fd]->wdata_size+addition)*4 < session[fd]->max_wdata )
+ { // shrink rule, shrink by 2 when only a quarter of the fifo is used, don't shrink below nominal size.
+ newsize = session[fd]->max_wdata / 2;
+ }
+ else // no change
+ return 0;
+
+ RECREATE(session[fd]->wdata, unsigned char, newsize);
+ session[fd]->max_wdata = newsize;
+
+ return 0;
}
/// advance the RFIFO cursor (marking 'len' bytes as processed)
@@ -632,186 +629,197 @@ int RFIFOSKIP(int fd, size_t len)
{
struct socket_data *s;
- if (!session_isActive(fd))
- return 0;
+ if ( !session_isActive(fd) )
+ return 0;
- s = session[fd];
+ s = session[fd];
- if (s->rdata_size < s->rdata_pos + len) {
- ShowError("RFIFOSKIP: skipped past end of read buffer! Adjusting from %d to %d (session #%d)\n", len, RFIFOREST(fd), fd);
- len = RFIFOREST(fd);
- }
+ if ( s->rdata_size < s->rdata_pos + len ) {
+ ShowError("RFIFOSKIP: skipped past end of read buffer! Adjusting from %d to %d (session #%d)\n", len, RFIFOREST(fd), fd);
+ len = RFIFOREST(fd);
+ }
- s->rdata_pos = s->rdata_pos + len;
- return 0;
+ s->rdata_pos = s->rdata_pos + len;
+ return 0;
}
/// advance the WFIFO cursor (marking 'len' bytes for sending)
int WFIFOSET(int fd, size_t len)
{
- size_t newreserve;
- struct socket_data *s = session[fd];
-
- if (!session_isValid(fd) || s->wdata == NULL)
- return 0;
-
- // we have written len bytes to the buffer already before calling WFIFOSET
- if (s->wdata_size+len > s->max_wdata) {
- // actually there was a buffer overflow already
- uint32 ip = s->client_addr;
- ShowFatalError("WFIFOSET: Write Buffer Overflow. Connection %d (%d.%d.%d.%d) has written %u bytes on a %u/%u bytes buffer.\n", fd, CONVIP(ip), (unsigned int)len, (unsigned int)s->wdata_size, (unsigned int)s->max_wdata);
- ShowDebug("Likely command that caused it: 0x%x\n", (*(uint16 *)(s->wdata + s->wdata_size)));
- // no other chance, make a better fifo model
- exit(EXIT_FAILURE);
- }
-
- if (len > 0xFFFF) {
- // dynamic packets allow up to UINT16_MAX bytes (<packet_id>.W <packet_len>.W ...)
- // all known fixed-size packets are within this limit, so use the same limit
- ShowFatalError("WFIFOSET: Packet 0x%x is too big. (len=%u, max=%u)\n", (*(uint16 *)(s->wdata + s->wdata_size)), (unsigned int)len, 0xFFFF);
- exit(EXIT_FAILURE);
- } else if (len == 0) {
- // abuses the fact, that the code that did WFIFOHEAD(fd,0), already wrote
- // the packet type into memory, even if it could have overwritten vital data
- // this can happen when a new packet was added on map-server, but packet len table was not updated
- ShowWarning("WFIFOSET: Attempted to send zero-length packet, most likely 0x%04x (please report this).\n", WFIFOW(fd,0));
- return 0;
- }
-
- if (!s->flag.server) {
-
- if (len > socket_max_client_packet) { // see declaration of socket_max_client_packet for details
- ShowError("WFIFOSET: Dropped too large client packet 0x%04x (length=%u, max=%u).\n", WFIFOW(fd,0), len, socket_max_client_packet);
- return 0;
- }
-
- if (s->wdata_size+len > WFIFO_MAX) { // reached maximum write fifo size
- ShowError("WFIFOSET: Maximum write buffer size for client connection %d exceeded, most likely caused by packet 0x%04x (len=%u, ip=%lu.%lu.%lu.%lu).\n", fd, WFIFOW(fd,0), len, CONVIP(s->client_addr));
- set_eof(fd);
- return 0;
- }
-
- }
- s->wdata_size += len;
- //If the interserver has 200% of its normal size full, flush the data.
- if (s->flag.server && s->wdata_size >= 2*FIFOSIZE_SERVERLINK)
- flush_fifo(fd);
-
- // always keep a WFIFO_SIZE reserve in the buffer
- // For inter-server connections, let the reserve be 1/4th of the link size.
- newreserve = s->flag.server ? FIFOSIZE_SERVERLINK / 4 : WFIFO_SIZE;
-
- // readjust the buffer to include the chosen reserve
- realloc_writefifo(fd, newreserve);
+ size_t newreserve;
+ struct socket_data* s = session[fd];
+
+ if( !session_isValid(fd) || s->wdata == NULL )
+ return 0;
+
+ // we have written len bytes to the buffer already before calling WFIFOSET
+ if(s->wdata_size+len > s->max_wdata)
+ { // actually there was a buffer overflow already
+ uint32 ip = s->client_addr;
+ ShowFatalError("WFIFOSET: Write Buffer Overflow. Connection %d (%d.%d.%d.%d) has written %u bytes on a %u/%u bytes buffer.\n", fd, CONVIP(ip), (unsigned int)len, (unsigned int)s->wdata_size, (unsigned int)s->max_wdata);
+ ShowDebug("Likely command that caused it: 0x%x\n", (*(uint16*)(s->wdata + s->wdata_size)));
+ // no other chance, make a better fifo model
+ exit(EXIT_FAILURE);
+ }
+
+ if( len > 0xFFFF )
+ {
+ // dynamic packets allow up to UINT16_MAX bytes (<packet_id>.W <packet_len>.W ...)
+ // all known fixed-size packets are within this limit, so use the same limit
+ ShowFatalError("WFIFOSET: Packet 0x%x is too big. (len=%u, max=%u)\n", (*(uint16*)(s->wdata + s->wdata_size)), (unsigned int)len, 0xFFFF);
+ exit(EXIT_FAILURE);
+ }
+ else if( len == 0 )
+ {
+ // abuses the fact, that the code that did WFIFOHEAD(fd,0), already wrote
+ // the packet type into memory, even if it could have overwritten vital data
+ // this can happen when a new packet was added on map-server, but packet len table was not updated
+ ShowWarning("WFIFOSET: Attempted to send zero-length packet, most likely 0x%04x (please report this).\n", WFIFOW(fd,0));
+ return 0;
+ }
+
+ if( !s->flag.server ) {
+
+ if( len > socket_max_client_packet ) {// see declaration of socket_max_client_packet for details
+ ShowError("WFIFOSET: Dropped too large client packet 0x%04x (length=%u, max=%u).\n", WFIFOW(fd,0), len, socket_max_client_packet);
+ return 0;
+ }
+
+ if( s->wdata_size+len > WFIFO_MAX ) {// reached maximum write fifo size
+ ShowError("WFIFOSET: Maximum write buffer size for client connection %d exceeded, most likely caused by packet 0x%04x (len=%u, ip=%lu.%lu.%lu.%lu).\n", fd, WFIFOW(fd,0), len, CONVIP(s->client_addr));
+ set_eof(fd);
+ return 0;
+ }
+
+ }
+ s->wdata_size += len;
+ //If the interserver has 200% of its normal size full, flush the data.
+ if( s->flag.server && s->wdata_size >= 2*FIFOSIZE_SERVERLINK )
+ flush_fifo(fd);
+
+ // always keep a WFIFO_SIZE reserve in the buffer
+ // For inter-server connections, let the reserve be 1/4th of the link size.
+ newreserve = s->flag.server ? FIFOSIZE_SERVERLINK / 4 : WFIFO_SIZE;
+
+ // readjust the buffer to include the chosen reserve
+ realloc_writefifo(fd, newreserve);
#ifdef SEND_SHORTLIST
- send_shortlist_add_fd(fd);
+ send_shortlist_add_fd(fd);
#endif
- return 0;
+ return 0;
}
int do_sockets(int next)
{
- fd_set rfd;
- struct timeval timeout;
- int ret,i;
+ fd_set rfd;
+ struct timeval timeout;
+ int ret,i;
- // PRESEND Timers are executed before do_sendrecv and can send packets and/or set sessions to eof.
- // Send remaining data and process client-side disconnects here.
+ // PRESEND Timers are executed before do_sendrecv and can send packets and/or set sessions to eof.
+ // Send remaining data and process client-side disconnects here.
#ifdef SEND_SHORTLIST
- send_shortlist_do_sends();
+ send_shortlist_do_sends();
#else
- for (i = 1; i < fd_max; i++) {
- if (!session[i])
- continue;
-
- if (session[i]->wdata_size)
- session[i]->func_send(i);
- }
+ for (i = 1; i < fd_max; i++)
+ {
+ if(!session[i])
+ continue;
+
+ if(session[i]->wdata_size)
+ session[i]->func_send(i);
+ }
#endif
- // can timeout until the next tick
- timeout.tv_sec = next/1000;
- timeout.tv_usec = next%1000*1000;
+ // can timeout until the next tick
+ timeout.tv_sec = next/1000;
+ timeout.tv_usec = next%1000*1000;
- memcpy(&rfd, &readfds, sizeof(rfd));
- ret = sSelect(fd_max, &rfd, NULL, NULL, &timeout);
+ memcpy(&rfd, &readfds, sizeof(rfd));
+ ret = sSelect(fd_max, &rfd, NULL, NULL, &timeout);
- if (ret == SOCKET_ERROR) {
- if (sErrno != S_EINTR) {
- ShowFatalError("do_sockets: select() failed, %s!\n", error_msg());
- exit(EXIT_FAILURE);
- }
- return 0; // interrupted by a signal, just loop and try again
- }
+ if( ret == SOCKET_ERROR )
+ {
+ if( sErrno != S_EINTR )
+ {
+ ShowFatalError("do_sockets: select() failed, %s!\n", error_msg());
+ exit(EXIT_FAILURE);
+ }
+ return 0; // interrupted by a signal, just loop and try again
+ }
- last_tick = time(NULL);
+ last_tick = time(NULL);
#if defined(WIN32)
- // on windows, enumerating all members of the fd_set is way faster if we access the internals
- for (i = 0; i < (int)rfd.fd_count; ++i) {
- int fd = sock2fd(rfd.fd_array[i]);
- if (session[fd])
- session[fd]->func_recv(fd);
- }
+ // on windows, enumerating all members of the fd_set is way faster if we access the internals
+ for( i = 0; i < (int)rfd.fd_count; ++i )
+ {
+ int fd = sock2fd(rfd.fd_array[i]);
+ if( session[fd] )
+ session[fd]->func_recv(fd);
+ }
#else
- // otherwise assume that the fd_set is a bit-array and enumerate it in a standard way
- for (i = 1; ret && i < fd_max; ++i) {
- if (sFD_ISSET(i,&rfd) && session[i]) {
- session[i]->func_recv(i);
- --ret;
- }
- }
+ // otherwise assume that the fd_set is a bit-array and enumerate it in a standard way
+ for( i = 1; ret && i < fd_max; ++i )
+ {
+ if(sFD_ISSET(i,&rfd) && session[i])
+ {
+ session[i]->func_recv(i);
+ --ret;
+ }
+ }
#endif
- // POSTSEND Send remaining data and handle eof sessions.
+ // POSTSEND Send remaining data and handle eof sessions.
#ifdef SEND_SHORTLIST
- send_shortlist_do_sends();
+ send_shortlist_do_sends();
#else
- for (i = 1; i < fd_max; i++) {
- if (!session[i])
- continue;
-
- if (session[i]->wdata_size)
- session[i]->func_send(i);
-
- if (session[i]->flag.eof) { //func_send can't free a session, this is safe.
- //Finally, even if there is no data to parse, connections signalled eof should be closed, so we call parse_func [Skotlex]
- session[i]->func_parse(i); //This should close the session immediately.
- }
- }
+ for (i = 1; i < fd_max; i++)
+ {
+ if(!session[i])
+ continue;
+
+ if(session[i]->wdata_size)
+ session[i]->func_send(i);
+
+ if(session[i]->flag.eof) //func_send can't free a session, this is safe.
+ { //Finally, even if there is no data to parse, connections signalled eof should be closed, so we call parse_func [Skotlex]
+ session[i]->func_parse(i); //This should close the session immediately.
+ }
+ }
#endif
- // parse input data on each socket
- for (i = 1; i < fd_max; i++) {
- if (!session[i])
- continue;
-
- if (session[i]->rdata_tick && DIFF_TICK(last_tick, session[i]->rdata_tick) > stall_time) {
- if (session[i]->flag.server) { /* server is special */
- if (session[i]->flag.ping != 2) /* only update if necessary otherwise it'd resend the ping unnecessarily */
- session[i]->flag.ping = 1;
- } else {
- ShowInfo("Session #%d timed out\n", i);
- set_eof(i);
- }
- }
-
- session[i]->func_parse(i);
-
- if (!session[i])
- continue;
-
- // after parse, check client's RFIFO size to know if there is an invalid packet (too big and not parsed)
- if (session[i]->rdata_size == RFIFO_SIZE && session[i]->max_rdata == RFIFO_SIZE) {
- set_eof(i);
- continue;
- }
- RFIFOFLUSH(i);
- }
-
- return 0;
+ // parse input data on each socket
+ for(i = 1; i < fd_max; i++)
+ {
+ if(!session[i])
+ continue;
+
+ if (session[i]->rdata_tick && DIFF_TICK(last_tick, session[i]->rdata_tick) > stall_time) {
+ if( session[i]->flag.server ) {/* server is special */
+ if( session[i]->flag.ping != 2 )/* only update if necessary otherwise it'd resend the ping unnecessarily */
+ session[i]->flag.ping = 1;
+ } else {
+ ShowInfo("Session #%d timed out\n", i);
+ set_eof(i);
+ }
+ }
+
+ session[i]->func_parse(i);
+
+ if(!session[i])
+ continue;
+
+ // after parse, check client's RFIFO size to know if there is an invalid packet (too big and not parsed)
+ if (session[i]->rdata_size == RFIFO_SIZE && session[i]->max_rdata == RFIFO_SIZE) {
+ set_eof(i);
+ continue;
+ }
+ RFIFOFLUSH(i);
+ }
+
+ return 0;
}
//////////////////////////////
@@ -820,26 +828,26 @@ int do_sockets(int next)
// IP rules and DDoS protection
typedef struct _connect_history {
- struct _connect_history *next;
- uint32 ip;
- uint32 tick;
- int count;
- unsigned ddos : 1;
+ struct _connect_history* next;
+ uint32 ip;
+ uint32 tick;
+ int count;
+ unsigned ddos : 1;
} ConnectHistory;
typedef struct _access_control {
- uint32 ip;
- uint32 mask;
+ uint32 ip;
+ uint32 mask;
} AccessControl;
enum _aco {
- ACO_DENY_ALLOW,
- ACO_ALLOW_DENY,
- ACO_MUTUAL_FAILURE
+ ACO_DENY_ALLOW,
+ ACO_ALLOW_DENY,
+ ACO_MUTUAL_FAILURE
};
-static AccessControl *access_allow = NULL;
-static AccessControl *access_deny = NULL;
+static AccessControl* access_allow = NULL;
+static AccessControl* access_deny = NULL;
static int access_order = ACO_DENY_ALLOW;
static int access_allownum = 0;
static int access_denynum = 0;
@@ -849,7 +857,7 @@ static int ddos_interval = 3*1000;
static int ddos_autoreset = 10*60*1000;
/// Connection history, an array of linked lists.
/// The array's index for any ip is ip&0xFFFF
-static ConnectHistory *connect_history[0x10000];
+static ConnectHistory* connect_history[0x10000];
static int connect_check_(uint32 ip);
@@ -857,11 +865,11 @@ static int connect_check_(uint32 ip);
/// @see connect_check_()
static int connect_check(uint32 ip)
{
- int result = connect_check_(ip);
- if (access_debug) {
- ShowInfo("connect_check: Connection from %d.%d.%d.%d %s\n", CONVIP(ip),result ? "allowed." : "denied!");
- }
- return result;
+ int result = connect_check_(ip);
+ if( access_debug ) {
+ ShowInfo("connect_check: Connection from %d.%d.%d.%d %s\n", CONVIP(ip),result ? "allowed." : "denied!");
+ }
+ return result;
}
/// Verifies if the IP can connect.
@@ -869,494 +877,504 @@ static int connect_check(uint32 ip)
/// 1 or 2 : Connection Accepted
static int connect_check_(uint32 ip)
{
- ConnectHistory *hist = connect_history[ip&0xFFFF];
- int i;
- int is_allowip = 0;
- int is_denyip = 0;
- int connect_ok = 0;
-
- // Search the allow list
- for (i=0; i < access_allownum; ++i) {
- if ((ip & access_allow[i].mask) == (access_allow[i].ip & access_allow[i].mask)) {
- if (access_debug) {
- ShowInfo("connect_check: Found match from allow list:%d.%d.%d.%d IP:%d.%d.%d.%d Mask:%d.%d.%d.%d\n",
- CONVIP(ip),
- CONVIP(access_allow[i].ip),
- CONVIP(access_allow[i].mask));
- }
- is_allowip = 1;
- break;
- }
- }
- // Search the deny list
- for (i=0; i < access_denynum; ++i) {
- if ((ip & access_deny[i].mask) == (access_deny[i].ip & access_deny[i].mask)) {
- if (access_debug) {
- ShowInfo("connect_check: Found match from deny list:%d.%d.%d.%d IP:%d.%d.%d.%d Mask:%d.%d.%d.%d\n",
- CONVIP(ip),
- CONVIP(access_deny[i].ip),
- CONVIP(access_deny[i].mask));
- }
- is_denyip = 1;
- break;
- }
- }
- // Decide connection status
- // 0 : Reject
- // 1 : Accept
- // 2 : Unconditional Accept (accepts even if flagged as DDoS)
- switch (access_order) {
- case ACO_DENY_ALLOW:
- default:
- if (is_denyip)
- connect_ok = 0; // Reject
- else if (is_allowip)
- connect_ok = 2; // Unconditional Accept
- else
- connect_ok = 1; // Accept
- break;
- case ACO_ALLOW_DENY:
- if (is_allowip)
- connect_ok = 2; // Unconditional Accept
- else if (is_denyip)
- connect_ok = 0; // Reject
- else
- connect_ok = 1; // Accept
- break;
- case ACO_MUTUAL_FAILURE:
- if (is_allowip && !is_denyip)
- connect_ok = 2; // Unconditional Accept
- else
- connect_ok = 0; // Reject
- break;
- }
-
- // Inspect connection history
- while (hist) {
- if (ip == hist->ip) {
- // IP found
- if (hist->ddos) {
- // flagged as DDoS
- return (connect_ok == 2 ? 1 : 0);
- } else if (DIFF_TICK(gettick(),hist->tick) < ddos_interval) {
- // connection within ddos_interval
- hist->tick = gettick();
- if (hist->count++ >= ddos_count) {
- // DDoS attack detected
- hist->ddos = 1;
- ShowWarning("connect_check: DDoS Attack detected from %d.%d.%d.%d!\n", CONVIP(ip));
- return (connect_ok == 2 ? 1 : 0);
- }
- return connect_ok;
- } else {
- // not within ddos_interval, clear data
- hist->tick = gettick();
- hist->count = 0;
- return connect_ok;
- }
- }
- hist = hist->next;
- }
- // IP not found, add to history
- CREATE(hist, ConnectHistory, 1);
- memset(hist, 0, sizeof(ConnectHistory));
- hist->ip = ip;
- hist->tick = gettick();
- hist->next = connect_history[ip&0xFFFF];
- connect_history[ip&0xFFFF] = hist;
- return connect_ok;
+ ConnectHistory* hist = connect_history[ip&0xFFFF];
+ int i;
+ int is_allowip = 0;
+ int is_denyip = 0;
+ int connect_ok = 0;
+
+ // Search the allow list
+ for( i=0; i < access_allownum; ++i ){
+ if( (ip & access_allow[i].mask) == (access_allow[i].ip & access_allow[i].mask) ){
+ if( access_debug ){
+ ShowInfo("connect_check: Found match from allow list:%d.%d.%d.%d IP:%d.%d.%d.%d Mask:%d.%d.%d.%d\n",
+ CONVIP(ip),
+ CONVIP(access_allow[i].ip),
+ CONVIP(access_allow[i].mask));
+ }
+ is_allowip = 1;
+ break;
+ }
+ }
+ // Search the deny list
+ for( i=0; i < access_denynum; ++i ){
+ if( (ip & access_deny[i].mask) == (access_deny[i].ip & access_deny[i].mask) ){
+ if( access_debug ){
+ ShowInfo("connect_check: Found match from deny list:%d.%d.%d.%d IP:%d.%d.%d.%d Mask:%d.%d.%d.%d\n",
+ CONVIP(ip),
+ CONVIP(access_deny[i].ip),
+ CONVIP(access_deny[i].mask));
+ }
+ is_denyip = 1;
+ break;
+ }
+ }
+ // Decide connection status
+ // 0 : Reject
+ // 1 : Accept
+ // 2 : Unconditional Accept (accepts even if flagged as DDoS)
+ switch(access_order) {
+ case ACO_DENY_ALLOW:
+ default:
+ if( is_denyip )
+ connect_ok = 0; // Reject
+ else if( is_allowip )
+ connect_ok = 2; // Unconditional Accept
+ else
+ connect_ok = 1; // Accept
+ break;
+ case ACO_ALLOW_DENY:
+ if( is_allowip )
+ connect_ok = 2; // Unconditional Accept
+ else if( is_denyip )
+ connect_ok = 0; // Reject
+ else
+ connect_ok = 1; // Accept
+ break;
+ case ACO_MUTUAL_FAILURE:
+ if( is_allowip && !is_denyip )
+ connect_ok = 2; // Unconditional Accept
+ else
+ connect_ok = 0; // Reject
+ break;
+ }
+
+ // Inspect connection history
+ while( hist ) {
+ if( ip == hist->ip )
+ {// IP found
+ if( hist->ddos )
+ {// flagged as DDoS
+ return (connect_ok == 2 ? 1 : 0);
+ } else if( DIFF_TICK(gettick(),hist->tick) < ddos_interval )
+ {// connection within ddos_interval
+ hist->tick = gettick();
+ if( hist->count++ >= ddos_count )
+ {// DDoS attack detected
+ hist->ddos = 1;
+ ShowWarning("connect_check: DDoS Attack detected from %d.%d.%d.%d!\n", CONVIP(ip));
+ return (connect_ok == 2 ? 1 : 0);
+ }
+ return connect_ok;
+ } else
+ {// not within ddos_interval, clear data
+ hist->tick = gettick();
+ hist->count = 0;
+ return connect_ok;
+ }
+ }
+ hist = hist->next;
+ }
+ // IP not found, add to history
+ CREATE(hist, ConnectHistory, 1);
+ memset(hist, 0, sizeof(ConnectHistory));
+ hist->ip = ip;
+ hist->tick = gettick();
+ hist->next = connect_history[ip&0xFFFF];
+ connect_history[ip&0xFFFF] = hist;
+ return connect_ok;
}
/// Timer function.
/// Deletes old connection history records.
static int connect_check_clear(int tid, unsigned int tick, int id, intptr_t data)
{
- int i;
- int clear = 0;
- int list = 0;
- ConnectHistory root;
- ConnectHistory *prev_hist;
- ConnectHistory *hist;
-
- for (i=0; i < 0x10000 ; ++i) {
- prev_hist = &root;
- root.next = hist = connect_history[i];
- while (hist) {
- if ((!hist->ddos && DIFF_TICK(tick,hist->tick) > ddos_interval*3) ||
- (hist->ddos && DIFF_TICK(tick,hist->tick) > ddos_autoreset)) {
- // Remove connection history
- prev_hist->next = hist->next;
- aFree(hist);
- hist = prev_hist->next;
- clear++;
- } else {
- prev_hist = hist;
- hist = hist->next;
- }
- list++;
- }
- connect_history[i] = root.next;
- }
- if (access_debug) {
- ShowInfo("connect_check_clear: Cleared %d of %d from IP list.\n", clear, list);
- }
- return list;
+ int i;
+ int clear = 0;
+ int list = 0;
+ ConnectHistory root;
+ ConnectHistory* prev_hist;
+ ConnectHistory* hist;
+
+ for( i=0; i < 0x10000 ; ++i ){
+ prev_hist = &root;
+ root.next = hist = connect_history[i];
+ while( hist ){
+ if( (!hist->ddos && DIFF_TICK(tick,hist->tick) > ddos_interval*3) ||
+ (hist->ddos && DIFF_TICK(tick,hist->tick) > ddos_autoreset) )
+ {// Remove connection history
+ prev_hist->next = hist->next;
+ aFree(hist);
+ hist = prev_hist->next;
+ clear++;
+ } else {
+ prev_hist = hist;
+ hist = hist->next;
+ }
+ list++;
+ }
+ connect_history[i] = root.next;
+ }
+ if( access_debug ){
+ ShowInfo("connect_check_clear: Cleared %d of %d from IP list.\n", clear, list);
+ }
+ return list;
}
/// Parses the ip address and mask and puts it into acc.
/// Returns 1 is successful, 0 otherwise.
-int access_ipmask(const char *str, AccessControl *acc)
+int access_ipmask(const char* str, AccessControl* acc)
{
- uint32 ip;
- uint32 mask;
- unsigned int a[4];
- unsigned int m[4];
- int n;
-
- if (strcmp(str,"all") == 0) {
- ip = 0;
- mask = 0;
- } else {
- if (((n=sscanf(str,"%u.%u.%u.%u/%u.%u.%u.%u",a,a+1,a+2,a+3,m,m+1,m+2,m+3)) != 8 && // not an ip + standard mask
- (n=sscanf(str,"%u.%u.%u.%u/%u",a,a+1,a+2,a+3,m)) != 5 && // not an ip + bit mask
- (n=sscanf(str,"%u.%u.%u.%u",a,a+1,a+2,a+3)) != 4) || // not an ip
- a[0] > 255 || a[1] > 255 || a[2] > 255 || a[3] > 255 || // invalid ip
- (n == 8 && (m[0] > 255 || m[1] > 255 || m[2] > 255 || m[3] > 255)) || // invalid standard mask
- (n == 5 && m[0] > 32)) { // invalid bit mask
- return 0;
- }
- ip = MAKEIP(a[0],a[1],a[2],a[3]);
- if (n == 8) {
- // standard mask
- mask = MAKEIP(m[0],m[1],m[2],m[3]);
- } else if (n == 5) {
- // bit mask
- mask = 0;
- while (m[0]) {
- mask = (mask >> 1) | 0x80000000;
- --m[0];
- }
- } else {
- // just this ip
- mask = 0xFFFFFFFF;
- }
- }
- if (access_debug) {
- ShowInfo("access_ipmask: Loaded IP:%d.%d.%d.%d mask:%d.%d.%d.%d\n", CONVIP(ip), CONVIP(mask));
- }
- acc->ip = ip;
- acc->mask = mask;
- return 1;
+ uint32 ip;
+ uint32 mask;
+ unsigned int a[4];
+ unsigned int m[4];
+ int n;
+
+ if( strcmp(str,"all") == 0 ) {
+ ip = 0;
+ mask = 0;
+ } else {
+ if( ((n=sscanf(str,"%u.%u.%u.%u/%u.%u.%u.%u",a,a+1,a+2,a+3,m,m+1,m+2,m+3)) != 8 && // not an ip + standard mask
+ (n=sscanf(str,"%u.%u.%u.%u/%u",a,a+1,a+2,a+3,m)) != 5 && // not an ip + bit mask
+ (n=sscanf(str,"%u.%u.%u.%u",a,a+1,a+2,a+3)) != 4 ) || // not an ip
+ a[0] > 255 || a[1] > 255 || a[2] > 255 || a[3] > 255 || // invalid ip
+ (n == 8 && (m[0] > 255 || m[1] > 255 || m[2] > 255 || m[3] > 255)) || // invalid standard mask
+ (n == 5 && m[0] > 32) ){ // invalid bit mask
+ return 0;
+ }
+ ip = MAKEIP(a[0],a[1],a[2],a[3]);
+ if( n == 8 )
+ {// standard mask
+ mask = MAKEIP(m[0],m[1],m[2],m[3]);
+ } else if( n == 5 )
+ {// bit mask
+ mask = 0;
+ while( m[0] ){
+ mask = (mask >> 1) | 0x80000000;
+ --m[0];
+ }
+ } else
+ {// just this ip
+ mask = 0xFFFFFFFF;
+ }
+ }
+ if( access_debug ){
+ ShowInfo("access_ipmask: Loaded IP:%d.%d.%d.%d mask:%d.%d.%d.%d\n", CONVIP(ip), CONVIP(mask));
+ }
+ acc->ip = ip;
+ acc->mask = mask;
+ return 1;
}
//////////////////////////////
#endif
//////////////////////////////
-int socket_config_read(const char *cfgName)
+int socket_config_read(const char* cfgName)
{
- char line[1024],w1[1024],w2[1024];
- FILE *fp;
-
- fp = fopen(cfgName, "r");
- if (fp == NULL) {
- ShowError("File not found: %s\n", cfgName);
- return 1;
- }
-
- while (fgets(line, sizeof(line), fp)) {
- if (line[0] == '/' && line[1] == '/')
- continue;
- if (sscanf(line, "%[^:]: %[^\r\n]", w1, w2) != 2)
- continue;
-
- if (!strcmpi(w1, "stall_time")) {
- stall_time = atoi(w2);
- if (stall_time < 3)
- stall_time = 3;/* a minimum is required to refrain it from killing itself */
- }
+ char line[1024],w1[1024],w2[1024];
+ FILE *fp;
+
+ fp = fopen(cfgName, "r");
+ if(fp == NULL) {
+ ShowError("File not found: %s\n", cfgName);
+ return 1;
+ }
+
+ while(fgets(line, sizeof(line), fp))
+ {
+ if(line[0] == '/' && line[1] == '/')
+ continue;
+ if(sscanf(line, "%[^:]: %[^\r\n]", w1, w2) != 2)
+ continue;
+
+ if (!strcmpi(w1, "stall_time")) {
+ stall_time = atoi(w2);
+ if( stall_time < 3 )
+ stall_time = 3;/* a minimum is required to refrain it from killing itself */
+ }
#ifndef MINICORE
- else if (!strcmpi(w1, "enable_ip_rules")) {
- ip_rules = config_switch(w2);
- } else if (!strcmpi(w1, "order")) {
- if (!strcmpi(w2, "deny,allow"))
- access_order = ACO_DENY_ALLOW;
- else if (!strcmpi(w2, "allow,deny"))
- access_order = ACO_ALLOW_DENY;
- else if (!strcmpi(w2, "mutual-failure"))
- access_order = ACO_MUTUAL_FAILURE;
- } else if (!strcmpi(w1, "allow")) {
- RECREATE(access_allow, AccessControl, access_allownum+1);
- if (access_ipmask(w2, &access_allow[access_allownum]))
- ++access_allownum;
- else
- ShowError("socket_config_read: Invalid ip or ip range '%s'!\n", line);
- } else if (!strcmpi(w1, "deny")) {
- RECREATE(access_deny, AccessControl, access_denynum+1);
- if (access_ipmask(w2, &access_deny[access_denynum]))
- ++access_denynum;
- else
- ShowError("socket_config_read: Invalid ip or ip range '%s'!\n", line);
- } else if (!strcmpi(w1,"ddos_interval"))
- ddos_interval = atoi(w2);
- else if (!strcmpi(w1,"ddos_count"))
- ddos_count = atoi(w2);
- else if (!strcmpi(w1,"ddos_autoreset"))
- ddos_autoreset = atoi(w2);
- else if (!strcmpi(w1,"debug"))
- access_debug = config_switch(w2);
- else if (!strcmpi(w1,"socket_max_client_packet"))
- socket_max_client_packet = strtoul(w2, NULL, 0);
+ else if (!strcmpi(w1, "enable_ip_rules")) {
+ ip_rules = config_switch(w2);
+ } else if (!strcmpi(w1, "order")) {
+ if (!strcmpi(w2, "deny,allow"))
+ access_order = ACO_DENY_ALLOW;
+ else if (!strcmpi(w2, "allow,deny"))
+ access_order = ACO_ALLOW_DENY;
+ else if (!strcmpi(w2, "mutual-failure"))
+ access_order = ACO_MUTUAL_FAILURE;
+ } else if (!strcmpi(w1, "allow")) {
+ RECREATE(access_allow, AccessControl, access_allownum+1);
+ if (access_ipmask(w2, &access_allow[access_allownum]))
+ ++access_allownum;
+ else
+ ShowError("socket_config_read: Invalid ip or ip range '%s'!\n", line);
+ } else if (!strcmpi(w1, "deny")) {
+ RECREATE(access_deny, AccessControl, access_denynum+1);
+ if (access_ipmask(w2, &access_deny[access_denynum]))
+ ++access_denynum;
+ else
+ ShowError("socket_config_read: Invalid ip or ip range '%s'!\n", line);
+ }
+ else if (!strcmpi(w1,"ddos_interval"))
+ ddos_interval = atoi(w2);
+ else if (!strcmpi(w1,"ddos_count"))
+ ddos_count = atoi(w2);
+ else if (!strcmpi(w1,"ddos_autoreset"))
+ ddos_autoreset = atoi(w2);
+ else if (!strcmpi(w1,"debug"))
+ access_debug = config_switch(w2);
+ else if (!strcmpi(w1,"socket_max_client_packet"))
+ socket_max_client_packet = strtoul(w2, NULL, 0);
#endif
- else if (!strcmpi(w1, "import"))
- socket_config_read(w2);
- else
- ShowWarning("Unknown setting '%s' in file %s\n", w1, cfgName);
- }
-
- fclose(fp);
- return 0;
+ else if (!strcmpi(w1, "import"))
+ socket_config_read(w2);
+ else
+ ShowWarning("Unknown setting '%s' in file %s\n", w1, cfgName);
+ }
+
+ fclose(fp);
+ return 0;
}
void socket_final(void)
{
- int i;
+ int i;
#ifndef MINICORE
- ConnectHistory *hist;
- ConnectHistory *next_hist;
-
- for (i=0; i < 0x10000; ++i) {
- hist = connect_history[i];
- while (hist) {
- next_hist = hist->next;
- aFree(hist);
- hist = next_hist;
- }
- }
- if (access_allow)
- aFree(access_allow);
- if (access_deny)
- aFree(access_deny);
+ ConnectHistory* hist;
+ ConnectHistory* next_hist;
+
+ for( i=0; i < 0x10000; ++i ){
+ hist = connect_history[i];
+ while( hist ){
+ next_hist = hist->next;
+ aFree(hist);
+ hist = next_hist;
+ }
+ }
+ if( access_allow )
+ aFree(access_allow);
+ if( access_deny )
+ aFree(access_deny);
#endif
- for (i = 1; i < fd_max; i++)
- if (session[i])
- do_close(i);
+ for( i = 1; i < fd_max; i++ )
+ if(session[i])
+ do_close(i);
- // session[0] のダミーデータを削除
- aFree(session[0]->rdata);
- aFree(session[0]->wdata);
- aFree(session[0]);
+ // session[0] のダミーデータを削除
+ aFree(session[0]->rdata);
+ aFree(session[0]->wdata);
+ aFree(session[0]);
}
/// Closes a socket.
void do_close(int fd)
{
- if (fd <= 0 ||fd >= FD_SETSIZE)
- return;// invalid
-
- flush_fifo(fd); // Try to send what's left (although it might not succeed since it's a nonblocking socket)
- sFD_CLR(fd, &readfds);// this needs to be done before closing the socket
- sShutdown(fd, SHUT_RDWR); // Disallow further reads/writes
- sClose(fd); // We don't really care if these closing functions return an error, we are just shutting down and not reusing this socket.
- if (session[fd]) delete_session(fd);
+ if( fd <= 0 ||fd >= FD_SETSIZE )
+ return;// invalid
+
+ flush_fifo(fd); // Try to send what's left (although it might not succeed since it's a nonblocking socket)
+ sFD_CLR(fd, &readfds);// this needs to be done before closing the socket
+ sShutdown(fd, SHUT_RDWR); // Disallow further reads/writes
+ sClose(fd); // We don't really care if these closing functions return an error, we are just shutting down and not reusing this socket.
+ if (session[fd]) delete_session(fd);
}
/// Retrieve local ips in host byte order.
/// Uses loopback is no address is found.
-int socket_getips(uint32 *ips, int max)
+int socket_getips(uint32* ips, int max)
{
- int num = 0;
+ int num = 0;
- if (ips == NULL || max <= 0)
- return 0;
+ if( ips == NULL || max <= 0 )
+ return 0;
#ifdef WIN32
- {
- char fullhost[255];
- u_long **a;
- struct hostent *hent;
-
- // XXX This should look up the local IP addresses in the registry
- // instead of calling gethostbyname. However, the way IP addresses
- // are stored in the registry is annoyingly complex, so I'll leave
- // this as T.B.D. [Meruru]
- if (gethostname(fullhost, sizeof(fullhost)) == SOCKET_ERROR) {
- ShowError("socket_getips: No hostname defined!\n");
- return 0;
- } else {
- hent = gethostbyname(fullhost);
- if (hent == NULL) {
- ShowError("socket_getips: Cannot resolve our own hostname to an IP address\n");
- return 0;
- }
- a = (u_long **)hent->h_addr_list;
- for (; a[num] != NULL && num < max; ++num)
- ips[num] = (uint32)ntohl(*a[num]);
- }
- }
+ {
+ char fullhost[255];
+ u_long** a;
+ struct hostent* hent;
+
+ // XXX This should look up the local IP addresses in the registry
+ // instead of calling gethostbyname. However, the way IP addresses
+ // are stored in the registry is annoyingly complex, so I'll leave
+ // this as T.B.D. [Meruru]
+ if( gethostname(fullhost, sizeof(fullhost)) == SOCKET_ERROR )
+ {
+ ShowError("socket_getips: No hostname defined!\n");
+ return 0;
+ }
+ else
+ {
+ hent = gethostbyname(fullhost);
+ if( hent == NULL ){
+ ShowError("socket_getips: Cannot resolve our own hostname to an IP address\n");
+ return 0;
+ }
+ a = (u_long**)hent->h_addr_list;
+ for( ; a[num] != NULL && num < max; ++num)
+ ips[num] = (uint32)ntohl(*a[num]);
+ }
+ }
#else // not WIN32
- {
- int pos;
- int fd;
- char buf[2*16*sizeof(struct ifreq)];
- struct ifconf ic;
- struct ifreq *ir;
- struct sockaddr_in *a;
- u_long ad;
-
- fd = sSocket(AF_INET, SOCK_STREAM, 0);
-
- memset(buf, 0x00, sizeof(buf));
-
- // The ioctl call will fail with Invalid Argument if there are more
- // interfaces than will fit in the buffer
- ic.ifc_len = sizeof(buf);
- ic.ifc_buf = buf;
- if (sIoctl(fd, SIOCGIFCONF, &ic) == -1) {
- ShowError("socket_getips: SIOCGIFCONF failed!\n");
- return 0;
- } else {
- for (pos=0; pos < ic.ifc_len && num < max;) {
- ir = (struct ifreq *)(buf+pos);
- a = (struct sockaddr_in *) &(ir->ifr_addr);
- if (a->sin_family == AF_INET) {
- ad = ntohl(a->sin_addr.s_addr);
- if (ad != INADDR_LOOPBACK && ad != INADDR_ANY)
- ips[num++] = (uint32)ad;
- }
-#if (defined(BSD) && BSD >= 199103) || defined(_AIX) || defined(__APPLE__)
- pos += ir->ifr_addr.sa_len + sizeof(ir->ifr_name);
-#else// not AIX or APPLE
- pos += sizeof(struct ifreq);
-#endif//not AIX or APPLE
- }
- }
- sClose(fd);
- }
+ {
+ int pos;
+ int fd;
+ char buf[2*16*sizeof(struct ifreq)];
+ struct ifconf ic;
+ struct ifreq* ir;
+ struct sockaddr_in* a;
+ u_long ad;
+
+ fd = sSocket(AF_INET, SOCK_STREAM, 0);
+
+ memset(buf, 0x00, sizeof(buf));
+
+ // The ioctl call will fail with Invalid Argument if there are more
+ // interfaces than will fit in the buffer
+ ic.ifc_len = sizeof(buf);
+ ic.ifc_buf = buf;
+ if( sIoctl(fd, SIOCGIFCONF, &ic) == -1 )
+ {
+ ShowError("socket_getips: SIOCGIFCONF failed!\n");
+ return 0;
+ }
+ else
+ {
+ for( pos=0; pos < ic.ifc_len && num < max; )
+ {
+ ir = (struct ifreq*)(buf+pos);
+ a = (struct sockaddr_in*) &(ir->ifr_addr);
+ if( a->sin_family == AF_INET ){
+ ad = ntohl(a->sin_addr.s_addr);
+ if( ad != INADDR_LOOPBACK && ad != INADDR_ANY )
+ ips[num++] = (uint32)ad;
+ }
+ #if (defined(BSD) && BSD >= 199103) || defined(_AIX) || defined(__APPLE__)
+ pos += ir->ifr_addr.sa_len + sizeof(ir->ifr_name);
+ #else// not AIX or APPLE
+ pos += sizeof(struct ifreq);
+ #endif//not AIX or APPLE
+ }
+ }
+ sClose(fd);
+ }
#endif // not W32
- // Use loopback if no ips are found
- if (num == 0)
- ips[num++] = (uint32)INADDR_LOOPBACK;
+ // Use loopback if no ips are found
+ if( num == 0 )
+ ips[num++] = (uint32)INADDR_LOOPBACK;
- return num;
+ return num;
}
void socket_init(void)
{
- char *SOCKET_CONF_FILENAME = "conf/packet_athena.conf";
- unsigned int rlim_cur = FD_SETSIZE;
+ char *SOCKET_CONF_FILENAME = "conf/packet_athena.conf";
+ unsigned int rlim_cur = FD_SETSIZE;
#ifdef WIN32
- {
- // Start up windows networking
- WSADATA wsaData;
- WORD wVersionRequested = MAKEWORD(2, 0);
- if (WSAStartup(wVersionRequested, &wsaData) != 0) {
- ShowError("socket_init: WinSock not available!\n");
- return;
- }
- if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 0) {
- ShowError("socket_init: WinSock version mismatch (2.0 or compatible required)!\n");
- return;
- }
- }
+ {// Start up windows networking
+ WSADATA wsaData;
+ WORD wVersionRequested = MAKEWORD(2, 0);
+ if( WSAStartup(wVersionRequested, &wsaData) != 0 )
+ {
+ ShowError("socket_init: WinSock not available!\n");
+ return;
+ }
+ if( LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 0 )
+ {
+ ShowError("socket_init: WinSock version mismatch (2.0 or compatible required)!\n");
+ return;
+ }
+ }
#elif defined(HAVE_SETRLIMIT) && !defined(CYGWIN)
- // NOTE: getrlimit and setrlimit have bogus behaviour in cygwin.
- // "Number of fds is virtually unlimited in cygwin" (sys/param.h)
- {
- // set socket limit to FD_SETSIZE
- struct rlimit rlp;
- if (0 == getrlimit(RLIMIT_NOFILE, &rlp)) {
- rlp.rlim_cur = FD_SETSIZE;
- if (0 != setrlimit(RLIMIT_NOFILE, &rlp)) {
- // failed, try setting the maximum too (permission to change system limits is required)
- rlp.rlim_max = FD_SETSIZE;
- if (0 != setrlimit(RLIMIT_NOFILE, &rlp)) {
- // failed
- const char *errmsg = error_msg();
- int rlim_ori;
- // set to maximum allowed
- getrlimit(RLIMIT_NOFILE, &rlp);
- rlim_ori = (int)rlp.rlim_cur;
- rlp.rlim_cur = rlp.rlim_max;
- setrlimit(RLIMIT_NOFILE, &rlp);
- // report limit
- getrlimit(RLIMIT_NOFILE, &rlp);
- rlim_cur = rlp.rlim_cur;
- ShowWarning("socket_init: failed to set socket limit to %d, setting to maximum allowed (original limit=%d, current limit=%d, maximum allowed=%d, %s).\n", FD_SETSIZE, rlim_ori, (int)rlp.rlim_cur, (int)rlp.rlim_max, errmsg);
- }
- }
- }
- }
+ // NOTE: getrlimit and setrlimit have bogus behaviour in cygwin.
+ // "Number of fds is virtually unlimited in cygwin" (sys/param.h)
+ {// set socket limit to FD_SETSIZE
+ struct rlimit rlp;
+ if( 0 == getrlimit(RLIMIT_NOFILE, &rlp) )
+ {
+ rlp.rlim_cur = FD_SETSIZE;
+ if( 0 != setrlimit(RLIMIT_NOFILE, &rlp) )
+ {// failed, try setting the maximum too (permission to change system limits is required)
+ rlp.rlim_max = FD_SETSIZE;
+ if( 0 != setrlimit(RLIMIT_NOFILE, &rlp) )
+ {// failed
+ const char *errmsg = error_msg();
+ int rlim_ori;
+ // set to maximum allowed
+ getrlimit(RLIMIT_NOFILE, &rlp);
+ rlim_ori = (int)rlp.rlim_cur;
+ rlp.rlim_cur = rlp.rlim_max;
+ setrlimit(RLIMIT_NOFILE, &rlp);
+ // report limit
+ getrlimit(RLIMIT_NOFILE, &rlp);
+ rlim_cur = rlp.rlim_cur;
+ ShowWarning("socket_init: failed to set socket limit to %d, setting to maximum allowed (original limit=%d, current limit=%d, maximum allowed=%d, %s).\n", FD_SETSIZE, rlim_ori, (int)rlp.rlim_cur, (int)rlp.rlim_max, errmsg);
+ }
+ }
+ }
+ }
#endif
- // Get initial local ips
- naddr_ = socket_getips(addr_,16);
+ // Get initial local ips
+ naddr_ = socket_getips(addr_,16);
- sFD_ZERO(&readfds);
+ sFD_ZERO(&readfds);
#if defined(SEND_SHORTLIST)
- memset(send_shortlist_set, 0, sizeof(send_shortlist_set));
+ memset(send_shortlist_set, 0, sizeof(send_shortlist_set));
#endif
- socket_config_read(SOCKET_CONF_FILENAME);
+ socket_config_read(SOCKET_CONF_FILENAME);
- // initialise last send-receive tick
- last_tick = time(NULL);
+ // initialise last send-receive tick
+ last_tick = time(NULL);
- // session[0] is now currently used for disconnected sessions of the map server, and as such,
- // should hold enough buffer (it is a vacuum so to speak) as it is never flushed. [Skotlex]
- create_session(0, null_recv, null_send, null_parse);
+ // session[0] is now currently used for disconnected sessions of the map server, and as such,
+ // should hold enough buffer (it is a vacuum so to speak) as it is never flushed. [Skotlex]
+ create_session(0, null_recv, null_send, null_parse);
#ifndef MINICORE
- // Delete old connection history every 5 minutes
- memset(connect_history, 0, sizeof(connect_history));
- add_timer_func_list(connect_check_clear, "connect_check_clear");
- add_timer_interval(gettick()+1000, connect_check_clear, 0, 0, 5*60*1000);
+ // Delete old connection history every 5 minutes
+ memset(connect_history, 0, sizeof(connect_history));
+ add_timer_func_list(connect_check_clear, "connect_check_clear");
+ add_timer_interval(gettick()+1000, connect_check_clear, 0, 0, 5*60*1000);
#endif
- ShowInfo("Server supports up to '"CL_WHITE"%u"CL_RESET"' concurrent connections.\n", rlim_cur);
+ ShowInfo("Server supports up to '"CL_WHITE"%u"CL_RESET"' concurrent connections.\n", rlim_cur);
}
bool session_isValid(int fd)
{
- return (fd > 0 && fd < FD_SETSIZE && session[fd] != NULL);
+ return ( fd > 0 && fd < FD_SETSIZE && session[fd] != NULL );
}
bool session_isActive(int fd)
{
- return (session_isValid(fd) && !session[fd]->flag.eof);
+ return ( session_isValid(fd) && !session[fd]->flag.eof );
}
// Resolves hostname into a numeric ip.
-uint32 host2ip(const char *hostname)
+uint32 host2ip(const char* hostname)
{
- struct hostent *h = gethostbyname(hostname);
- return (h != NULL) ? ntohl(*(uint32 *)h->h_addr) : 0;
+ struct hostent* h = gethostbyname(hostname);
+ return (h != NULL) ? ntohl(*(uint32*)h->h_addr) : 0;
}
// Converts a numeric ip into a dot-formatted string.
// Result is placed either into a user-provided buffer or a static system buffer.
-const char *ip2str(uint32 ip, char ip_str[16])
+const char* ip2str(uint32 ip, char ip_str[16])
{
- struct in_addr addr;
- addr.s_addr = htonl(ip);
- return (ip_str == NULL) ? inet_ntoa(addr) : strncpy(ip_str, inet_ntoa(addr), 16);
+ struct in_addr addr;
+ addr.s_addr = htonl(ip);
+ return (ip_str == NULL) ? inet_ntoa(addr) : strncpy(ip_str, inet_ntoa(addr), 16);
}
// Converts a dot-formatted ip string into a numeric ip.
-uint32 str2ip(const char *ip_str)
+uint32 str2ip(const char* ip_str)
{
- return ntohl(inet_addr(ip_str));
+ return ntohl(inet_addr(ip_str));
}
// Reorders bytes from network to little endian (Windows).
// Neccessary for sending port numbers to the RO client until Gravity notices that they forgot ntohs() calls.
uint16 ntows(uint16 netshort)
{
- return ((netshort & 0xFF) << 8) | ((netshort & 0xFF00) >> 8);
+ return ((netshort & 0xFF) << 8) | ((netshort & 0xFF00) >> 8);
}
#ifdef SEND_SHORTLIST
@@ -1364,70 +1382,75 @@ uint16 ntows(uint16 netshort)
// sending or eof handling.
void send_shortlist_add_fd(int fd)
{
- int i;
- int bit;
+ int i;
+ int bit;
- if (!session_isValid(fd))
- return;// out of range
+ if( !session_isValid(fd) )
+ return;// out of range
- i = fd/32;
- bit = fd%32;
+ i = fd/32;
+ bit = fd%32;
- if ((send_shortlist_set[i]>>bit)&1)
- return;// already in the list
+ if( (send_shortlist_set[i]>>bit)&1 )
+ return;// already in the list
- if (send_shortlist_count >= ARRAYLENGTH(send_shortlist_array)) {
- ShowDebug("send_shortlist_add_fd: shortlist is full, ignoring... (fd=%d shortlist.count=%d shortlist.length=%d)\n", fd, send_shortlist_count, ARRAYLENGTH(send_shortlist_array));
- return;
- }
+ if( send_shortlist_count >= ARRAYLENGTH(send_shortlist_array) )
+ {
+ ShowDebug("send_shortlist_add_fd: shortlist is full, ignoring... (fd=%d shortlist.count=%d shortlist.length=%d)\n", fd, send_shortlist_count, ARRAYLENGTH(send_shortlist_array));
+ return;
+ }
- // set the bit
- send_shortlist_set[i] |= 1<<bit;
- // Add to the end of the shortlist array.
- send_shortlist_array[send_shortlist_count++] = fd;
+ // set the bit
+ send_shortlist_set[i] |= 1<<bit;
+ // Add to the end of the shortlist array.
+ send_shortlist_array[send_shortlist_count++] = fd;
}
// Do pending network sends and eof handling from the shortlist.
void send_shortlist_do_sends()
{
- int i;
-
- for (i = send_shortlist_count-1; i >= 0; --i) {
- int fd = send_shortlist_array[i];
- int idx = fd/32;
- int bit = fd%32;
-
- // Remove fd from shortlist, move the last fd to the current position
- --send_shortlist_count;
- send_shortlist_array[i] = send_shortlist_array[send_shortlist_count];
- send_shortlist_array[send_shortlist_count] = 0;
-
- if (fd <= 0 || fd >= FD_SETSIZE) {
- ShowDebug("send_shortlist_do_sends: fd is out of range, corrupted memory? (fd=%d)\n", fd);
- continue;
- }
- if (((send_shortlist_set[idx]>>bit)&1) == 0) {
- ShowDebug("send_shortlist_do_sends: fd is not set, why is it in the shortlist? (fd=%d)\n", fd);
- continue;
- }
- send_shortlist_set[idx]&=~(1<<bit);// unset fd
- // If this session still exists, perform send operations on it and
- // check for the eof state.
- if (session[fd]) {
- // Send data
- if (session[fd]->wdata_size)
- session[fd]->func_send(fd);
-
- // If it's been marked as eof, call the parse func on it so that
- // the socket will be immediately closed.
- if (session[fd]->flag.eof)
- session[fd]->func_parse(fd);
-
- // If the session still exists, is not eof and has things left to
- // be sent from it we'll re-add it to the shortlist.
- if (session[fd] && !session[fd]->flag.eof && session[fd]->wdata_size)
- send_shortlist_add_fd(fd);
- }
- }
+ int i;
+
+ for( i = send_shortlist_count-1; i >= 0; --i )
+ {
+ int fd = send_shortlist_array[i];
+ int idx = fd/32;
+ int bit = fd%32;
+
+ // Remove fd from shortlist, move the last fd to the current position
+ --send_shortlist_count;
+ send_shortlist_array[i] = send_shortlist_array[send_shortlist_count];
+ send_shortlist_array[send_shortlist_count] = 0;
+
+ if( fd <= 0 || fd >= FD_SETSIZE )
+ {
+ ShowDebug("send_shortlist_do_sends: fd is out of range, corrupted memory? (fd=%d)\n", fd);
+ continue;
+ }
+ if( ((send_shortlist_set[idx]>>bit)&1) == 0 )
+ {
+ ShowDebug("send_shortlist_do_sends: fd is not set, why is it in the shortlist? (fd=%d)\n", fd);
+ continue;
+ }
+ send_shortlist_set[idx]&=~(1<<bit);// unset fd
+ // If this session still exists, perform send operations on it and
+ // check for the eof state.
+ if( session[fd] )
+ {
+ // Send data
+ if( session[fd]->wdata_size )
+ session[fd]->func_send(fd);
+
+ // If it's been marked as eof, call the parse func on it so that
+ // the socket will be immediately closed.
+ if( session[fd]->flag.eof )
+ session[fd]->func_parse(fd);
+
+ // If the session still exists, is not eof and has things left to
+ // be sent from it we'll re-add it to the shortlist.
+ if( session[fd] && !session[fd]->flag.eof && session[fd]->wdata_size )
+ send_shortlist_add_fd(fd);
+ }
+ }
}
#endif