src/d2dbs/dbserver.c

/*
 * Copyright (C) 2001           sousou  (liupeng.cs@263.net)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#include "common/setup_before.h"
#include "setup.h"

#ifdef HAVE_STDDEF_H
# include <stddef.h>
#else
# ifndef NULL
#  define NULL ((void *)0)
# endif
#endif
#include <stdio.h>
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#else
# ifdef HAVE_SYS_FILE_H
#  include <sys/file.h>
# endif
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
# ifdef HAVE_MEMORY_H
#  include <memory.h>
# endif
#endif
#include "compat/memset.h"
#include <errno.h>
#include "compat/strerror.h"
#ifdef TIME_WITH_SYS_TIME
# include <time.h>
# include <sys/time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
#include "compat/socket.h"
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#ifdef HAVE_NETINET_IN_H
# include <netinet/in.h>
#endif
#include "compat/netinet_in.h"
#ifdef HAVE_ARPA_INET_H
# include <arpa/inet.h>
#endif
#include "compat/inet_ntoa.h"
#include "compat/psock.h"
#include "common/network.h"

#include "dbserver.h"
#include "charlock.h"
#include "d2ladder.h"
#include "dbspacket.h"
#include "prefs.h"
#include "handle_signal.h"
#include "common/list.h"
#include "common/eventlog.h"
#ifdef WIN32
# include <conio.h> /* for kbhit() and getch() */
#endif
#include "common/addr.h"
#include "common/xalloc.h"
#include "common/setup_after.h"


static int              dbs_packet_gs_id = 0;
static t_preset_d2gsid  *preset_d2gsid_head = NULL;
t_list * dbs_server_connection_list = NULL;
int dbs_server_listen_socket=-1;
extern int g_ServiceStatus;

/* dbs_server_main
 * The module's driver function -- we just call other functions and
 * interpret their results.
 */

static int dbs_handle_timed_events(void);
static void dbs_on_exit(void);

int dbs_server_init(void);
void dbs_server_loop(int ListeningSocket);
int dbs_server_setup_fdsets(fd_set * pReadFDs, fd_set * pWriteFDs,
        fd_set * pExceptFDs, int ListeningSocket ) ;
BOOL dbs_server_read_data(t_d2dbs_connection* conn) ;
BOOL dbs_server_write_data(t_d2dbs_connection* conn) ;
int dbs_server_list_add_socket(int sd, unsigned int ipaddr);
static int setsockopt_keepalive(int sock);
static unsigned int get_preset_d2gsid(unsigned int ipaddr);


int dbs_server_main(void)
{
        eventlog(eventlog_level_info,__FUNCTION__,"establishing the listener...");
        dbs_server_listen_socket = dbs_server_init();
        if (dbs_server_listen_socket<0) {
                eventlog(eventlog_level_error,__FUNCTION__,"dbs_server_init error ");
                return 3;
        }
        eventlog(eventlog_level_info,__FUNCTION__,"waiting for connections...");
        dbs_server_loop(dbs_server_listen_socket);
        dbs_on_exit();
        return 0;
}

/* dbs_server_init
 * Sets up a listener on the given interface and port, returning the
 * listening socket if successful; if not, returns -1.
 */
/* FIXME: No it doesn't!  pcAddress is not ever referenced in this
 * function.
 * CreepLord: Fixed much better way (will accept dns hostnames)
 */
int dbs_server_init(void)
{
        int sd;
        struct sockaddr_in sinInterface;
        int val;
        t_addr  * servaddr;
                
        dbs_server_connection_list=list_create();

        if (d2dbs_d2ladder_init()==-1)
        {
                eventlog(eventlog_level_error,__FUNCTION__,"d2ladder_init() failed");
                return -1;
        }

        if (cl_init(DEFAULT_HASHTBL_LEN, DEFAULT_GS_MAX)==-1)
        {
                eventlog(eventlog_level_error,__FUNCTION__,"cl_init() failed");
                return -1;
        }

        if (psock_init()<0)
        {
                eventlog(eventlog_level_error,__FUNCTION__,"psock_init() failed");
                return -1;
        }
        
        sd = psock_socket(PSOCK_PF_INET, PSOCK_SOCK_STREAM, PSOCK_IPPROTO_TCP);
        if (sd==-1)
        {
                eventlog(eventlog_level_error,__FUNCTION__,"psock_socket() failed : %s",pstrerror(psock_errno()));
                return -1;
        }

        val = 1;
        if (psock_setsockopt(sd, PSOCK_SOL_SOCKET, PSOCK_SO_REUSEADDR, &val, sizeof(val)) < 0)
        {
                eventlog(eventlog_level_error,__FUNCTION__,"psock_setsockopt() failed : %s",pstrerror(psock_errno()));
        }

        if (!(servaddr=addr_create_str(d2dbs_prefs_get_servaddrs(),INADDR_ANY,DEFAULT_LISTEN_PORT)))
        {
                eventlog(eventlog_level_error,__FUNCTION__,"could not get servaddr");
                return -1;
        }
        
        sinInterface.sin_family = PSOCK_AF_INET;
        sinInterface.sin_addr.s_addr = htonl(addr_get_ip(servaddr));
        sinInterface.sin_port = htons(addr_get_port(servaddr));
        if (psock_bind(sd, (struct sockaddr*)&sinInterface, (psock_t_socklen)sizeof(struct sockaddr_in)) < 0)
        {
                eventlog(eventlog_level_error,__FUNCTION__,"psock_bind() failed : %s",pstrerror(psock_errno()));
                return -1;
        }
        if (psock_listen(sd, LISTEN_QUEUE) < 0)
        {
                eventlog(eventlog_level_error,__FUNCTION__,"psock_listen() failed : %s",pstrerror(psock_errno()));
                return -1;
        }
        addr_destroy(servaddr);
        return sd;
}


