- Undid r16968: SVN Replaced with source:/trunk/src/@16966 (tid:74924).

[16969:16991/trunk/src/] will be re-committed in the next 24 hours.

git-svn-id: https://rathena.svn.sourceforge.net/svnroot/rathena/trunk@16992 54d463be-8e91-2dee-dedb-b68131a5f0ec

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