ngircd-tor/src/ngircd/sighandlers.c

337 lines
7.5 KiB
C
Raw Normal View History

/*
* ngIRCd -- The Next Generation IRC Daemon
* Copyright (c)2001-2014 Alexander Barton (alex@barton.de) and Contributors.
*
* 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.
* Please read the file COPYING, README and AUTHORS for more information.
*/
#include "portab.h"
/**
* @file
* Signal Handlers: Actions to be performed when the program
* receives a signal.
*/
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include "conn.h"
#include "channel.h"
#include "conf.h"
#include "io.h"
#include "log.h"
#include "ngircd.h"
#include "sighandlers.h"
static int signalpipe[2];
static const int signals_catch[] = {
SIGINT, SIGQUIT, SIGTERM, SIGHUP, SIGCHLD, SIGUSR1, SIGUSR2
};
#ifdef DEBUG
static void
Dump_State(void)
{
Log(LOG_DEBUG, "--- Internal server state: %s ---",
Client_ID(Client_ThisServer()));
Log(LOG_DEBUG, "time()=%ld", time(NULL));
Conf_DebugDump();
Conn_DebugDump();
Client_DebugDump();
Log(LOG_DEBUG, "--- End of state dump ---");
} /* Dump_State */
#endif
static void
Signal_Block(int sig)
{
#ifdef HAVE_SIGPROCMASK
sigset_t set;
sigemptyset(&set);
sigaddset(&set, sig);
sigprocmask(SIG_BLOCK, &set, NULL);
#else
sigblock(sig);
#endif
}
static void
Signal_Unblock(int sig)
{
#ifdef HAVE_SIGPROCMASK
sigset_t set;
sigemptyset(&set);
sigaddset(&set, sig);
sigprocmask(SIG_UNBLOCK, &set, NULL);
#else
int old = sigblock(0) & ~sig;
sigsetmask(old);
#endif
}
/**
* Reload the server configuration file.
*/
static void
Rehash(void)
{
char old_name[CLIENT_ID_LEN];
unsigned old_nicklen;
Log( LOG_NOTICE|LOG_snotice, "Re-reading configuration NOW!" );
/* Remember old server name and nickname length */
strlcpy( old_name, Conf_ServerName, sizeof old_name );
old_nicklen = Conf_MaxNickLength;
/* Re-read configuration ... */
if (!Conf_Rehash( ))
return;
/* Close down all listening sockets */
Conn_ExitListeners( );
/* Recover old server name and nickname length: these values can't
* be changed during run-time */
if (strcmp(old_name, Conf_ServerName) != 0 ) {
strlcpy(Conf_ServerName, old_name, sizeof Conf_ServerName);
Log(LOG_ERR,
"Can't change \"ServerName\" on runtime! Ignored new name.");
}
if (old_nicklen != Conf_MaxNickLength) {
Conf_MaxNickLength = old_nicklen;
Log(LOG_ERR,
"Can't change \"MaxNickLength\" on runtime! Ignored new value.");
}
/* Create new pre-defined channels */
Channel_InitPredefined( );
if (!ConnSSL_InitLibrary())
Log(LOG_WARNING,
"Re-Initializing of SSL failed, using old keys!");
/* Start listening on sockets */
Conn_InitListeners( );
/* Sync configuration with established connections */
Conn_SyncServerStruct( );
Log( LOG_NOTICE|LOG_snotice, "Re-reading of configuration done." );
} /* Rehash */
/**
* Signal handler of ngIRCd.
* This function is called whenever ngIRCd catches a signal sent by the
* user and/or the system to it. For example SIGTERM and SIGHUP.
*
* It blocks the signal and queues it for later execution by Signal_Handler_BH.
* @param Signal Number of the signal to handle.
*/
static void
Signal_Handler(int Signal)
{
switch (Signal) {
case SIGTERM:
case SIGINT:
case SIGQUIT:
/* shut down sever */
NGIRCd_SignalQuit = true;
return;
case SIGCHLD:
/* child-process exited, avoid zombies */
while (waitpid( -1, NULL, WNOHANG) > 0)
;
return;
#ifdef DEBUG
case SIGUSR1:
if (! NGIRCd_Debug) {
Log(LOG_INFO|LOG_snotice,
"Got SIGUSR1, debug mode activated.");
#ifdef SNIFFER
strcpy(NGIRCd_DebugLevel, "2");
NGIRCd_Debug = true;
NGIRCd_Sniffer = true;
#else
strcpy(NGIRCd_DebugLevel, "1");
NGIRCd_Debug = true;
#endif /* SNIFFER */
} else {
Log(LOG_INFO|LOG_snotice,
"Got SIGUSR1, debug mode deactivated.");
strcpy(NGIRCd_DebugLevel, "");
NGIRCd_Debug = false;
#ifdef SNIFFER
NGIRCd_Sniffer = false;
#endif /* SNIFFER */
}
return;
#endif
}
/*
* other signal: queue for later execution.
* This has the advantage that we are not restricted
* to functions that can be called safely from signal handlers.
*/
if (write(signalpipe[1], &Signal, sizeof(Signal)) != -1)
Signal_Block(Signal);
} /* Signal_Handler */
/**
* Signal processing handler of ngIRCd.
* This function is called from the main conn event loop in (io_dispatch)
* whenever ngIRCd has queued a signal.
*
* This function runs in normal context, not from the real signal handler,
* thus its not necessary to only use functions that are signal safe.
* @param Signal Number of the signal that was queued.
*/
static void
Signal_Handler_BH(int Signal)
{
switch (Signal) {
case SIGHUP:
/* re-read configuration */
Rehash();
break;
#ifdef DEBUG
case SIGUSR2:
if (NGIRCd_Debug) {
Log(LOG_INFO|LOG_snotice,
"Got SIGUSR2, dumping internal state ...");
Dump_State();
}
break;
default:
Log(LOG_DEBUG, "Got signal %d! Ignored.", Signal);
#endif
}
Signal_Unblock(Signal);
}
static void
Signal_Callback(int fd, short UNUSED what)
{
int sig, ret;
(void) what;
do {
ret = (int)read(fd, &sig, sizeof(sig));
if (ret == sizeof(int))
Signal_Handler_BH(sig);
} while (ret == sizeof(int));
if (ret == -1) {
if (errno == EAGAIN || errno == EINTR)
return;
Log(LOG_EMERG, "Read from signal pipe: %s - Exiting!",
strerror(errno));
exit(1);
}
Log(LOG_EMERG, "EOF on signal pipe!? - Exiting!");
exit(1);
}
/**
* Initialize the signal handlers, catch
* those signals we are interested in and sets SIGPIPE to be ignored.
* @return true if initialization was successful.
*/
bool
Signals_Init(void)
{
size_t i;
#ifdef HAVE_SIGACTION
struct sigaction saction;
#endif
if (signalpipe[0] > 0 || signalpipe[1] > 0)
return true;
if (pipe(signalpipe))
return false;
if (!io_setnonblock(signalpipe[0]) ||
!io_setnonblock(signalpipe[1]))
return false;
if (!io_setcloexec(signalpipe[0]) ||
!io_setcloexec(signalpipe[1]))
return false;
#ifdef HAVE_SIGACTION
memset( &saction, 0, sizeof( saction ));
saction.sa_handler = Signal_Handler;
#ifdef SA_RESTART
saction.sa_flags |= SA_RESTART;
#endif
#ifdef SA_NOCLDWAIT
saction.sa_flags |= SA_NOCLDWAIT;
#endif
for (i=0; i < C_ARRAY_SIZE(signals_catch) ; i++)
sigaction(signals_catch[i], &saction, NULL);
/* we handle write errors properly; ignore SIGPIPE */
saction.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &saction, NULL);
#else
for (i=0; i < C_ARRAY_SIZE(signals_catch) ; i++)
signal(signals_catch[i], Signal_Handler);
signal(SIGPIPE, SIG_IGN);
#endif
return io_event_create(signalpipe[0], IO_WANTREAD, Signal_Callback);
} /* Signals_Init */
/**
* Restores signals to their default behavior.
*
* This should be called after a fork() in the new
* child prodcess, especially when we are about to call
* 3rd party code (e.g. PAM).
*/
void
Signals_Exit(void)
{
size_t i;
#ifdef HAVE_SIGACTION
struct sigaction saction;
memset(&saction, 0, sizeof(saction));
saction.sa_handler = SIG_DFL;
for (i=0; i < C_ARRAY_SIZE(signals_catch) ; i++)
sigaction(signals_catch[i], &saction, NULL);
sigaction(SIGPIPE, &saction, NULL);
#else
for (i=0; i < C_ARRAY_SIZE(signals_catch) ; i++)
signal(signals_catch[i], SIG_DFL);
signal(SIGPIPE, SIG_DFL);
#endif
close(signalpipe[1]);
close(signalpipe[0]);
signalpipe[0] = signalpipe[1] = 0;
}
/* -eof- */