Annotation of ircnowd/src/ngircd/sighandlers.c, Revision 1.1.1.1
1.1 tomglok 1: /*
2: * ngIRCd -- The Next Generation IRC Daemon
3: * Copyright (c)2001-2015 Alexander Barton (alex@barton.de) and Contributors.
4: *
5: * This program is free software; you can redistribute it and/or modify
6: * it under the terms of the GNU General Public License as published by
7: * the Free Software Foundation; either version 2 of the License, or
8: * (at your option) any later version.
9: * Please read the file COPYING, README and AUTHORS for more information.
10: */
11:
12: #include "portab.h"
13:
14: /**
15: * @file
16: * Signal Handlers: Actions to be performed when the program
17: * receives a signal.
18: */
19:
20: #include <errno.h>
21: #include <unistd.h>
22: #include <stdlib.h>
23: #include <string.h>
24: #include <signal.h>
25: #include <sys/types.h>
26: #include <sys/wait.h>
27: #include <time.h>
28:
29: #include "conn.h"
30: #include "channel.h"
31: #include "conf.h"
32: #include "io.h"
33: #include "log.h"
34: #include "ngircd.h"
35:
36: #include "sighandlers.h"
37:
38: static int signalpipe[2];
39:
40: static const int signals_catch[] = {
41: SIGINT, SIGQUIT, SIGTERM, SIGHUP, SIGCHLD, SIGUSR1, SIGUSR2
42: };
43:
44: #ifdef DEBUG
45:
46: static void
47: Dump_State(void)
48: {
49: Log(LOG_DEBUG, "--- Internal server state: %s ---",
50: Client_ID(Client_ThisServer()));
51: #ifdef HAVE_LONG_LONG
52: Log(LOG_DEBUG, "time()=%llu", (unsigned long long)time(NULL));
53: #else
54: Log(LOG_DEBUG, "time()=%lu", (unsigned long)time(NULL));
55: #endif
56: Conf_DebugDump();
57: Conn_DebugDump();
58: Client_DebugDump();
59: Log(LOG_DEBUG, "--- End of state dump ---");
60: } /* Dump_State */
61:
62: #endif
63:
64: static void
65: Signal_Block(int sig)
66: {
67: #ifdef HAVE_SIGPROCMASK
68: sigset_t set;
69:
70: sigemptyset(&set);
71: sigaddset(&set, sig);
72:
73: sigprocmask(SIG_BLOCK, &set, NULL);
74: #else
75: sigblock(sig);
76: #endif
77: }
78:
79: static void
80: Signal_Unblock(int sig)
81: {
82: #ifdef HAVE_SIGPROCMASK
83: sigset_t set;
84:
85: sigemptyset(&set);
86: sigaddset(&set, sig);
87:
88: sigprocmask(SIG_UNBLOCK, &set, NULL);
89: #else
90: int old = sigblock(0) & ~sig;
91: sigsetmask(old);
92: #endif
93: }
94:
95: /**
96: * Reload the server configuration file.
97: */
98: static void
99: Rehash(void)
100: {
101: char old_name[CLIENT_ID_LEN];
102: unsigned old_nicklen;
103:
104: Log( LOG_NOTICE|LOG_snotice, "Re-reading configuration NOW!" );
105:
106: /* Remember old server name and nickname length */
107: strlcpy( old_name, Conf_ServerName, sizeof old_name );
108: old_nicklen = Conf_MaxNickLength;
109:
110: /* Re-read configuration ... */
111: if (!Conf_Rehash( ))
112: return;
113:
114: /* Close down all listening sockets */
115: Conn_ExitListeners( );
116:
117: /* Recover old server name and nickname length: these values can't
118: * be changed during run-time */
119: if (strcmp(old_name, Conf_ServerName) != 0 ) {
120: strlcpy(Conf_ServerName, old_name, sizeof Conf_ServerName);
121: Log(LOG_ERR,
122: "Can't change server name (\"Name\") on runtime! Ignored new name.");
123: }
124: if (old_nicklen != Conf_MaxNickLength) {
125: Conf_MaxNickLength = old_nicklen;
126: Log(LOG_ERR,
127: "Can't change \"MaxNickLength\" on runtime! Ignored new value.");
128: }
129:
130: /* Create new pre-defined channels */
131: Channel_InitPredefined( );
132:
133: if (!ConnSSL_InitLibrary())
134: Log(LOG_WARNING,
135: "Re-Initializing of SSL failed!");
136:
137: /* Start listening on sockets */
138: Conn_InitListeners( );
139:
140: /* Sync configuration with established connections */
141: Conn_SyncServerStruct( );
142:
143: Log( LOG_NOTICE|LOG_snotice, "Re-reading of configuration done." );
144: } /* Rehash */
145:
146: /**
147: * Signal handler of ngIRCd.
148: * This function is called whenever ngIRCd catches a signal sent by the
149: * user and/or the system to it. For example SIGTERM and SIGHUP.
150: *
151: * It blocks the signal and queues it for later execution by Signal_Handler_BH.
152: * @param Signal Number of the signal to handle.
153: */
154: static void
155: Signal_Handler(int Signal)
156: {
157: if (Signal != SIGCHLD) {
158: #ifdef HAVE_STRSIGNAL
159: Log(LOG_INFO, "Got signal \"%s\" ...", strsignal(Signal));
160: #else
161: Log(LOG_INFO, "Got signal %d ...", Signal);
162: #endif
163: }
164:
165: switch (Signal) {
166: case SIGTERM:
167: case SIGINT:
168: case SIGQUIT:
169: /* shut down sever */
170: NGIRCd_SignalQuit = true;
171: return;
172: case SIGCHLD:
173: /* child-process exited, avoid zombies */
174: while (waitpid( -1, NULL, WNOHANG) > 0)
175: ;
176: return;
177: #ifdef DEBUG
178: case SIGUSR1:
179: if (! NGIRCd_Debug) {
180: Log(LOG_INFO|LOG_snotice,
181: "Got SIGUSR1, debug mode activated.");
182: #ifdef SNIFFER
183: strcpy(NGIRCd_DebugLevel, "2");
184: NGIRCd_Debug = true;
185: NGIRCd_Sniffer = true;
186: #else
187: strcpy(NGIRCd_DebugLevel, "1");
188: NGIRCd_Debug = true;
189: #endif /* SNIFFER */
190: } else {
191: Log(LOG_INFO|LOG_snotice,
192: "Got SIGUSR1, debug mode deactivated.");
193: strcpy(NGIRCd_DebugLevel, "");
194: NGIRCd_Debug = false;
195: #ifdef SNIFFER
196: NGIRCd_Sniffer = false;
197: #endif /* SNIFFER */
198: }
199: return;
200: #endif
201: }
202:
203: /*
204: * other signal: queue for later execution.
205: * This has the advantage that we are not restricted
206: * to functions that can be called safely from signal handlers.
207: */
208: if (write(signalpipe[1], &Signal, sizeof(Signal)) != -1)
209: Signal_Block(Signal);
210: } /* Signal_Handler */
211:
212: /**
213: * Signal processing handler of ngIRCd.
214: * This function is called from the main conn event loop in (io_dispatch)
215: * whenever ngIRCd has queued a signal.
216: *
217: * This function runs in normal context, not from the real signal handler,
218: * thus its not necessary to only use functions that are signal safe.
219: * @param Signal Number of the signal that was queued.
220: */
221: static void
222: Signal_Handler_BH(int Signal)
223: {
224: switch (Signal) {
225: case SIGHUP:
226: /* re-read configuration */
227: Rehash();
228: break;
229: #ifdef DEBUG
230: case SIGUSR2:
231: if (NGIRCd_Debug) {
232: Log(LOG_INFO|LOG_snotice,
233: "Got SIGUSR2, dumping internal state ...");
234: Dump_State();
235: }
236: break;
237: default:
238: Log(LOG_DEBUG, "Got signal %d! Ignored.", Signal);
239: #endif
240: }
241: Signal_Unblock(Signal);
242: }
243:
244: static void
245: Signal_Callback(int fd, short UNUSED what)
246: {
247: int sig, ret;
248: (void) what;
249:
250: do {
251: ret = (int)read(fd, &sig, sizeof(sig));
252: if (ret == sizeof(int))
253: Signal_Handler_BH(sig);
254: } while (ret == sizeof(int));
255:
256: if (ret == -1) {
257: if (errno == EAGAIN || errno == EINTR)
258: return;
259:
260: Log(LOG_EMERG, "Read from signal pipe: %s - Exiting!",
261: strerror(errno));
262: exit(1);
263: }
264:
265: Log(LOG_EMERG, "EOF on signal pipe!? - Exiting!");
266: exit(1);
267: }
268:
269: /**
270: * Initialize the signal handlers, catch
271: * those signals we are interested in and sets SIGPIPE to be ignored.
272: * @return true if initialization was successful.
273: */
274: bool
275: Signals_Init(void)
276: {
277: size_t i;
278: #ifdef HAVE_SIGACTION
279: struct sigaction saction;
280: #endif
281: if (signalpipe[0] > 0 || signalpipe[1] > 0)
282: return true;
283:
284: if (pipe(signalpipe))
285: return false;
286:
287: if (!io_setnonblock(signalpipe[0]) ||
288: !io_setnonblock(signalpipe[1]))
289: return false;
290: if (!io_setcloexec(signalpipe[0]) ||
291: !io_setcloexec(signalpipe[1]))
292: return false;
293: #ifdef HAVE_SIGACTION
294: memset( &saction, 0, sizeof( saction ));
295: saction.sa_handler = Signal_Handler;
296: #ifdef SA_RESTART
297: saction.sa_flags |= SA_RESTART;
298: #endif
299: #ifdef SA_NOCLDWAIT
300: saction.sa_flags |= SA_NOCLDWAIT;
301: #endif
302:
303: for (i=0; i < C_ARRAY_SIZE(signals_catch) ; i++)
304: sigaction(signals_catch[i], &saction, NULL);
305:
306: /* we handle write errors properly; ignore SIGPIPE */
307: saction.sa_handler = SIG_IGN;
308: sigaction(SIGPIPE, &saction, NULL);
309: #else
310: for (i=0; i < C_ARRAY_SIZE(signals_catch) ; i++)
311: signal(signals_catch[i], Signal_Handler);
312:
313: signal(SIGPIPE, SIG_IGN);
314: #endif
315: return io_event_create(signalpipe[0], IO_WANTREAD, Signal_Callback);
316: } /* Signals_Init */
317:
318: /**
319: * Restores signals to their default behavior.
320: *
321: * This should be called after a fork() in the new
322: * child prodcess, especially when we are about to call
323: * 3rd party code (e.g. PAM).
324: */
325: void
326: Signals_Exit(void)
327: {
328: size_t i;
329: #ifdef HAVE_SIGACTION
330: struct sigaction saction;
331:
332: memset(&saction, 0, sizeof(saction));
333: saction.sa_handler = SIG_DFL;
334:
335: for (i=0; i < C_ARRAY_SIZE(signals_catch) ; i++)
336: sigaction(signals_catch[i], &saction, NULL);
337: sigaction(SIGPIPE, &saction, NULL);
338: #else
339: for (i=0; i < C_ARRAY_SIZE(signals_catch) ; i++)
340: signal(signals_catch[i], SIG_DFL);
341: signal(SIGPIPE, SIG_DFL);
342: #endif
343: close(signalpipe[1]);
344: close(signalpipe[0]);
345: signalpipe[0] = signalpipe[1] = 0;
346: }
347:
348: /* -eof- */
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sighandlers.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / ircnowd / src / ngircd