src/d2cs/d2gs.c

/*
 * Copyright (C) 2000,2001      Onlyer  (onlyer@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
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif
#include "compat/strsep.h"
#include "compat/char_bit.h"
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h> /* needed to include netinet/in.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> /* FIXME: probably not needed... do some systems put types in here or something? */
#endif
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#include "compat/psock.h"

#include "d2gs.h"
#include "game.h"
#include "net.h"
#include "bit.h"
#include "prefs.h"
#include "gs_scope.h"
#include "connection.h"
#include "common/introtate.h"
#include "common/addr.h"
#include "common/list.h"
#include "common/eventlog.h"
#include "common/xalloc.h"
#include "common/setup_after.h"

static t_list           * d2gslist_head=NULL;
static unsigned int     d2gs_id=0;
static unsigned int     total_d2gs=0;

extern t_list * d2gslist(void)
{
        return d2gslist_head;
}

extern int d2gslist_create(void)
{
        d2gslist_head=list_create();
        return d2gslist_reload(prefs_get_d2gs_list());
}

extern int d2gslist_reload(char const * gslist)
{
        t_addrlist      * gsaddrs;
        t_d2gs          * gs;

        if (!d2gslist_head) return -1;

        BEGIN_LIST_TRAVERSE_DATA(d2gslist_head,gs)
        {
                BIT_CLR_FLAG(gs->flag, D2GS_FLAG_VALID);
        }
        END_LIST_TRAVERSE_DATA()

        gsaddrs = addrlist_create(gslist, INADDR_ANY, 0);
        if (gsaddrs) {
            t_elem const *acurr;
            t_addr * curr_laddr;

            LIST_TRAVERSE_CONST(gsaddrs, acurr)
            {
                curr_laddr = (t_addr*)elem_get_data(acurr);
                if (!curr_laddr) {
                    eventlog(eventlog_level_error, __FUNCTION__, "found NULL value in gslist");
                    continue;
                }
                if (!(gs=d2gslist_find_gs_by_ip(addr_get_ip(curr_laddr))))
                    gs = d2gs_create(addr_num_to_ip_str(addr_get_ip(curr_laddr)));
                if (gs) BIT_SET_FLAG(gs->flag, D2GS_FLAG_VALID);
            }
            addrlist_destroy(gsaddrs);
        }

        BEGIN_LIST_TRAVERSE_DATA(d2gslist_head,gs)
        {
                if (!BIT_TST_FLAG(gs->flag, D2GS_FLAG_VALID)) {
                        d2gs_destroy(gs,&curr_elem_);
                }
        }
        END_LIST_TRAVERSE_DATA()
        
        return 0;
}

extern int d2gslist_destroy(void)
{
        t_d2gs  * gs;

        BEGIN_LIST_TRAVERSE_DATA_CONST(d2gslist_head,gs)
        {
                d2gs_destroy(gs,(t_elem **)&curr_elem_);
        }
        END_LIST_TRAVERSE_DATA_CONST()
        d2cs_connlist_reap();

        if (list_destroy(d2gslist_head)<0) {
                eventlog(eventlog_level_error,__FUNCTION__,"error destroy d2gs list");
                return -1;
        }
        d2gslist_head=NULL;
        
        return 0;
}

extern t_d2gs * d2gslist_find_gs_by_ip(unsigned int ip)
{
        t_d2gs  * gs;

        BEGIN_LIST_TRAVERSE_DATA_CONST(d2gslist_head,gs)
        {
                if (gs->ip==ip) return gs;
        }
        END_LIST_TRAVERSE_DATA_CONST()
        return NULL;
}

extern t_d2gs * d2gslist_find_gs(unsigned int id)
{
        t_d2gs  * gs;

        BEGIN_LIST_TRAVERSE_DATA_CONST(d2gslist_head,gs)
        {
                if (gs->id==id) return gs;
        }
        END_LIST_TRAVERSE_DATA_CONST()
        return NULL;
}