/* dbs_server_setup_fdsets
 * Set up the three FD sets used with select() with the sockets in the
 * connection list.  Also add one for the listener socket, if we have
 * one.
 */

int dbs_server_setup_fdsets(t_psock_fd_set * pReadFDs, t_psock_fd_set * pWriteFDs, t_psock_fd_set * pExceptFDs, int lsocket)
{
        t_elem const * elem;
        t_d2dbs_connection* it;
        int highest_fd;

        PSOCK_FD_ZERO(pReadFDs);
        PSOCK_FD_ZERO(pWriteFDs);
        PSOCK_FD_ZERO(pExceptFDs); /* FIXME: don't check these... remove this code */
        /* Add the listener socket to the read and except FD sets, if there is one. */
        if (lsocket >= 0) {
                PSOCK_FD_SET(lsocket, pReadFDs);
                PSOCK_FD_SET(lsocket, pExceptFDs);
        }
        highest_fd=lsocket;

        LIST_TRAVERSE_CONST(dbs_server_connection_list,elem)
        {               
                if (!(it=elem_get_data(elem))) continue;
                if (it->nCharsInReadBuffer < (kBufferSize-kMaxPacketLength)) {
                        /* There's space in the read buffer, so pay attention to incoming data. */
                        PSOCK_FD_SET(it->sd, pReadFDs);
                }
                if (it->nCharsInWriteBuffer > 0) {
                        PSOCK_FD_SET(it->sd, pWriteFDs);
                }
                PSOCK_FD_SET(it->sd, pExceptFDs);
                if (highest_fd < it->sd) highest_fd=it->sd;
        }
        return highest_fd;
}

/* dbs_server_read_data
 * Data came in on a client socket, so read it into the buffer.  Returns
 * false on failure, or when the client closes its half of the
 * connection.  (EAGAIN doesn't count as a failure.)
 */
BOOL dbs_server_read_data(t_d2dbs_connection* conn)
{
        int nBytes;

        nBytes = net_recv(conn->sd, conn->ReadBuf + conn->nCharsInReadBuffer,
                          kBufferSize - conn->nCharsInReadBuffer);

        if (nBytes < 0) return FALSE;
        conn->nCharsInReadBuffer += nBytes;
        return TRUE;
}


/* dbs_server_write_data
 * The connection is writable, so send any pending data.  Returns
 * false on failure.  (EAGAIN doesn't count as a failure.)
 */
BOOL dbs_server_write_data(t_d2dbs_connection* conn)
{
        int nBytes ;

        nBytes = net_send(conn->sd, conn->WriteBuf, 
            conn->nCharsInWriteBuffer > kMaxPacketLength ? kMaxPacketLength : conn->nCharsInWriteBuffer);

        if (nBytes < 0) return FALSE;

        conn->nCharsInWriteBuffer -= nBytes;
        if (conn->nCharsInWriteBuffer)
                memmove(conn->WriteBuf, conn->WriteBuf + nBytes, conn->nCharsInWriteBuffer);

        return TRUE;
}

int dbs_server_list_add_socket(int sd, unsigned int ipaddr)
{
        t_d2dbs_connection      *it;
        struct in_addr          in;

        it=xmalloc(sizeof(t_d2dbs_connection));
        memset(it, 0, sizeof(t_d2dbs_connection));
        it->sd=sd;
        it->ipaddr=ipaddr;
        it->major=0;
        it->minor=0;
        it->type=0;
        it->stats=0;
        it->verified=0;
        it->serverid=get_preset_d2gsid(ipaddr);
        it->last_active=time(NULL);
        it->nCharsInReadBuffer=0;
        it->nCharsInWriteBuffer=0;
        list_append_data(dbs_server_connection_list,it);
        in.s_addr = htonl(ipaddr);
        strncpy(it->serverip, inet_ntoa(in), sizeof(it->serverip)-1);

        return 1;
}

