src/d2cs/gamequeue.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 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
# ifdef HAVE_MEMORY_H
#  include <memory.h>
# endif
#endif
#include "compat/strcasecmp.h"

#include "connection.h"
#include "gamequeue.h"
#include "handle_d2cs.h"
#include "common/packet.h"
#include "common/list.h"
#include "common/eventlog.h"
#include "common/xalloc.h"
#include "common/setup_after.h"

static t_list   * gqlist_head=NULL;
static unsigned int gqlist_seqno=0;

extern t_list * gqlist(void)
{
        return gqlist_head;
}

extern int gqlist_create(void)
{
        gqlist_head=list_create();
        return 0;
}

extern int gqlist_destroy(void)
{
        t_gq    * gq;

        BEGIN_LIST_TRAVERSE_DATA(gqlist_head,gq)
        {
                gq_destroy(gq,(t_elem **)curr_elem_);
        }
        END_LIST_TRAVERSE_DATA()

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

extern t_gq * gq_create(unsigned int clientid, t_packet * packet, char const * gamename)
{
        t_gq    * gq;

        gq=xmalloc(sizeof(t_gq));
        gq->seqno=++gqlist_seqno;
        gq->clientid=clientid;
        gq->packet=packet;
        strncpy(gq->gamename, gamename, MAX_GAMENAME_LEN);
        if (packet) packet_add_ref(packet);
        list_append_data(gqlist_head,gq);
        return gq;
}

extern int gq_destroy(t_gq * gq, t_elem ** elem)
{
        ASSERT(gq,-1);
        if (list_remove_data(gqlist_head,gq,elem)<0) {
                eventlog(eventlog_level_error,__FUNCTION__,"error remove game queue from list");
                return -1;
        }
        if (gq->packet) packet_del_ref(gq->packet);
        xfree(gq);
        return 0;
}

extern unsigned int gq_get_clientid(t_gq const * gq)
{
        ASSERT(gq,0);
        return gq->clientid;
}

extern int gqlist_check_creategame(int number)
{
        t_connection    * c;
        t_gq            * gq;
        int             i=0;

        if (number <= 0) return -1;

        BEGIN_LIST_TRAVERSE_DATA(gqlist_head,gq)
        {
                c=d2cs_connlist_find_connection_by_sessionnum(gq->clientid);
                if (!c) {
                        eventlog(eventlog_level_error,__FUNCTION__,"client %d not found (gamename: %s)",gq->clientid,gq->gamename);
                        gq_destroy(gq,&curr_elem_);
                        continue;
                } else if (!conn_get_gamequeue(c)) {
                        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game queue for client %s",d2cs_conn_get_account(c));
                        gq_destroy(gq,&curr_elem_);
                        continue;
                } else {
                        eventlog(eventlog_level_info,__FUNCTION__,"try create game %s for account %s",gq->gamename,d2cs_conn_get_account(c));
                        d2cs_handle_client_creategame(c,gq->packet);
                        conn_set_gamequeue(c,NULL);
                        gq_destroy(gq,&curr_elem_);
                        i++;
                        if(i >= number) break;
                }
        }
        END_LIST_TRAVERSE_DATA()
        return 0;
}

extern int gqlist_update_all_clients(void)
{
        t_connection    * c;
        t_gq            * gq;
        unsigned int    n;

        n=0;
        BEGIN_LIST_TRAVERSE_DATA(gqlist_head,gq)
        {
                c=d2cs_connlist_find_connection_by_sessionnum(gq->clientid);
                if (!c) {
                        eventlog(eventlog_level_error,__FUNCTION__,"client %d not found (gamename: %s)",gq->clientid,gq->gamename);
                        gq_destroy(gq,&curr_elem_);
                        continue;
                } else {
                        n++;
                        eventlog(eventlog_level_debug,__FUNCTION__,"update client %s position to %d",d2cs_conn_get_account(c),n);
                        d2cs_send_client_creategamewait(c,n);
                }
        }
        END_LIST_TRAVERSE_DATA()
        if (n) eventlog(eventlog_level_info,__FUNCTION__,"total %d game queues",n);
        return 0;
}

extern unsigned int gqlist_get_gq_position(t_gq * gq)
{
        t_gq            * tmp;
        unsigned int    pos;

        pos=0;
        BEGIN_LIST_TRAVERSE_DATA(gqlist_head,tmp)
        {
                pos++;
                if (tmp==gq) return pos;
        }
        END_LIST_TRAVERSE_DATA()
        return 0;
}

extern unsigned int gqlist_get_length(void)
{
        return list_get_length(gqlist_head);
}

extern t_gq * gqlist_find_game(char const * gamename)
{
        t_gq            * gq;

        BEGIN_LIST_TRAVERSE_DATA(gqlist_head,gq)
        {
                if (!strcasecmp(gq->gamename,gamename)) return gq;
        }
        END_LIST_TRAVERSE_DATA()
        return NULL;
}
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 STDC_HEADERS
22			# include <stdlib.h>
23			#else
24			# ifdef HAVE_MALLOC_H
25			# include <malloc.h>
26			# endif
27			#endif
28			#ifdef HAVE_STRING_H
29			# include <string.h>
30			#else
31			# ifdef HAVE_STRINGS_H
32			# include <strings.h>
33			# endif
34			# ifdef HAVE_MEMORY_H
35			# include <memory.h>
36			# endif
37			#endif
38			#include "compat/strcasecmp.h"
39
40			#include "connection.h"
41			#include "gamequeue.h"
42			#include "handle_d2cs.h"
43			#include "common/packet.h"
44			#include "common/list.h"
45			#include "common/eventlog.h"
46			#include "common/xalloc.h"
47			#include "common/setup_after.h"
48
49			static t_list * gqlist_head=NULL;
50			static unsigned int gqlist_seqno=0;
51
52			extern t_list * gqlist(void)
53			{
54			return gqlist_head;
55			}
56
57			extern int gqlist_create(void)
58			{
59			gqlist_head=list_create();
60			return 0;
61			}
62
63			extern int gqlist_destroy(void)
64			{
65			t_gq * gq;
66
67			BEGIN_LIST_TRAVERSE_DATA(gqlist_head,gq)
68			{
69			gq_destroy(gq,(t_elem **)curr_elem_);
70			}
71			END_LIST_TRAVERSE_DATA()
72
73			if (list_destroy(gqlist_head)<0) {
74			eventlog(eventlog_level_error,__FUNCTION__,"error destroy game queue list");
75			return -1;
76			}
77			gqlist_head=NULL;
78			return 0;
79			}
80
81			extern t_gq * gq_create(unsigned int clientid, t_packet * packet, char const * gamename)
82			{
83			t_gq * gq;
84
85			gq=xmalloc(sizeof(t_gq));
86			gq->seqno=++gqlist_seqno;
87			gq->clientid=clientid;
88			gq->packet=packet;
89			strncpy(gq->gamename, gamename, MAX_GAMENAME_LEN);
90			if (packet) packet_add_ref(packet);
91			list_append_data(gqlist_head,gq);
92			return gq;
93			}
94
95			extern int gq_destroy(t_gq * gq, t_elem ** elem)
96			{
97			ASSERT(gq,-1);
98			if (list_remove_data(gqlist_head,gq,elem)<0) {
99			eventlog(eventlog_level_error,__FUNCTION__,"error remove game queue from list");
100			return -1;
101			}
102			if (gq->packet) packet_del_ref(gq->packet);
103			xfree(gq);
104			return 0;
105			}
106
107			extern unsigned int gq_get_clientid(t_gq const * gq)
108			{
109			ASSERT(gq,0);
110			return gq->clientid;
111			}
112
113			extern int gqlist_check_creategame(int number)
114			{
115			t_connection * c;
116			t_gq * gq;
117			int i=0;
118
119			if (number <= 0) return -1;
120
121			BEGIN_LIST_TRAVERSE_DATA(gqlist_head,gq)
122			{
123			c=d2cs_connlist_find_connection_by_sessionnum(gq->clientid);
124			if (!c) {
125			eventlog(eventlog_level_error,__FUNCTION__,"client %d not found (gamename: %s)",gq->clientid,gq->gamename);
126			gq_destroy(gq,&curr_elem_);
127			continue;
128			} else if (!conn_get_gamequeue(c)) {
129			eventlog(eventlog_level_error,__FUNCTION__,"got NULL game queue for client %s",d2cs_conn_get_account(c));
130			gq_destroy(gq,&curr_elem_);
131			continue;
132			} else {
133			eventlog(eventlog_level_info,__FUNCTION__,"try create game %s for account %s",gq->gamename,d2cs_conn_get_account(c));
134			d2cs_handle_client_creategame(c,gq->packet);
135			conn_set_gamequeue(c,NULL);
136			gq_destroy(gq,&curr_elem_);
137			i++;
138			if(i >= number) break;
139			}
140			}
141			END_LIST_TRAVERSE_DATA()
142			return 0;
143			}
144
145			extern int gqlist_update_all_clients(void)
146			{
147			t_connection * c;
148			t_gq * gq;
149			unsigned int n;
150
151			n=0;
152			BEGIN_LIST_TRAVERSE_DATA(gqlist_head,gq)
153			{
154			c=d2cs_connlist_find_connection_by_sessionnum(gq->clientid);
155			if (!c) {
156			eventlog(eventlog_level_error,__FUNCTION__,"client %d not found (gamename: %s)",gq->clientid,gq->gamename);
157			gq_destroy(gq,&curr_elem_);
158			continue;
159			} else {
160			n++;
161			eventlog(eventlog_level_debug,__FUNCTION__,"update client %s position to %d",d2cs_conn_get_account(c),n);
162			d2cs_send_client_creategamewait(c,n);
163			}
164			}
165			END_LIST_TRAVERSE_DATA()
166			if (n) eventlog(eventlog_level_info,__FUNCTION__,"total %d game queues",n);
167			return 0;
168			}
169
170			extern unsigned int gqlist_get_gq_position(t_gq * gq)
171			{
172			t_gq * tmp;
173			unsigned int pos;
174
175			pos=0;
176			BEGIN_LIST_TRAVERSE_DATA(gqlist_head,tmp)
177			{
178			pos++;
179			if (tmp==gq) return pos;
180			}
181			END_LIST_TRAVERSE_DATA()
182			return 0;
183			}
184
185			extern unsigned int gqlist_get_length(void)
186			{
187			return list_get_length(gqlist_head);
188			}
189
190			extern t_gq * gqlist_find_game(char const * gamename)
191			{
192			t_gq * gq;
193
194			BEGIN_LIST_TRAVERSE_DATA(gqlist_head,gq)
195			{
196			if (!strcasecmp(gq->gamename,gamename)) return gq;
197			}
198			END_LIST_TRAVERSE_DATA()
199			return NULL;
200			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1