src/d2cs/handle_signal.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
#include <errno.h>
#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/strdup.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 DO_POSIXSIG
# include <signal.h>
# include "compat/signal.h"
#endif
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#else
# ifdef HAVE_SYS_FILE_H
#  include <sys/file.h>
# endif
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#include "d2gs.h"
#include "game.h"
#include "prefs.h"
#include "d2ladder.h"
#include "cmdline_parse.h"
#include "handle_signal.h"
#include "common/trans.h"
#include "common/eventlog.h"
#include "common/xalloc.h"
#include "common/setup_after.h"

static void on_signal(int s);

static volatile struct
{
        unsigned char   do_quit;
        unsigned char   cancel_quit;
        unsigned char   reload_config;
        unsigned char   reload_ladder;
        unsigned char   restart_d2gs;
        unsigned int    exit_time;
} signal_data ={ 0, 0, 0, 0, 0, 0 };

extern int handle_signal(void)
{
        time_t          now;
    char const * levels;
    char *       temp;
    char const * tok;


        if (signal_data.cancel_quit) {
                signal_data.cancel_quit=0;
                if (!signal_data.exit_time) {
                        eventlog(eventlog_level_info,__FUNCTION__,"there is no previous shutdown to be canceled");
                } else {
                        signal_data.exit_time=0;
                        eventlog(eventlog_level_info,__FUNCTION__,"shutdown was canceled due to signal");
                }
        }
        if (signal_data.do_quit) {
                signal_data.do_quit=0;
                now=time(NULL);
                if (!signal_data.exit_time) {
                        signal_data.exit_time=now+d2cs_prefs_get_shutdown_delay();
                } else {
                        signal_data.exit_time-=d2cs_prefs_get_shutdown_decr();
                }
                eventlog(eventlog_level_info,__FUNCTION__,"the server is going to shutdown in %lu minutes",(signal_data.exit_time-now)/60);
        }
        if (signal_data.exit_time) {
                now=time(NULL);
                if (now >= (signed)signal_data.exit_time) {
                        eventlog(eventlog_level_info,__FUNCTION__,"shutdown server due to signal");
                        return -1;
                }
        }
        if (signal_data.reload_config) {
                signal_data.reload_config=0;
                eventlog(eventlog_level_info,__FUNCTION__,"reloading configuartion file due to signal");
                if (prefs_reload(cmdline_get_prefs_file())<0) {
                        eventlog(eventlog_level_error,__FUNCTION__,"error reload configuration file,exitting");
                        return -1;
                }
                if (d2gslist_reload(prefs_get_d2gs_list())<0) {
                        eventlog(eventlog_level_error,__FUNCTION__,"error reloading game server list,exitting");
                        return -1;
                }
                if (trans_reload(d2cs_prefs_get_transfile(),TRANS_D2CS)<0) {
                        eventlog(eventlog_level_error,__FUNCTION__,"could not reload trans list");
                }

        eventlog_clear_level();
        if ((levels = d2cs_prefs_get_loglevels()))
        {
            temp = xstrdup(levels);
            tok = strtok(temp,","); /* strtok modifies the string it is passed */

            while (tok)
            {
              if (eventlog_add_level(tok)<0)
              eventlog(eventlog_level_error,__FUNCTION__,"could not add log level \"%s\"",tok);
              tok = strtok(NULL,",");
            }

            xfree(temp);
        }

                if (!cmdline_get_debugmode()) eventlog_open(d2cs_prefs_get_logfile());
        }
        if (signal_data.reload_ladder) {
                signal_data.reload_ladder=0;
                eventlog(eventlog_level_info,__FUNCTION__,"reloading ladder data due to signal");
                d2ladder_refresh();
        }
        
        if (signal_data.restart_d2gs) {
                signal_data.restart_d2gs=0;
                eventlog(eventlog_level_info,__FUNCTION__,"restarting all game servers due to signal");
                d2gs_restart_all_gs();
        }
        
        return 0;
}
#ifdef WIN32
extern void signal_quit_wrapper(void)
{
  signal_data.do_quit=1;
}

extern void signal_reload_config_wrapper(void)
{
    signal_data.reload_config = 1;
}

extern void signal_load_ladder_wrapper(void)
{
    signal_data.reload_ladder = 1;
}

extern void signal_exit_wrapper(void)
{
    signal_data.exit_time = 1;
    signal_data.do_quit = 1;
}