static int dbs_handle_timed_events(void)
{
        static  time_t          prev_ladder_save_time=0;
        static  time_t          prev_keepalive_save_time=0;
        static  time_t          prev_timeout_checktime=0;
        time_t                  now;

        now=time(NULL);
        if (now-prev_ladder_save_time>(signed)prefs_get_laddersave_interval()) {
                d2ladder_saveladder();
                prev_ladder_save_time=now;
        }
        if (now-prev_keepalive_save_time>(signed)prefs_get_keepalive_interval()) {
                dbs_keepalive();
                prev_keepalive_save_time=now;
        }
        if (now-prev_timeout_checktime>(signed)d2dbs_prefs_get_timeout_checkinterval()) {
                dbs_check_timeout();
                prev_timeout_checktime=now;
        }
        return 0;
}

void dbs_server_loop(int lsocket)
{
        struct sockaddr_in sinRemote;
        int sd ;
        fd_set ReadFDs, WriteFDs, ExceptFDs;
        t_elem * elem;
        t_d2dbs_connection* it;
        BOOL bOK ;
        const char* pcErrorType ;
        struct timeval         tv;
        int highest_fd;
        psock_t_socklen nAddrSize = sizeof(sinRemote);
        
        while (1) {

#ifdef WIN32
        if (g_ServiceStatus<0 && kbhit() && getch()=='q')
            d2dbs_signal_quit_wrapper();
        if (g_ServiceStatus == 0) d2dbs_signal_quit_wrapper();

        while (g_ServiceStatus == 2) Sleep(1000);
#endif

                if (d2dbs_handle_signal()<0) break;

                dbs_handle_timed_events();
                highest_fd=dbs_server_setup_fdsets(&ReadFDs, &WriteFDs, &ExceptFDs, lsocket);

                tv.tv_sec  = 0;
                tv.tv_usec = SELECT_TIME_OUT;
                switch (psock_select(highest_fd+1, &ReadFDs, &WriteFDs, &ExceptFDs, &tv) ) {
                        case -1:
                                eventlog(eventlog_level_error,__FUNCTION__,"psock_select() failed : %s",pstrerror(psock_errno()));
                                continue;
                        case 0:
                                continue;
                        default:
                                break;
                }

                if (PSOCK_FD_ISSET(lsocket, &ReadFDs)) {
                        sd = psock_accept(lsocket, (struct sockaddr*)&sinRemote, &nAddrSize);
                        if (sd == -1) {
                                eventlog(eventlog_level_error,__FUNCTION__,"psock_accept() failed : %s",pstrerror(psock_errno()));
                                return;
                        }
                        
                        eventlog(eventlog_level_info,__FUNCTION__,"accepted connection from %s:%d , socket %d .",
                                inet_ntoa(sinRemote.sin_addr) , ntohs(sinRemote.sin_port), sd);
                        eventlog_step(prefs_get_logfile_gs(),eventlog_level_info,__FUNCTION__,"accepted connection from %s:%d , socket %d .",
                                inet_ntoa(sinRemote.sin_addr) , ntohs(sinRemote.sin_port), sd);
                        setsockopt_keepalive(sd);
                        dbs_server_list_add_socket(sd, ntohl(sinRemote.sin_addr.s_addr));
                        if (psock_ctl(sd,PSOCK_NONBLOCK)<0) {
                                eventlog(eventlog_level_error,__FUNCTION__,"could not set TCP socket [%d] to non-blocking mode (closing connection) (psock_ctl: %s)", sd,pstrerror(psock_errno()));
                                psock_close(sd);
                        }
                } else if (PSOCK_FD_ISSET(lsocket, &ExceptFDs)) {
                        eventlog(eventlog_level_error,__FUNCTION__,"exception on listening socket");
                        /* FIXME: exceptions are not errors with TCP, they are out-of-band data */
                        return;
                }
                
                LIST_TRAVERSE(dbs_server_connection_list,elem)
                {
                        bOK = TRUE;
                        pcErrorType = 0;
                        
                        if (!(it=elem_get_data(elem))) continue;
                        if (PSOCK_FD_ISSET(it->sd, &ExceptFDs)) {
                                bOK = FALSE;
                                pcErrorType = "General socket error"; /* FIXME: no no no no no */
                                PSOCK_FD_CLR(it->sd, &ExceptFDs);
                        } else {
                                
                                if (PSOCK_FD_ISSET(it->sd, &ReadFDs)) {
                                        bOK = dbs_server_read_data(it);
                                        pcErrorType = "Read error";
                                        PSOCK_FD_CLR(it->sd, &ReadFDs);
                                }
                                
                                if (PSOCK_FD_ISSET(it->sd, &WriteFDs)) {
                                        bOK = dbs_server_write_data(it);
                                        pcErrorType = "Write error";
                                        PSOCK_FD_CLR(it->sd, &WriteFDs);
                                }
                        }
                        
                        if (!bOK) {
                                int     err, errno2;
                                psock_t_socklen errlen;
                                
                                err = 0;
                                errlen = sizeof(err);
                                errno2 = psock_errno();

                                if (psock_getsockopt(it->sd, PSOCK_SOL_SOCKET, PSOCK_SO_ERROR, &err, &errlen)==0) {
                                        if (errlen && err!=0) {
                                                err = err ? err : errno2;
                                                eventlog(eventlog_level_error,__FUNCTION__,"data socket error : %s(%d)",pstrerror(err),err);
                                        }
                                }
                                dbs_server_shutdown_connection(it);
                                list_remove_elem(dbs_server_connection_list,&elem);
                        } else {
                                if (dbs_packet_handle(it)==-1) {
                                        eventlog(eventlog_level_error,__FUNCTION__,"dbs_packet_handle() failed");
                                        dbs_server_shutdown_connection(it);
                                        list_remove_elem(dbs_server_connection_list,&elem);
                                }
                        }
                }
        }
}