extern t_d2gs * d2gs_create(char const * ipaddr)
{
        t_d2gs  * gs;
        unsigned int    ip;

        ASSERT(ipaddr,NULL);
        if ((ip=net_inet_addr(ipaddr))==~0U) {
                eventlog(eventlog_level_error,__FUNCTION__,"got bad ip address %s",ipaddr);
                return NULL;
        }
        if (d2gslist_find_gs_by_ip(ntohl(ip))) {
                eventlog(eventlog_level_error,__FUNCTION__,"game server %s already in list",ipaddr);
                return NULL;
        }
        gs=xmalloc(sizeof(t_d2gs));
        gs->ip=ntohl(ip);
        gs->id=++d2gs_id;
        gs->active=0;
        gs->token=0;
        gs->state=d2gs_state_none;
        gs->gamenum=0;
        gs->maxgame=0;
        gs->connection=NULL;

        if (list_append_data(d2gslist_head,gs)<0) {
                eventlog(eventlog_level_error,__FUNCTION__,"error add gs to list");
                xfree(gs);
                return NULL;
        }
        eventlog(eventlog_level_info,__FUNCTION__,"added game server %s (id: %d) to list",ipaddr,gs->id);
        return gs;
}

extern int d2gs_destroy(t_d2gs * gs, t_elem ** curr)
{
        ASSERT(gs,-1);
        if (list_remove_data(d2gslist_head,gs,curr)<0) {
                eventlog(eventlog_level_error,__FUNCTION__,"error remove gs from list");
                return -1;
        }
        if (gs->active && gs->connection) {
                d2cs_conn_set_state(gs->connection, conn_state_destroy);
                d2gs_deactive(gs, gs->connection);
        }
        eventlog(eventlog_level_info,__FUNCTION__,"removed game server %s (id: %d) from list",addr_num_to_ip_str(gs->ip),gs->id);
        xfree(gs);
        return 0;
}

extern t_d2gs * d2gslist_get_server_by_id(unsigned int id)
{
        t_d2gs  * gs;

        BEGIN_LIST_TRAVERSE_DATA_CONST(d2gslist_head,gs)
        {
                if (gs->id==id) return gs;
        }
        END_LIST_TRAVERSE_DATA_CONST()
        return NULL;
}
          
extern t_d2gs * d2gslist_choose_server(t_connection * c)
{
        t_d2gs                  * gs;
        t_d2gs                  * ogs;
        unsigned int            percent;
        unsigned int            min_percent=100;

        ogs=NULL;
        BEGIN_LIST_TRAVERSE_DATA_CONST(d2gslist_head,gs)
        {
                if (!gs->active) continue;
                if (!gs->connection) continue;
                if (gs->state!=d2gs_state_authed) continue;
                if (!gs->maxgame) continue;
                if (gs->gamenum>=gs->maxgame) continue;
                
                /* Added by Leaflet at 2006-06-05 -- Begin */
                if (serve_scope_list_validate (gs->ip, c)) continue;
                /* End */
                
                percent=100*gs->gamenum/gs->maxgame;
                if (percent<min_percent) {
                        min_percent=percent;
                        ogs=gs;
                }
        }
        END_LIST_TRAVERSE_DATA_CONST()
        return ogs;
}

extern int d2gs_set_state(t_d2gs * gs, t_d2gs_state state)
{
        ASSERT(gs,-1);
        gs->state=state;
        return 0;
}

extern t_d2gs_state d2gs_get_state(t_d2gs const * gs)
{
        ASSERT(gs,d2gs_state_none);
        return gs->state;
}

extern int d2gs_add_gamenum(t_d2gs * gs, int number)
{
        ASSERT(gs,-1);
        gs->gamenum += number;
        return 0;
}

extern unsigned int d2gs_get_gamenum(t_d2gs const * gs)
{
        ASSERT(gs,0);
        return gs->gamenum;
}


