lsyncd/core/signal.c
2018-05-06 22:46:00 +02:00

181 lines
3.5 KiB
C

/*
| singal.c from Lsyncd -- the Live (Mirror) Syncing Demon
|
| Albeit this signal handling system at first seems to violate
| rentry rules things are evened out by sigmasks taking care
| only one signal at a time can enter the core.
|
| License: GPLv2 (see COPYING) or any later version
| Authors: Axel Kittenberger <axkibe@gmail.com>
*/
#include "feature.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#define LUA_USE_APICHECK 1
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
#include "log.h"
#include "mem.h"
static volatile sig_atomic_t * queue;
static int queue_len;
static int queue_pos;
/*
| Set by TERM or HUP signal handler
| telling Lsyncd should end or reset ASAP.
*/
volatile sig_atomic_t hup = 0;
volatile sig_atomic_t term = 0;
volatile sig_atomic_t sigcode = 0;
/*
| signal handler
*/
static void
signal_child( int sig )
{
// Nothing!
//
// This signal handler is just installed so the kernel
// keeps finished child processes as zombies waiting to be reaped.
}
/*
| signal handler
*/
static void
signal_handler( int sig )
{
// looks if this signal is already queued
for( int i = 0; i < queue_pos; i++ )
{
// if so it is dropped
if( queue[ i ] == sig ) return;
}
if( queue_pos + 1 >= queue_len )
{
// this should never ever happen
logstring( "Error", "Signal queue overflow!" );
exit( -1 );
}
queue[ queue_pos++ ] = sig;
}
/*
| Initializes signal handling.
|
| Listens to SIGCHLD, but blocks it until pselect( )
| opens the signal handler up.
*/
void
signal_init( )
{
queue_len = 5;
queue = s_malloc( queue_len * sizeof( sig_atomic_t ) );
queue_pos = 0;
}
/*
| Registers (or deregisters) a signal handlers.
|
| Params on Lua stack:
| 1: table of all signal handlers
|
| Returns on Lua stack:
|
| true if the signal could be registered with the kernel/libc
| false if they denied it
*/
int
l_onsignal( lua_State *L )
{
int sigc = 0;
int ok;
// the block mask includes all signals that have registered handlers.
// it is used to block all signals outside the select() call
// and also during the core signal handler runs.
sigset_t blockmask;
sigemptyset( &blockmask );
sigaddset( &blockmask, SIGCHLD );
// first time iterates the signal handler table to build
// the blockmask
lua_pushnil( L );
while( lua_next( L, -2 ) )
{
int htype = lua_type( L, -1 ); // the handle
// pops the value, leaves the key on stack
lua_pop( L, 1 );
// not a handler function (probably false)
if( htype != LUA_TFUNCTION ) continue;
int signum = lua_tointegerx( L, -1 , &ok );
if( !ok ) continue;
sigc++;
}
// and block those signals
sigprocmask( SIG_BLOCK, &blockmask, NULL );
// if there are more signal handlers than
// the signal queue allows, it is enlarged.
if( sigc >= queue_len )
{
while( sigc >= queue_len ) queue_len *= 2;
queue = s_realloc( (sig_atomic_t *)( queue ), queue_len * sizeof( sig_atomic_t ) );
}
// now iterates the signal handler table
// once again to register the signal handlers.
struct sigaction act;
memset (&act, '\0', sizeof(act));
act.sa_mask = blockmask;
lua_pushnil( L );
while( lua_next( L, -2 ) )
{
int htype = lua_type( L, -1 ); // the handle
act.sa_handler = &signal_handler;
// pops the value, leaves the key on stack
lua_pop( L, 1 );
// not a handler function (probably false)
if( htype != LUA_TFUNCTION ) continue;
int signum = lua_tointegerx( L, -1 , &ok );
if( !ok ) continue;
sigaction( signum, &act, 0 );
}
return 0;
}