extern void signal_restart_d2gs_wrapper(void)
{
    signal_data.restart_d2gs = 1;
}
#else
extern int handle_signal_init(void)
{
        signal(SIGINT,on_signal);
        signal(SIGTERM,on_signal);
        signal(SIGABRT,on_signal);
        signal(SIGHUP,on_signal);
        signal(SIGUSR1,on_signal);
        signal(SIGUSR2,on_signal);
        signal(SIGPIPE,on_signal);
        return 0;
}

static void on_signal(int s)
{
        switch (s) {
                case SIGINT:
                        eventlog(eventlog_level_debug,__FUNCTION__,"sigint received");
                        signal_data.do_quit=1;
                        break;
                case SIGTERM:
                        eventlog(eventlog_level_debug,__FUNCTION__,"sigint received");
                        signal_data.do_quit=1;
                        break;
                case SIGABRT:
                        eventlog(eventlog_level_debug,__FUNCTION__,"sigabrt received");
                        signal_data.cancel_quit=1;
                        break;
                case SIGHUP:
                        eventlog(eventlog_level_debug,__FUNCTION__,"sighup received");
                        signal_data.reload_config=1;
                        break;
                case SIGUSR1:
                        eventlog(eventlog_level_debug,__FUNCTION__,"sigusr1 received");
                        signal_data.reload_ladder=1;
                        break;
                case SIGUSR2:
                        eventlog(eventlog_level_debug,__FUNCTION__,"sigusr2 received");
                        signal_data.restart_d2gs=1;
                        break;
                case SIGPIPE:
                        eventlog(eventlog_level_debug,__FUNCTION__,"sigpipe received");
                        break;
        }
        signal(s,on_signal);
}
#endif

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			#include <errno.h>
29			#ifdef HAVE_STRING_H
30			# include <string.h>
31			#else
32			# ifdef HAVE_STRINGS_H
33			# include <strings.h>
34			# endif
35			# ifdef HAVE_MEMORY_H
36			# include <memory.h>
37			# endif
38			#endif
39			#include "compat/strdup.h"
40			#ifdef TIME_WITH_SYS_TIME
41			# include <time.h>
42			# include <sys/time.h>
43			#else
44			# ifdef HAVE_SYS_TIME_H
45			# include <sys/time.h>
46			# else
47			# include <time.h>
48			# endif
49			#endif
50			#ifdef DO_POSIXSIG
51			# include <signal.h>
52			# include "compat/signal.h"
53			#endif
54			#ifdef HAVE_FCNTL_H
55			# include <fcntl.h>
56			#else
57			# ifdef HAVE_SYS_FILE_H
58			# include <sys/file.h>
59			# endif
60			#endif
61			#ifdef HAVE_UNISTD_H
62			# include <unistd.h>
63			#endif
64
65			#include "d2gs.h"
66			#include "game.h"
67			#include "prefs.h"
68			#include "d2ladder.h"
69			#include "cmdline_parse.h"
70			#include "handle_signal.h"
71			#include "common/trans.h"
72			#include "common/eventlog.h"
73			#include "common/xalloc.h"
74			#include "common/setup_after.h"
75
76			static void on_signal(int s);
77
78			static volatile struct
79			{
80			unsigned char do_quit;
81			unsigned char cancel_quit;
82			unsigned char reload_config;
83			unsigned char reload_ladder;
84			unsigned char restart_d2gs;
85			unsigned int exit_time;
86			} signal_data ={ 0, 0, 0, 0, 0, 0 };
87
88			extern int handle_signal(void)
89			{
90			time_t now;
91			char const * levels;
92			char * temp;
93			char const * tok;
94
95
96			if (signal_data.cancel_quit) {
97			signal_data.cancel_quit=0;
98			if (!signal_data.exit_time) {
99			eventlog(eventlog_level_info,__FUNCTION__,"there is no previous shutdown to be canceled");
100			} else {
101			signal_data.exit_time=0;
102			eventlog(eventlog_level_info,__FUNCTION__,"shutdown was canceled due to signal");
103			}
104			}
105			if (signal_data.do_quit) {
106			signal_data.do_quit=0;
107			now=time(NULL);
108			if (!signal_data.exit_time) {
109			signal_data.exit_time=now+d2cs_prefs_get_shutdown_delay();
110			} else {
111			signal_data.exit_time-=d2cs_prefs_get_shutdown_decr();
112			}
113			eventlog(eventlog_level_info,__FUNCTION__,"the server is going to shutdown in %lu minutes",(signal_data.exit_time-now)/60);
114			}
115			if (signal_data.exit_time) {
116			now=time(NULL);
117			if (now >= (signed)signal_data.exit_time) {
118			eventlog(eventlog_level_info,__FUNCTION__,"shutdown server due to signal");
119			return -1;
120			}
121			}
122			if (signal_data.reload_config) {
123			signal_data.reload_config=0;
124			eventlog(eventlog_level_info,__FUNCTION__,"reloading configuartion file due to signal");
125			if (prefs_reload(cmdline_get_prefs_file())<0) {
126			eventlog(eventlog_level_error,__FUNCTION__,"error reload configuration file,exitting");
127			return -1;
128			}
129			if (d2gslist_reload(prefs_get_d2gs_list())<0) {
130			eventlog(eventlog_level_error,__FUNCTION__,"error reloading game server list,exitting");
131			return -1;
132			}
133			if (trans_reload(d2cs_prefs_get_transfile(),TRANS_D2CS)<0) {
134			eventlog(eventlog_level_error,__FUNCTION__,"could not reload trans list");
135			}
136
137			eventlog_clear_level();
138			if ((levels = d2cs_prefs_get_loglevels()))
139			{
140			temp = xstrdup(levels);
141			tok = strtok(temp,","); /* strtok modifies the string it is passed */
142
143			while (tok)
144			{
145			if (eventlog_add_level(tok)<0)
146			eventlog(eventlog_level_error,__FUNCTION__,"could not add log level \"%s\"",tok);
147			tok = strtok(NULL,",");
148			}
149
150			xfree(temp);
151			}
152
153			if (!cmdline_get_debugmode()) eventlog_open(d2cs_prefs_get_logfile());
154			}
155			if (signal_data.reload_ladder) {
156			signal_data.reload_ladder=0;
157			eventlog(eventlog_level_info,__FUNCTION__,"reloading ladder data due to signal");
158			d2ladder_refresh();
159			}
160
161			if (signal_data.restart_d2gs) {
162			signal_data.restart_d2gs=0;
163			eventlog(eventlog_level_info,__FUNCTION__,"restarting all game servers due to signal");
164			d2gs_restart_all_gs();
165			}
166
167			return 0;
168			}
169			#ifdef WIN32
170			extern void signal_quit_wrapper(void)
171			{
172			signal_data.do_quit=1;
173			}
174
175			extern void signal_reload_config_wrapper(void)
176			{
177			signal_data.reload_config = 1;
178			}
179
180			extern void signal_load_ladder_wrapper(void)
181			{
182			signal_data.reload_ladder = 1;
183			}
184
185			extern void signal_exit_wrapper(void)
186			{
187			signal_data.exit_time = 1;
188			signal_data.do_quit = 1;
189			}
190
191			extern void signal_restart_d2gs_wrapper(void)
192			{
193			signal_data.restart_d2gs = 1;
194			}
195			#else
196			extern int handle_signal_init(void)
197			{
198			signal(SIGINT,on_signal);
199			signal(SIGTERM,on_signal);
200			signal(SIGABRT,on_signal);
201			signal(SIGHUP,on_signal);
202			signal(SIGUSR1,on_signal);
203			signal(SIGUSR2,on_signal);
204			signal(SIGPIPE,on_signal);
205			return 0;
206			}
207
208			static void on_signal(int s)
209			{
210			switch (s) {
211			case SIGINT:
212			eventlog(eventlog_level_debug,__FUNCTION__,"sigint received");
213			signal_data.do_quit=1;
214			break;
215			case SIGTERM:
216			eventlog(eventlog_level_debug,__FUNCTION__,"sigint received");
217			signal_data.do_quit=1;
218			break;
219			case SIGABRT:
220			eventlog(eventlog_level_debug,__FUNCTION__,"sigabrt received");
221			signal_data.cancel_quit=1;
222			break;
223			case SIGHUP:
224			eventlog(eventlog_level_debug,__FUNCTION__,"sighup received");
225			signal_data.reload_config=1;
226			break;
227			case SIGUSR1:
228			eventlog(eventlog_level_debug,__FUNCTION__,"sigusr1 received");
229			signal_data.reload_ladder=1;
230			break;
231			case SIGUSR2:
232			eventlog(eventlog_level_debug,__FUNCTION__,"sigusr2 received");
233			signal_data.restart_d2gs=1;
234			break;
235			case SIGPIPE:
236			eventlog(eventlog_level_debug,__FUNCTION__,"sigpipe received");
237			break;
238			}
239			signal(s,on_signal);
240			}
241			#endif
242
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1