extern int d2gs_set_maxgame(t_d2gs * gs,unsigned int maxgame)
{
        ASSERT(gs,-1);
        gs->maxgame=maxgame;
        return 0;
}

extern unsigned int d2gs_get_maxgame(t_d2gs const * gs)
{
        ASSERT(gs,0);
        return gs->maxgame;
}

extern unsigned int d2gs_get_id(t_d2gs const * gs)
{
        ASSERT(gs,0);
        return gs->id;
}

extern unsigned int d2gs_get_ip(t_d2gs const * gs)
{
        ASSERT(gs,0);
        return gs->ip;
}

extern unsigned int d2gs_get_token(t_d2gs const * gs)
{
        return gs->token;
}

extern unsigned int d2gs_make_token(t_d2gs * gs)
{
        return ((unsigned int)rand())^((++(gs->token))+((unsigned int)time(NULL)));
}

extern t_connection * d2gs_get_connection(t_d2gs const * gs)
{
        ASSERT(gs,NULL);
        return gs->connection;
}

extern int d2gs_active(t_d2gs * gs, t_connection * c)
{
        ASSERT(gs,-1);
        ASSERT(c,-1);

        if (gs->active && gs->connection) {
                eventlog(eventlog_level_warn,__FUNCTION__,"game server %d is already actived, deactive previous connection first",gs->id);
                d2gs_deactive(gs, gs->connection);
        }
        total_d2gs++;
        eventlog(eventlog_level_info,__FUNCTION__,"game server %s (id: %d) actived (%d total)",addr_num_to_addr_str(d2cs_conn_get_addr(c),
                d2cs_conn_get_port(c)),gs->id,total_d2gs);
        gs->state=d2gs_state_authed;
        gs->connection=c;
        gs->active=1;
        gs->gamenum=0;
        gs->maxgame=0;
        return 0;
}

extern int d2gs_deactive(t_d2gs * gs, t_connection * c)
{
        t_game * game;

        ASSERT(gs,-1);
        if (!gs->active || !gs->connection) {
                eventlog(eventlog_level_warn,__FUNCTION__,"game server %d is not actived yet", gs->id);
                return -1;
        }
        if (gs->connection != c) {
                eventlog(eventlog_level_debug,__FUNCTION__,"game server %d connection mismatch,ignore it", gs->id);
                return 0;
        }
        total_d2gs--;
        eventlog(eventlog_level_info,__FUNCTION__,"game server %s (id: %d) deactived (%d left)",addr_num_to_addr_str(d2cs_conn_get_addr(gs->connection),d2cs_conn_get_port(gs->connection)),gs->id,total_d2gs);
        gs->state=d2gs_state_none;
        gs->connection=NULL;
        gs->active=0;
        gs->maxgame=0;
        eventlog(eventlog_level_info,__FUNCTION__,"destroying all games on game server %d",gs->id);
        BEGIN_LIST_TRAVERSE_DATA(d2cs_gamelist(),game)
        {
                if (game_get_d2gs(game)==gs) game_destroy(game,&curr_elem_);
        }
        END_LIST_TRAVERSE_DATA()
        if (gs->gamenum!=0) {
                eventlog(eventlog_level_error,__FUNCTION__,"game server %d deactived but still with games left",gs->id);
        }
        gs->gamenum=0;
        return 0;
}

extern unsigned int d2gs_calc_checksum(t_connection * c)
{
        unsigned int    sessionnum, checksum, port, addr;
        unsigned int    i, len, ch;
        char const      * realmname;
        char const      * password;

        ASSERT(c,0);
        sessionnum=d2cs_conn_get_sessionnum(c);
        checksum=prefs_get_d2gs_checksum();
        port=d2cs_conn_get_port(c);
        addr=d2cs_conn_get_addr(c);
        realmname=prefs_get_realmname();
        password=prefs_get_d2gs_password();

        len=strlen(realmname);
        for (i=0; i<len ; i++) {
                ch = (unsigned int)(unsigned char) realmname[i];
                checksum ^= ROTL(sessionnum,i, sizeof(unsigned int) * CHAR_BIT);
                checksum ^= ROTL(port , ch, sizeof(unsigned int) * CHAR_BIT);
        }
        len=strlen(password);
        for (i=0; i<len ; i++) {
                ch = (unsigned int)(unsigned char) password[i];
                checksum ^= ROTL(sessionnum,i, sizeof(unsigned int) * CHAR_BIT);
                checksum ^= ROTL(port , ch, sizeof(unsigned int) * CHAR_BIT);
        }
        checksum ^= addr;
        return checksum;
}