static void dbs_on_exit(void)
{
        t_elem * elem;
        t_d2dbs_connection * it;

        if (dbs_server_listen_socket>=0)
                psock_close(dbs_server_listen_socket);
        dbs_server_listen_socket=-1;

        LIST_TRAVERSE(dbs_server_connection_list,elem)
        {
                if (!(it=elem_get_data(elem))) continue;
                dbs_server_shutdown_connection(it);
                list_remove_elem(dbs_server_connection_list,&elem);
        }
        cl_destroy();
        d2dbs_d2ladder_destroy();
        list_destroy(dbs_server_connection_list);
        if (preset_d2gsid_head)
        {
                t_preset_d2gsid * curr;
                t_preset_d2gsid * next;
                
                for (curr=preset_d2gsid_head; curr; curr=next)
                {
                        next = curr->next;
                        xfree(curr);
                }
        }
        eventlog(eventlog_level_info,__FUNCTION__,"dbserver stopped");
}

int dbs_server_shutdown_connection(t_d2dbs_connection* conn)
{
        psock_shutdown(conn->sd, PSOCK_SHUT_RDWR) ;
        psock_close(conn->sd);
        if (conn->verified && conn->type==CONNECT_CLASS_D2GS_TO_D2DBS) {
                eventlog(eventlog_level_info,__FUNCTION__,"unlock all characters on gs %s(%d)",conn->serverip,conn->serverid);
                eventlog_step(prefs_get_logfile_gs(),eventlog_level_info,__FUNCTION__,"unlock all characters on gs %s(%d)",conn->serverip,conn->serverid);
                eventlog_step(prefs_get_logfile_gs(),eventlog_level_info,__FUNCTION__,"close connection to gs on socket %d", conn->sd);
                cl_unlock_all_char_by_gsid(conn->serverid);
        }
        xfree(conn);
        return 1;
}

static int setsockopt_keepalive(int sock)
{
        int             optval;
        psock_t_socklen optlen;

        optval = 1;
        optlen = sizeof(optval);
        if (psock_setsockopt(sock, PSOCK_SOL_SOCKET, PSOCK_SO_KEEPALIVE, &optval, optlen)) {
                eventlog(eventlog_level_info,__FUNCTION__,"failed set KEEPALIVE for socket %d, errno=%d", sock, psock_errno());
                return -1;
        } else {
                eventlog(eventlog_level_info,__FUNCTION__,"set KEEPALIVE option for socket %d", sock);
                return 0;
        }
}