extern int d2gs_keepalive(void)
{
        t_packet        * packet;
        t_d2gs *        gs;

        if (!(packet=packet_create(packet_class_d2gs))) {
                eventlog(eventlog_level_error,__FUNCTION__,"error creating packet");
                return -1;
        }
        packet_set_size(packet,sizeof(t_d2cs_d2gs_echoreq));
        packet_set_type(packet,D2CS_D2GS_ECHOREQ);
        /* FIXME: sequence number not set */
        bn_int_set(&packet->u.d2cs_d2gs.h.seqno,0);             
        BEGIN_LIST_TRAVERSE_DATA(d2gslist_head,gs)
        {
                if (gs->active && gs->connection) {
                        conn_push_outqueue(gs->connection,packet);
                }
        }
        END_LIST_TRAVERSE_DATA()
        packet_del_ref(packet);
        return 0;
}

extern int d2gs_restart_all_gs(void)
{
        t_packet        * packet;
        t_d2gs          * gs;
        
        if (!(packet=packet_create(packet_class_d2gs))) {
                eventlog(eventlog_level_error, __FUNCTION__, "error creating packet");
                return -1;
        }
        packet_set_size(packet,sizeof(t_d2cs_d2gs_control));
        packet_set_type(packet,D2CS_D2GS_CONTROL);
        /* FIXME: sequence number not set */
        bn_int_set(&packet->u.d2cs_d2gs.h.seqno,0);                     
        bn_int_set(&packet->u.d2cs_d2gs_control.cmd, D2CS_D2GS_CONTROL_CMD_RESTART);
        bn_int_set(&packet->u.d2cs_d2gs_control.value, prefs_get_d2gs_restart_delay());
        
        BEGIN_LIST_TRAVERSE_DATA(d2gslist_head,gs)
        {
                if (gs->connection) {
                    conn_push_outqueue(gs->connection,packet);
                }
        }
        
        END_LIST_TRAVERSE_DATA()
        packet_del_ref(packet);
        return 0;
}