static unsigned int get_preset_d2gsid(unsigned int ipaddr)
{
        t_preset_d2gsid         *pgsid;

        pgsid = preset_d2gsid_head;
        while (pgsid)
        {
                if (pgsid->ipaddr == ipaddr)
                        return pgsid->d2gsid;
                pgsid = pgsid->next;
        }
        /* not found, build a new item */
        pgsid = xmalloc(sizeof(t_preset_d2gsid));
        pgsid->ipaddr = ipaddr;
        pgsid->d2gsid = ++dbs_packet_gs_id;
        /* add to list */
        pgsid->next = preset_d2gsid_head;
        preset_d2gsid_head = pgsid;
        return preset_d2gsid_head->d2gsid;
}
1	sysadm	1.1	/*
2			* Copyright (C) 2001 sousou (liupeng.cs@263.net)
3			*
4			* This program is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU General Public License
6			* as published by the Free Software Foundation; either version 2
7			* of the License, or (at your option) any later version.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to the Free Software
16			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17			*/
18			#include "common/setup_before.h"
19			#include "setup.h"
20
21			#ifdef HAVE_STDDEF_H
22			# include <stddef.h>
23			#else
24			# ifndef NULL
25			# define NULL ((void *)0)
26			# endif
27			#endif
28			#include <stdio.h>
29			#ifdef STDC_HEADERS
30			# include <stdlib.h>
31			#else
32			# ifdef HAVE_MALLOC_H
33			# include <malloc.h>
34			# endif
35			#endif
36			#ifdef HAVE_UNISTD_H
37			# include <unistd.h>
38			#endif
39			#ifdef HAVE_FCNTL_H
40			# include <fcntl.h>
41			#else
42			# ifdef HAVE_SYS_FILE_H
43			# include <sys/file.h>
44			# endif
45			#endif
46			#ifdef HAVE_STRING_H
47			# include <string.h>
48			#else
49			# ifdef HAVE_STRINGS_H
50			# include <strings.h>
51			# endif
52			# ifdef HAVE_MEMORY_H
53			# include <memory.h>
54			# endif
55			#endif
56			#include "compat/memset.h"
57			#include <errno.h>
58			#include "compat/strerror.h"
59			#ifdef TIME_WITH_SYS_TIME
60			# include <time.h>
61			# include <sys/time.h>
62			#else
63			# ifdef HAVE_SYS_TIME_H
64			# include <sys/time.h>
65			# else
66			# include <time.h>
67			# endif
68			#endif
69			#ifdef HAVE_SYS_TYPES_H
70			# include <sys/types.h>
71			#endif
72			#ifdef HAVE_SYS_SOCKET_H
73			# include <sys/socket.h>
74			#endif
75			#include "compat/socket.h"
76			#ifdef HAVE_SYS_PARAM_H
77			# include <sys/param.h>
78			#endif
79			#ifdef HAVE_NETINET_IN_H
80			# include <netinet/in.h>
81			#endif
82			#include "compat/netinet_in.h"
83			#ifdef HAVE_ARPA_INET_H
84			# include <arpa/inet.h>
85			#endif
86			#include "compat/inet_ntoa.h"
87			#include "compat/psock.h"
88			#include "common/network.h"
89
90			#include "dbserver.h"
91			#include "charlock.h"
92			#include "d2ladder.h"
93			#include "dbspacket.h"
94			#include "prefs.h"
95			#include "handle_signal.h"
96			#include "common/list.h"
97			#include "common/eventlog.h"
98			#ifdef WIN32
99			# include <conio.h> /* for kbhit() and getch() */
100			#endif
101			#include "common/addr.h"
102			#include "common/xalloc.h"
103			#include "common/setup_after.h"
104
105
106			static int dbs_packet_gs_id = 0;
107			static t_preset_d2gsid *preset_d2gsid_head = NULL;
108			t_list * dbs_server_connection_list = NULL;
109			int dbs_server_listen_socket=-1;
110			extern int g_ServiceStatus;
111
112			/* dbs_server_main
113			* The module's driver function -- we just call other functions and
114			* interpret their results.
115			*/
116
117			static int dbs_handle_timed_events(void);
118			static void dbs_on_exit(void);
119
120			int dbs_server_init(void);
121			void dbs_server_loop(int ListeningSocket);
122			int dbs_server_setup_fdsets(fd_set * pReadFDs, fd_set * pWriteFDs,
123			fd_set * pExceptFDs, int ListeningSocket ) ;
124			BOOL dbs_server_read_data(t_d2dbs_connection* conn) ;
125			BOOL dbs_server_write_data(t_d2dbs_connection* conn) ;
126			int dbs_server_list_add_socket(int sd, unsigned int ipaddr);
127			static int setsockopt_keepalive(int sock);
128			static unsigned int get_preset_d2gsid(unsigned int ipaddr);
129
130
131			int dbs_server_main(void)
132			{
133			eventlog(eventlog_level_info,__FUNCTION__,"establishing the listener...");
134			dbs_server_listen_socket = dbs_server_init();
135			if (dbs_server_listen_socket<0) {
136			eventlog(eventlog_level_error,__FUNCTION__,"dbs_server_init error ");
137			return 3;
138			}
139			eventlog(eventlog_level_info,__FUNCTION__,"waiting for connections...");
140			dbs_server_loop(dbs_server_listen_socket);
141			dbs_on_exit();
142			return 0;
143			}
144
145			/* dbs_server_init
146			* Sets up a listener on the given interface and port, returning the
147			* listening socket if successful; if not, returns -1.
148			*/
149			/* FIXME: No it doesn't! pcAddress is not ever referenced in this
150			* function.
151			* CreepLord: Fixed much better way (will accept dns hostnames)
152			*/
153			int dbs_server_init(void)
154			{
155			int sd;
156			struct sockaddr_in sinInterface;
157			int val;
158			t_addr * servaddr;
159
160			dbs_server_connection_list=list_create();
161
162			if (d2dbs_d2ladder_init()==-1)
163			{
164			eventlog(eventlog_level_error,__FUNCTION__,"d2ladder_init() failed");
165			return -1;
166			}
167
168			if (cl_init(DEFAULT_HASHTBL_LEN, DEFAULT_GS_MAX)==-1)
169			{
170			eventlog(eventlog_level_error,__FUNCTION__,"cl_init() failed");
171			return -1;
172			}
173
174			if (psock_init()<0)
175			{
176			eventlog(eventlog_level_error,__FUNCTION__,"psock_init() failed");
177			return -1;
178			}
179
180			sd = psock_socket(PSOCK_PF_INET, PSOCK_SOCK_STREAM, PSOCK_IPPROTO_TCP);
181			if (sd==-1)
182			{
183			eventlog(eventlog_level_error,__FUNCTION__,"psock_socket() failed : %s",pstrerror(psock_errno()));
184			return -1;
185			}
186
187			val = 1;
188			if (psock_setsockopt(sd, PSOCK_SOL_SOCKET, PSOCK_SO_REUSEADDR, &val, sizeof(val)) < 0)
189			{
190			eventlog(eventlog_level_error,__FUNCTION__,"psock_setsockopt() failed : %s",pstrerror(psock_errno()));
191			}
192
193			if (!(servaddr=addr_create_str(d2dbs_prefs_get_servaddrs(),INADDR_ANY,DEFAULT_LISTEN_PORT)))
194			{
195			eventlog(eventlog_level_error,__FUNCTION__,"could not get servaddr");
196			return -1;
197			}
198
199			sinInterface.sin_family = PSOCK_AF_INET;
200			sinInterface.sin_addr.s_addr = htonl(addr_get_ip(servaddr));
201			sinInterface.sin_port = htons(addr_get_port(servaddr));
202			if (psock_bind(sd, (struct sockaddr*)&sinInterface, (psock_t_socklen)sizeof(struct sockaddr_in)) < 0)
203			{
204			eventlog(eventlog_level_error,__FUNCTION__,"psock_bind() failed : %s",pstrerror(psock_errno()));
205			return -1;
206			}
207			if (psock_listen(sd, LISTEN_QUEUE) < 0)
208			{
209			eventlog(eventlog_level_error,__FUNCTION__,"psock_listen() failed : %s",pstrerror(psock_errno()));
210			return -1;
211			}
212			addr_destroy(servaddr);
213			return sd;
214			}
215
216
217			/* dbs_server_setup_fdsets
218			* Set up the three FD sets used with select() with the sockets in the
219			* connection list. Also add one for the listener socket, if we have
220			* one.
221			*/
222
223			int dbs_server_setup_fdsets(t_psock_fd_set * pReadFDs, t_psock_fd_set * pWriteFDs, t_psock_fd_set * pExceptFDs, int lsocket)
224			{
225			t_elem const * elem;
226			t_d2dbs_connection* it;
227			int highest_fd;
228
229			PSOCK_FD_ZERO(pReadFDs);
230			PSOCK_FD_ZERO(pWriteFDs);
231			PSOCK_FD_ZERO(pExceptFDs); /* FIXME: don't check these... remove this code */
232			/* Add the listener socket to the read and except FD sets, if there is one. */
233			if (lsocket >= 0) {
234			PSOCK_FD_SET(lsocket, pReadFDs);
235			PSOCK_FD_SET(lsocket, pExceptFDs);
236			}
237			highest_fd=lsocket;
238
239			LIST_TRAVERSE_CONST(dbs_server_connection_list,elem)
240			{
241			if (!(it=elem_get_data(elem))) continue;
242			if (it->nCharsInReadBuffer < (kBufferSize-kMaxPacketLength)) {
243			/* There's space in the read buffer, so pay attention to incoming data. */
244			PSOCK_FD_SET(it->sd, pReadFDs);
245			}
246			if (it->nCharsInWriteBuffer > 0) {
247			PSOCK_FD_SET(it->sd, pWriteFDs);
248			}
249			PSOCK_FD_SET(it->sd, pExceptFDs);
250			if (highest_fd < it->sd) highest_fd=it->sd;
251			}
252			return highest_fd;
253			}
254
255			/* dbs_server_read_data
256			* Data came in on a client socket, so read it into the buffer. Returns
257			* false on failure, or when the client closes its half of the
258			* connection. (EAGAIN doesn't count as a failure.)
259			*/
260			BOOL dbs_server_read_data(t_d2dbs_connection* conn)
261			{
262			int nBytes;
263
264			nBytes = net_recv(conn->sd, conn->ReadBuf + conn->nCharsInReadBuffer,
265			kBufferSize - conn->nCharsInReadBuffer);
266
267			if (nBytes < 0) return FALSE;
268			conn->nCharsInReadBuffer += nBytes;
269			return TRUE;
270			}
271
272
273			/* dbs_server_write_data
274			* The connection is writable, so send any pending data. Returns
275			* false on failure. (EAGAIN doesn't count as a failure.)
276			*/
277			BOOL dbs_server_write_data(t_d2dbs_connection* conn)
278			{
279			int nBytes ;
280
281			nBytes = net_send(conn->sd, conn->WriteBuf,
282			conn->nCharsInWriteBuffer > kMaxPacketLength ? kMaxPacketLength : conn->nCharsInWriteBuffer);
283
284			if (nBytes < 0) return FALSE;
285
286			conn->nCharsInWriteBuffer -= nBytes;
287			if (conn->nCharsInWriteBuffer)
288			memmove(conn->WriteBuf, conn->WriteBuf + nBytes, conn->nCharsInWriteBuffer);
289
290			return TRUE;
291			}
292
293			int dbs_server_list_add_socket(int sd, unsigned int ipaddr)
294			{
295			t_d2dbs_connection *it;
296			struct in_addr in;
297
298			it=xmalloc(sizeof(t_d2dbs_connection));
299			memset(it, 0, sizeof(t_d2dbs_connection));
300			it->sd=sd;
301			it->ipaddr=ipaddr;
302			it->major=0;
303			it->minor=0;
304			it->type=0;
305			it->stats=0;
306			it->verified=0;
307			it->serverid=get_preset_d2gsid(ipaddr);
308			it->last_active=time(NULL);
309			it->nCharsInReadBuffer=0;
310			it->nCharsInWriteBuffer=0;
311			list_append_data(dbs_server_connection_list,it);
312			in.s_addr = htonl(ipaddr);
313			strncpy(it->serverip, inet_ntoa(in), sizeof(it->serverip)-1);
314
315			return 1;
316			}
317
318			static int dbs_handle_timed_events(void)
319			{
320			static time_t prev_ladder_save_time=0;
321			static time_t prev_keepalive_save_time=0;
322			static time_t prev_timeout_checktime=0;
323			time_t now;
324
325			now=time(NULL);
326			if (now-prev_ladder_save_time>(signed)prefs_get_laddersave_interval()) {
327			d2ladder_saveladder();
328			prev_ladder_save_time=now;
329			}
330			if (now-prev_keepalive_save_time>(signed)prefs_get_keepalive_interval()) {
331			dbs_keepalive();
332			prev_keepalive_save_time=now;
333			}
334			if (now-prev_timeout_checktime>(signed)d2dbs_prefs_get_timeout_checkinterval()) {
335			dbs_check_timeout();
336			prev_timeout_checktime=now;
337			}
338			return 0;
339			}
340
341			void dbs_server_loop(int lsocket)
342			{
343			struct sockaddr_in sinRemote;
344			int sd ;
345			fd_set ReadFDs, WriteFDs, ExceptFDs;
346			t_elem * elem;
347			t_d2dbs_connection* it;
348			BOOL bOK ;
349			const char* pcErrorType ;
350			struct timeval tv;
351			int highest_fd;
352			psock_t_socklen nAddrSize = sizeof(sinRemote);
353
354			while (1) {
355
356			#ifdef WIN32
357			if (g_ServiceStatus<0 && kbhit() && getch()=='q')
358			d2dbs_signal_quit_wrapper();
359			if (g_ServiceStatus == 0) d2dbs_signal_quit_wrapper();
360
361			while (g_ServiceStatus == 2) Sleep(1000);
362			#endif
363
364			if (d2dbs_handle_signal()<0) break;
365
366			dbs_handle_timed_events();
367			highest_fd=dbs_server_setup_fdsets(&ReadFDs, &WriteFDs, &ExceptFDs, lsocket);
368
369			tv.tv_sec = 0;
370			tv.tv_usec = SELECT_TIME_OUT;
371			switch (psock_select(highest_fd+1, &ReadFDs, &WriteFDs, &ExceptFDs, &tv) ) {
372			case -1:
373			eventlog(eventlog_level_error,__FUNCTION__,"psock_select() failed : %s",pstrerror(psock_errno()));
374			continue;
375			case 0:
376			continue;
377			default:
378			break;
379			}
380
381			if (PSOCK_FD_ISSET(lsocket, &ReadFDs)) {
382			sd = psock_accept(lsocket, (struct sockaddr*)&sinRemote, &nAddrSize);
383			if (sd == -1) {
384			eventlog(eventlog_level_error,__FUNCTION__,"psock_accept() failed : %s",pstrerror(psock_errno()));
385			return;
386			}
387
388			eventlog(eventlog_level_info,__FUNCTION__,"accepted connection from %s:%d , socket %d .",
389			inet_ntoa(sinRemote.sin_addr) , ntohs(sinRemote.sin_port), sd);
390			eventlog_step(prefs_get_logfile_gs(),eventlog_level_info,__FUNCTION__,"accepted connection from %s:%d , socket %d .",
391			inet_ntoa(sinRemote.sin_addr) , ntohs(sinRemote.sin_port), sd);
392			setsockopt_keepalive(sd);
393			dbs_server_list_add_socket(sd, ntohl(sinRemote.sin_addr.s_addr));
394			if (psock_ctl(sd,PSOCK_NONBLOCK)<0) {
395			eventlog(eventlog_level_error,__FUNCTION__,"could not set TCP socket [%d] to non-blocking mode (closing connection) (psock_ctl: %s)", sd,pstrerror(psock_errno()));
396			psock_close(sd);
397			}
398			} else if (PSOCK_FD_ISSET(lsocket, &ExceptFDs)) {
399			eventlog(eventlog_level_error,__FUNCTION__,"exception on listening socket");
400			/* FIXME: exceptions are not errors with TCP, they are out-of-band data */
401			return;
402			}
403
404			LIST_TRAVERSE(dbs_server_connection_list,elem)
405			{
406			bOK = TRUE;
407			pcErrorType = 0;
408
409			if (!(it=elem_get_data(elem))) continue;
410			if (PSOCK_FD_ISSET(it->sd, &ExceptFDs)) {
411			bOK = FALSE;
412			pcErrorType = "General socket error"; /* FIXME: no no no no no */
413			PSOCK_FD_CLR(it->sd, &ExceptFDs);
414			} else {
415
416			if (PSOCK_FD_ISSET(it->sd, &ReadFDs)) {
417			bOK = dbs_server_read_data(it);
418			pcErrorType = "Read error";
419			PSOCK_FD_CLR(it->sd, &ReadFDs);
420			}
421
422			if (PSOCK_FD_ISSET(it->sd, &WriteFDs)) {
423			bOK = dbs_server_write_data(it);
424			pcErrorType = "Write error";
425			PSOCK_FD_CLR(it->sd, &WriteFDs);
426			}
427			}
428
429			if (!bOK) {
430			int err, errno2;
431			psock_t_socklen errlen;
432
433			err = 0;
434			errlen = sizeof(err);
435			errno2 = psock_errno();
436
437			if (psock_getsockopt(it->sd, PSOCK_SOL_SOCKET, PSOCK_SO_ERROR, &err, &errlen)==0) {
438			if (errlen && err!=0) {
439			err = err ? err : errno2;
440			eventlog(eventlog_level_error,__FUNCTION__,"data socket error : %s(%d)",pstrerror(err),err);
441			}
442			}
443			dbs_server_shutdown_connection(it);
444			list_remove_elem(dbs_server_connection_list,&elem);
445			} else {
446			if (dbs_packet_handle(it)==-1) {
447			eventlog(eventlog_level_error,__FUNCTION__,"dbs_packet_handle() failed");
448			dbs_server_shutdown_connection(it);
449			list_remove_elem(dbs_server_connection_list,&elem);
450			}
451			}
452			}
453			}
454			}
455
456			static void dbs_on_exit(void)
457			{
458			t_elem * elem;
459			t_d2dbs_connection * it;
460
461			if (dbs_server_listen_socket>=0)
462			psock_close(dbs_server_listen_socket);
463			dbs_server_listen_socket=-1;
464
465			LIST_TRAVERSE(dbs_server_connection_list,elem)
466			{
467			if (!(it=elem_get_data(elem))) continue;
468			dbs_server_shutdown_connection(it);
469			list_remove_elem(dbs_server_connection_list,&elem);
470			}
471			cl_destroy();
472			d2dbs_d2ladder_destroy();
473			list_destroy(dbs_server_connection_list);
474			if (preset_d2gsid_head)
475			{
476			t_preset_d2gsid * curr;
477			t_preset_d2gsid * next;
478
479			for (curr=preset_d2gsid_head; curr; curr=next)
480			{
481			next = curr->next;
482			xfree(curr);
483			}
484			}
485			eventlog(eventlog_level_info,__FUNCTION__,"dbserver stopped");
486			}
487
488			int dbs_server_shutdown_connection(t_d2dbs_connection* conn)
489			{
490			psock_shutdown(conn->sd, PSOCK_SHUT_RDWR) ;
491			psock_close(conn->sd);
492			if (conn->verified && conn->type==CONNECT_CLASS_D2GS_TO_D2DBS) {
493			eventlog(eventlog_level_info,__FUNCTION__,"unlock all characters on gs %s(%d)",conn->serverip,conn->serverid);
494			eventlog_step(prefs_get_logfile_gs(),eventlog_level_info,__FUNCTION__,"unlock all characters on gs %s(%d)",conn->serverip,conn->serverid);
495			eventlog_step(prefs_get_logfile_gs(),eventlog_level_info,__FUNCTION__,"close connection to gs on socket %d", conn->sd);
496			cl_unlock_all_char_by_gsid(conn->serverid);
497			}
498			xfree(conn);
499			return 1;
500			}
501
502			static int setsockopt_keepalive(int sock)
503			{
504			int optval;
505			psock_t_socklen optlen;
506
507			optval = 1;
508			optlen = sizeof(optval);
509			if (psock_setsockopt(sock, PSOCK_SOL_SOCKET, PSOCK_SO_KEEPALIVE, &optval, optlen)) {
510			eventlog(eventlog_level_info,__FUNCTION__,"failed set KEEPALIVE for socket %d, errno=%d", sock, psock_errno());
511			return -1;
512			} else {
513			eventlog(eventlog_level_info,__FUNCTION__,"set KEEPALIVE option for socket %d", sock);
514			return 0;
515			}
516			}
517
518			static unsigned int get_preset_d2gsid(unsigned int ipaddr)
519			{
520			t_preset_d2gsid *pgsid;
521
522			pgsid = preset_d2gsid_head;
523			while (pgsid)
524			{
525			if (pgsid->ipaddr == ipaddr)
526			return pgsid->d2gsid;
527			pgsid = pgsid->next;
528			}
529			/* not found, build a new item */
530			pgsid = xmalloc(sizeof(t_preset_d2gsid));
531			pgsid->ipaddr = ipaddr;
532			pgsid->d2gsid = ++dbs_packet_gs_id;
533			/* add to list */
534			pgsid->next = preset_d2gsid_head;
535			preset_d2gsid_head = pgsid;
536			return preset_d2gsid_head->d2gsid;
537			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1