1	sysadm	1.1	/*
2			* Copyright (C) 2000,2001 Onlyer (onlyer@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			#ifdef STDC_HEADERS
29			# include <stdlib.h>
30			#else
31			# ifdef HAVE_MALLOC_H
32			# include <malloc.h>
33			# endif
34			#endif
35			#ifdef HAVE_STRING_H
36			# include <string.h>
37			#else
38			# ifdef HAVE_STRINGS_H
39			# include <strings.h>
40			# endif
41			#endif
42			#include "compat/strsep.h"
43			#include "compat/char_bit.h"
44			#ifdef HAVE_SYS_TYPES_H
45			# include <sys/types.h> /* needed to include netinet/in.h */
46			#endif
47			#ifdef HAVE_SYS_SOCKET_H
48			# include <sys/socket.h>
49			#endif
50			#include "compat/socket.h"
51			#ifdef HAVE_SYS_PARAM_H
52			# include <sys/param.h>
53			#endif
54			#ifdef HAVE_NETINET_IN_H
55			# include <netinet/in.h>
56			#endif
57			#include "compat/netinet_in.h"
58			#ifdef HAVE_ARPA_INET_H
59			# include <arpa/inet.h> /* FIXME: probably not needed... do some systems put types in here or something? */
60			#endif
61			#ifdef TIME_WITH_SYS_TIME
62			# include <sys/time.h>
63			# include <time.h>
64			#else
65			# ifdef HAVE_SYS_TIME_H
66			# include <sys/time.h>
67			# else
68			# include <time.h>
69			# endif
70			#endif
71			#include "compat/psock.h"
72
73			#include "d2gs.h"
74			#include "game.h"
75			#include "net.h"
76			#include "bit.h"
77			#include "prefs.h"
78	sysadm	1.2	#include "gs_scope.h"
79	sysadm	1.1	#include "connection.h"
80			#include "common/introtate.h"
81			#include "common/addr.h"
82			#include "common/list.h"
83			#include "common/eventlog.h"
84			#include "common/xalloc.h"
85			#include "common/setup_after.h"
86
87			static t_list * d2gslist_head=NULL;
88			static unsigned int d2gs_id=0;
89			static unsigned int total_d2gs=0;
90
91			extern t_list * d2gslist(void)
92			{
93			return d2gslist_head;
94			}
95
96			extern int d2gslist_create(void)
97			{
98			d2gslist_head=list_create();
99			return d2gslist_reload(prefs_get_d2gs_list());
100			}
101
102			extern int d2gslist_reload(char const * gslist)
103			{
104			t_addrlist * gsaddrs;
105			t_d2gs * gs;
106
107			if (!d2gslist_head) return -1;
108
109			BEGIN_LIST_TRAVERSE_DATA(d2gslist_head,gs)
110			{
111			BIT_CLR_FLAG(gs->flag, D2GS_FLAG_VALID);
112			}
113			END_LIST_TRAVERSE_DATA()
114
115			gsaddrs = addrlist_create(gslist, INADDR_ANY, 0);
116			if (gsaddrs) {
117			t_elem const *acurr;
118			t_addr * curr_laddr;
119
120			LIST_TRAVERSE_CONST(gsaddrs, acurr)
121			{
122			curr_laddr = (t_addr*)elem_get_data(acurr);
123			if (!curr_laddr) {
124			eventlog(eventlog_level_error, __FUNCTION__, "found NULL value in gslist");
125			continue;
126			}
127			if (!(gs=d2gslist_find_gs_by_ip(addr_get_ip(curr_laddr))))
128			gs = d2gs_create(addr_num_to_ip_str(addr_get_ip(curr_laddr)));
129			if (gs) BIT_SET_FLAG(gs->flag, D2GS_FLAG_VALID);
130			}
131			addrlist_destroy(gsaddrs);
132			}
133
134			BEGIN_LIST_TRAVERSE_DATA(d2gslist_head,gs)
135			{
136			if (!BIT_TST_FLAG(gs->flag, D2GS_FLAG_VALID)) {
137			d2gs_destroy(gs,&curr_elem_);
138			}
139			}
140			END_LIST_TRAVERSE_DATA()
141
142			return 0;
143			}
144
145			extern int d2gslist_destroy(void)
146			{
147			t_d2gs * gs;
148
149			BEGIN_LIST_TRAVERSE_DATA_CONST(d2gslist_head,gs)
150			{
151			d2gs_destroy(gs,(t_elem **)&curr_elem_);
152			}
153			END_LIST_TRAVERSE_DATA_CONST()
154			d2cs_connlist_reap();
155
156			if (list_destroy(d2gslist_head)<0) {
157			eventlog(eventlog_level_error,__FUNCTION__,"error destroy d2gs list");
158			return -1;
159			}
160			d2gslist_head=NULL;
161
162			return 0;
163			}
164
165			extern t_d2gs * d2gslist_find_gs_by_ip(unsigned int ip)
166			{
167			t_d2gs * gs;
168
169			BEGIN_LIST_TRAVERSE_DATA_CONST(d2gslist_head,gs)
170			{
171			if (gs->ip==ip) return gs;
172			}
173			END_LIST_TRAVERSE_DATA_CONST()
174			return NULL;
175			}
176
177			extern t_d2gs * d2gslist_find_gs(unsigned int id)
178			{
179			t_d2gs * gs;
180
181			BEGIN_LIST_TRAVERSE_DATA_CONST(d2gslist_head,gs)
182			{
183			if (gs->id==id) return gs;
184			}
185			END_LIST_TRAVERSE_DATA_CONST()
186			return NULL;
187			}
188
189			extern t_d2gs * d2gs_create(char const * ipaddr)
190			{
191			t_d2gs * gs;
192			unsigned int ip;
193
194			ASSERT(ipaddr,NULL);
195			if ((ip=net_inet_addr(ipaddr))==~0U) {
196			eventlog(eventlog_level_error,__FUNCTION__,"got bad ip address %s",ipaddr);
197			return NULL;
198			}
199			if (d2gslist_find_gs_by_ip(ntohl(ip))) {
200			eventlog(eventlog_level_error,__FUNCTION__,"game server %s already in list",ipaddr);
201			return NULL;
202			}
203			gs=xmalloc(sizeof(t_d2gs));
204			gs->ip=ntohl(ip);
205			gs->id=++d2gs_id;
206			gs->active=0;
207			gs->token=0;
208			gs->state=d2gs_state_none;
209			gs->gamenum=0;
210			gs->maxgame=0;
211			gs->connection=NULL;
212
213			if (list_append_data(d2gslist_head,gs)<0) {
214			eventlog(eventlog_level_error,__FUNCTION__,"error add gs to list");
215			xfree(gs);
216			return NULL;
217			}
218			eventlog(eventlog_level_info,__FUNCTION__,"added game server %s (id: %d) to list",ipaddr,gs->id);
219			return gs;
220			}
221
222			extern int d2gs_destroy(t_d2gs * gs, t_elem ** curr)
223			{
224			ASSERT(gs,-1);
225			if (list_remove_data(d2gslist_head,gs,curr)<0) {
226			eventlog(eventlog_level_error,__FUNCTION__,"error remove gs from list");
227			return -1;
228			}
229			if (gs->active && gs->connection) {
230			d2cs_conn_set_state(gs->connection, conn_state_destroy);
231			d2gs_deactive(gs, gs->connection);
232			}
233			eventlog(eventlog_level_info,__FUNCTION__,"removed game server %s (id: %d) from list",addr_num_to_ip_str(gs->ip),gs->id);
234			xfree(gs);
235			return 0;
236			}
237
238			extern t_d2gs * d2gslist_get_server_by_id(unsigned int id)
239			{
240			t_d2gs * gs;
241
242			BEGIN_LIST_TRAVERSE_DATA_CONST(d2gslist_head,gs)
243			{
244			if (gs->id==id) return gs;
245			}
246			END_LIST_TRAVERSE_DATA_CONST()
247			return NULL;
248			}
249
250			extern t_d2gs * d2gslist_choose_server(t_connection * c)
251			{
252			t_d2gs * gs;
253			t_d2gs * ogs;
254			unsigned int percent;
255			unsigned int min_percent=100;
256
257			ogs=NULL;
258			BEGIN_LIST_TRAVERSE_DATA_CONST(d2gslist_head,gs)
259			{
260			if (!gs->active) continue;
261			if (!gs->connection) continue;
262			if (gs->state!=d2gs_state_authed) continue;
263			if (!gs->maxgame) continue;
264			if (gs->gamenum>=gs->maxgame) continue;
265
266			/* Added by Leaflet at 2006-06-05 -- Begin */
267			if (serve_scope_list_validate (gs->ip, c)) continue;
268			/* End */
269
270			percent=100*gs->gamenum/gs->maxgame;
271			if (percent<min_percent) {
272			min_percent=percent;
273			ogs=gs;
274			}
275			}
276			END_LIST_TRAVERSE_DATA_CONST()
277			return ogs;
278			}
279
280			extern int d2gs_set_state(t_d2gs * gs, t_d2gs_state state)
281			{
282			ASSERT(gs,-1);
283			gs->state=state;
284			return 0;
285			}
286
287			extern t_d2gs_state d2gs_get_state(t_d2gs const * gs)
288			{
289			ASSERT(gs,d2gs_state_none);
290			return gs->state;
291			}
292
293			extern int d2gs_add_gamenum(t_d2gs * gs, int number)
294			{
295			ASSERT(gs,-1);
296			gs->gamenum += number;
297			return 0;
298			}
299
300			extern unsigned int d2gs_get_gamenum(t_d2gs const * gs)
301			{
302			ASSERT(gs,0);
303			return gs->gamenum;
304			}
305
306
307			extern int d2gs_set_maxgame(t_d2gs * gs,unsigned int maxgame)
308			{
309			ASSERT(gs,-1);
310			gs->maxgame=maxgame;
311			return 0;
312			}
313
314			extern unsigned int d2gs_get_maxgame(t_d2gs const * gs)
315			{
316			ASSERT(gs,0);
317			return gs->maxgame;
318			}
319
320			extern unsigned int d2gs_get_id(t_d2gs const * gs)
321			{
322			ASSERT(gs,0);
323			return gs->id;
324			}
325
326			extern unsigned int d2gs_get_ip(t_d2gs const * gs)
327			{
328			ASSERT(gs,0);
329			return gs->ip;
330			}
331
332			extern unsigned int d2gs_get_token(t_d2gs const * gs)
333			{
334			return gs->token;
335			}
336
337			extern unsigned int d2gs_make_token(t_d2gs * gs)
338			{
339			return ((unsigned int)rand())^((++(gs->token))+((unsigned int)time(NULL)));
340			}
341
342			extern t_connection * d2gs_get_connection(t_d2gs const * gs)
343			{
344			ASSERT(gs,NULL);
345			return gs->connection;
346			}
347
348			extern int d2gs_active(t_d2gs * gs, t_connection * c)
349			{
350			ASSERT(gs,-1);
351			ASSERT(c,-1);
352
353			if (gs->active && gs->connection) {
354			eventlog(eventlog_level_warn,__FUNCTION__,"game server %d is already actived, deactive previous connection first",gs->id);
355			d2gs_deactive(gs, gs->connection);
356			}
357			total_d2gs++;
358			eventlog(eventlog_level_info,__FUNCTION__,"game server %s (id: %d) actived (%d total)",addr_num_to_addr_str(d2cs_conn_get_addr(c),
359			d2cs_conn_get_port(c)),gs->id,total_d2gs);
360			gs->state=d2gs_state_authed;
361			gs->connection=c;
362			gs->active=1;
363			gs->gamenum=0;
364			gs->maxgame=0;
365			return 0;
366			}
367
368			extern int d2gs_deactive(t_d2gs * gs, t_connection * c)
369			{
370			t_game * game;
371
372			ASSERT(gs,-1);
373			if (!gs->active \|\| !gs->connection) {
374			eventlog(eventlog_level_warn,__FUNCTION__,"game server %d is not actived yet", gs->id);
375			return -1;
376			}
377			if (gs->connection != c) {
378			eventlog(eventlog_level_debug,__FUNCTION__,"game server %d connection mismatch,ignore it", gs->id);
379			return 0;
380			}
381			total_d2gs--;
382			eventlog(eventlog_level_info,__FUNCTION__,"game server %s (id: %d) deactived (%d left)",addr_num_to_addr_str(d2cs_conn_get_addr(gs->connection),d2cs_conn_get_port(gs->connection)),gs->id,total_d2gs);
383			gs->state=d2gs_state_none;
384			gs->connection=NULL;
385			gs->active=0;
386			gs->maxgame=0;
387			eventlog(eventlog_level_info,__FUNCTION__,"destroying all games on game server %d",gs->id);
388			BEGIN_LIST_TRAVERSE_DATA(d2cs_gamelist(),game)
389			{
390			if (game_get_d2gs(game)==gs) game_destroy(game,&curr_elem_);
391			}
392			END_LIST_TRAVERSE_DATA()
393			if (gs->gamenum!=0) {
394			eventlog(eventlog_level_error,__FUNCTION__,"game server %d deactived but still with games left",gs->id);
395			}
396			gs->gamenum=0;
397			return 0;
398			}
399
400			extern unsigned int d2gs_calc_checksum(t_connection * c)
401			{
402			unsigned int sessionnum, checksum, port, addr;
403			unsigned int i, len, ch;
404			char const * realmname;
405			char const * password;
406
407			ASSERT(c,0);
408			sessionnum=d2cs_conn_get_sessionnum(c);
409			checksum=prefs_get_d2gs_checksum();
410			port=d2cs_conn_get_port(c);
411			addr=d2cs_conn_get_addr(c);
412			realmname=prefs_get_realmname();
413			password=prefs_get_d2gs_password();
414
415			len=strlen(realmname);
416			for (i=0; i<len ; i++) {
417			ch = (unsigned int)(unsigned char) realmname[i];
418			checksum ^= ROTL(sessionnum,i, sizeof(unsigned int) * CHAR_BIT);
419			checksum ^= ROTL(port , ch, sizeof(unsigned int) * CHAR_BIT);
420			}
421			len=strlen(password);
422			for (i=0; i<len ; i++) {
423			ch = (unsigned int)(unsigned char) password[i];
424			checksum ^= ROTL(sessionnum,i, sizeof(unsigned int) * CHAR_BIT);
425			checksum ^= ROTL(port , ch, sizeof(unsigned int) * CHAR_BIT);
426			}
427			checksum ^= addr;
428			return checksum;
429			}
430
431			extern int d2gs_keepalive(void)
432			{
433			t_packet * packet;
434			t_d2gs * gs;
435
436			if (!(packet=packet_create(packet_class_d2gs))) {
437			eventlog(eventlog_level_error,__FUNCTION__,"error creating packet");
438			return -1;
439			}
440			packet_set_size(packet,sizeof(t_d2cs_d2gs_echoreq));
441			packet_set_type(packet,D2CS_D2GS_ECHOREQ);
442			/* FIXME: sequence number not set */
443			bn_int_set(&packet->u.d2cs_d2gs.h.seqno,0);
444			BEGIN_LIST_TRAVERSE_DATA(d2gslist_head,gs)
445			{
446			if (gs->active && gs->connection) {
447			conn_push_outqueue(gs->connection,packet);
448			}
449			}
450			END_LIST_TRAVERSE_DATA()
451			packet_del_ref(packet);
452			return 0;
453			}
454
455			extern int d2gs_restart_all_gs(void)
456			{
457			t_packet * packet;
458			t_d2gs * gs;
459
460			if (!(packet=packet_create(packet_class_d2gs))) {
461			eventlog(eventlog_level_error, __FUNCTION__, "error creating packet");
462			return -1;
463			}
464			packet_set_size(packet,sizeof(t_d2cs_d2gs_control));
465			packet_set_type(packet,D2CS_D2GS_CONTROL);
466			/* FIXME: sequence number not set */
467			bn_int_set(&packet->u.d2cs_d2gs.h.seqno,0);
468			bn_int_set(&packet->u.d2cs_d2gs_control.cmd, D2CS_D2GS_CONTROL_CMD_RESTART);
469			bn_int_set(&packet->u.d2cs_d2gs_control.value, prefs_get_d2gs_restart_delay());
470
471			BEGIN_LIST_TRAVERSE_DATA(d2gslist_head,gs)
472			{
473			if (gs->connection) {
474			conn_push_outqueue(gs->connection,packet);
475			}
476			}
477
478			END_LIST_TRAVERSE_DATA()
479			packet_del_ref(packet);
480			return 0;
481			}
482
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1