[mirror_frr.git] / lib / sigevent.c

/* Quagga signal handling functions.
 * Copyright (C) 2004 Paul Jakma,
 *
 * This file is part of Quagga.
 *
 * Quagga 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, or (at your option) any
 * later version.
 *
 * Quagga 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; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>
#include <sigevent.h>
#include <log.h>
#include <memory.h>
#include <lib_errors.h>

#ifdef HAVE_UCONTEXT_H
#ifdef GNU_LINUX
/* get REG_EIP from ucontext.h */
#ifndef __USE_GNU
#define __USE_GNU
#endif /* __USE_GNU */
#endif /* GNU_LINUX */
#include <ucontext.h>
#endif /* HAVE_UCONTEXT_H */


/* master signals descriptor struct */
static struct quagga_sigevent_master_t {
	struct thread *t;

	struct quagga_signal_t *signals;
	int sigc;

	volatile sig_atomic_t caught;
} sigmaster;

/* Generic signal handler
 * Schedules signal event thread
 */
static void quagga_signal_handler(int signo)
{
	int i;
	struct quagga_signal_t *sig;

	for (i = 0; i < sigmaster.sigc; i++) {
		sig = &(sigmaster.signals[i]);

		if (sig->signal == signo)
			sig->caught = 1;
	}

	sigmaster.caught = 1;
}

/*
 * Check whether any signals have been received and are pending. This is done
 * with the application's key signals blocked. The complete set of signals
 * is returned in 'setp', so the caller can restore them when appropriate.
 * If there are pending signals, returns 'true', 'false' otherwise.
 */
bool frr_sigevent_check(sigset_t *setp)
{
	sigset_t blocked;
	int i;
	bool ret;

	sigemptyset(setp);
	sigemptyset(&blocked);

	/* Set up mask of application's signals */
	for (i = 0; i < sigmaster.sigc; i++)
		sigaddset(&blocked, sigmaster.signals[i].signal);

	pthread_sigmask(SIG_BLOCK, &blocked, setp);

	/* Now that the application's signals are blocked, test. */
	ret = (sigmaster.caught != 0);

	return ret;
}

/* check if signals have been caught and run appropriate handlers */
int quagga_sigevent_process(void)
{
	struct quagga_signal_t *sig;
	int i;
#ifdef SIGEVENT_BLOCK_SIGNALS
	/* shouldnt need to block signals, but potentially may be needed */
	sigset_t newmask, oldmask;

	/*
	 * Block most signals, but be careful not to defer SIGTRAP because
	 * doing so breaks gdb, at least on NetBSD 2.0.  Avoid asking to
	 * block SIGKILL, just because we shouldn't be able to do so.
	 */
	sigfillset(&newmask);
	sigdelset(&newmask, SIGTRAP);
	sigdelset(&newmask, SIGKILL);

	if ((sigprocmask(SIG_BLOCK, &newmask, &oldmask)) < 0) {
		flog_err_sys(EC_LIB_SYSTEM_CALL,
			     "quagga_signal_timer: couldnt block signals!");
		return -1;
	}
#endif /* SIGEVENT_BLOCK_SIGNALS */

	if (sigmaster.caught > 0) {
		sigmaster.caught = 0;
		/* must not read or set sigmaster.caught after here,
		 * race condition with per-sig caught flags if one does
		 */

		for (i = 0; i < sigmaster.sigc; i++) {
			sig = &(sigmaster.signals[i]);

			if (sig->caught > 0) {
				sig->caught = 0;
				if (sig->handler)
					sig->handler();
			}
		}
	}

#ifdef SIGEVENT_BLOCK_SIGNALS
	if (sigprocmask(SIG_UNBLOCK, &oldmask, NULL) < 0)
		;
	return -1;
#endif /* SIGEVENT_BLOCK_SIGNALS */

	return 0;
}

#ifdef SIGEVENT_SCHEDULE_THREAD
/* timer thread to check signals. Shouldnt be needed */
int quagga_signal_timer(struct thread *t)
{
	struct quagga_sigevent_master_t *sigm;

	sigm = THREAD_ARG(t);
	sigm->t = NULL;
	thread_add_timer(sigm->t->master, quagga_signal_timer, &sigmaster,
			 QUAGGA_SIGNAL_TIMER_INTERVAL, &sigm->t);
	return quagga_sigevent_process();
}
#endif /* SIGEVENT_SCHEDULE_THREAD */

/* Initialization of signal handles. */
/* Signal wrapper. */
static int signal_set(int signo)
{
	int ret;
	struct sigaction sig;
	struct sigaction osig;

	sig.sa_handler = &quagga_signal_handler;
	sigfillset(&sig.sa_mask);
	sig.sa_flags = 0;
	if (signo == SIGALRM) {
#ifdef SA_INTERRUPT
		sig.sa_flags |= SA_INTERRUPT; /* SunOS */
#endif
	} else {
#ifdef SA_RESTART
		sig.sa_flags |= SA_RESTART;
#endif /* SA_RESTART */
	}

	ret = sigaction(signo, &sig, &osig);
	if (ret < 0)
		return ret;
	else
		return 0;
}

/* XXX This function should be enhanced to support more platforms
       (it currently works only on Linux/x86). */
static void *program_counter(void *context)
{
#ifdef HAVE_UCONTEXT_H
#ifdef GNU_LINUX
/* these are from GNU libc, rather than Linux, strictly speaking */
#if defined(REG_EIP)
#  define REG_INDEX REG_EIP
#elif defined(REG_RIP)
#  define REG_INDEX REG_RIP
#elif defined(__powerpc__)
#  define REG_INDEX 32
#endif
#endif		       /* GNU_LINUX */

#ifdef REG_INDEX
#ifdef HAVE_UCONTEXT_T_UC_MCONTEXT_GREGS
#  define REGS gregs[REG_INDEX]
#elif defined(HAVE_UCONTEXT_T_UC_MCONTEXT_UC_REGS)
#  define REGS uc_regs->gregs[REG_INDEX]
#endif /* HAVE_UCONTEXT_T_UC_MCONTEXT_GREGS */
#endif /* REG_INDEX */

#ifdef REGS
	if (context)
		return (void *)(((ucontext_t *)context)->uc_mcontext.REGS);
#elif defined(HAVE_UCONTEXT_T_UC_MCONTEXT_REGS__NIP)
	/* older Linux / struct pt_regs ? */
	if (context)
		return (void *)(((ucontext_t *)context)->uc_mcontext.regs->nip);
#endif /* REGS */

#endif /* HAVE_UCONTEXT_H */
	return NULL;
}

static void __attribute__((noreturn))
exit_handler(int signo, siginfo_t *siginfo, void *context)
{
	void *pc = program_counter(context);

	zlog_signal(signo, "exiting...", siginfo, pc);
	_exit(128 + signo);
}

static void __attribute__((noreturn))
core_handler(int signo, siginfo_t *siginfo, void *context)
{
	void *pc = program_counter(context);

	/* make sure we don't hang in here.  default for SIGALRM is terminate.
	 * - if we're in backtrace for more than a second, abort. */
	struct sigaction sa_default = {.sa_handler = SIG_DFL};

	sigaction(SIGALRM, &sa_default, NULL);
	sigaction(signo, &sa_default, NULL);

	sigset_t sigset;

	sigemptyset(&sigset);
	sigaddset(&sigset, SIGALRM);
	sigprocmask(SIG_UNBLOCK, &sigset, NULL);

	alarm(1);

	zlog_signal(signo, "aborting...", siginfo, pc);

	/* dump memory stats on core */
	log_memstats(stderr, "core_handler");

	zlog_tls_buffer_fini();

	/* give the kernel a chance to generate a coredump */
	sigaddset(&sigset, signo);
	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
	raise(signo);

	/* only chance to end up here is if the default action for signo is
	 * something other than kill or coredump the process
	 */
	_exit(128 + signo);
}

static void trap_default_signals(void)
{
	static const int core_signals[] = {
		SIGQUIT, SIGILL, SIGABRT,
#ifdef SIGEMT
		SIGEMT,
#endif
		SIGFPE,  SIGBUS, SIGSEGV,
#ifdef SIGSYS
		SIGSYS,
#endif
#ifdef SIGXCPU
		SIGXCPU,
#endif
#ifdef SIGXFSZ
		SIGXFSZ,
#endif
	};
	static const int exit_signals[] = {
		SIGHUP,    SIGINT, SIGALRM, SIGTERM, SIGUSR1, SIGUSR2,
#ifdef SIGPOLL
		SIGPOLL,
#endif
#ifdef SIGVTALRM
		SIGVTALRM,
#endif
#ifdef SIGSTKFLT
		SIGSTKFLT,
#endif
	};
	static const int ignore_signals[] = {
		SIGPIPE,
	};
	static const struct {
		const int *sigs;
		unsigned int nsigs;
		void (*handler)(int signo, siginfo_t *info, void *context);
	} sigmap[] = {
		{core_signals, array_size(core_signals), core_handler},
		{exit_signals, array_size(exit_signals), exit_handler},
		{ignore_signals, array_size(ignore_signals), NULL},
	};
	unsigned int i;

	for (i = 0; i < array_size(sigmap); i++) {
		unsigned int j;

		for (j = 0; j < sigmap[i].nsigs; j++) {
			struct sigaction oact;
			if ((sigaction(sigmap[i].sigs[j], NULL, &oact) == 0)
			    && (oact.sa_handler == SIG_DFL)) {
				struct sigaction act;
				sigfillset(&act.sa_mask);
				if (sigmap[i].handler == NULL) {
					act.sa_handler = SIG_IGN;
					act.sa_flags = 0;
				} else {
					/* Request extra arguments to signal
					 * handler. */
					act.sa_sigaction = sigmap[i].handler;
					act.sa_flags = SA_SIGINFO;
#ifdef SA_RESETHAND
					/* don't try to print backtraces
					 * recursively */
					if (sigmap[i].handler == core_handler)
						act.sa_flags |= SA_RESETHAND;
#endif
				}
				if (sigaction(sigmap[i].sigs[j], &act, NULL)
				    < 0)
					flog_err(
						EC_LIB_SYSTEM_CALL,
						"Unable to set signal handler for signal %d: %s",
						sigmap[i].sigs[j],
						safe_strerror(errno));
			}
		}
	}
}

void signal_init(struct thread_master *m, int sigc,
		 struct quagga_signal_t signals[])
{

	int i = 0;
	struct quagga_signal_t *sig;

	/* First establish some default handlers that can be overridden by
	   the application. */
	trap_default_signals();

	while (i < sigc) {
		sig = &signals[i];
		if (signal_set(sig->signal) < 0)
			exit(-1);
		i++;
	}

	sigmaster.sigc = sigc;
	sigmaster.signals = signals;

#ifdef SIGEVENT_SCHEDULE_THREAD
	sigmaster.t = NULL;
	thread_add_timer(m, quagga_signal_timer, &sigmaster,
			 QUAGGA_SIGNAL_TIMER_INTERVAL, &sigmaster.t);
#endif /* SIGEVENT_SCHEDULE_THREAD */
}
Commit	Line	Data
c49b3069	1	/* Quagga signal handling functions.
	2	* Copyright (C) 2004 Paul Jakma,
	3	*
	4	* This file is part of Quagga.
	5	*
	6	* Quagga is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2, or (at your option) any
	9	* later version.
	10	*
	11	* Quagga is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
896014f4 DL	16	* You should have received a copy of the GNU General Public License along
	17	* with this program; see the file COPYING; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
c49b3069	19	*/
	20
	21	#include <zebra.h>
	22	#include <sigevent.h>
	23	#include <log.h>
837d16cc	24	#include <memory.h>
481bc15f	25	#include <lib_errors.h>
c49b3069	26
40abf239	27	#ifdef HAVE_UCONTEXT_H
	28	#ifdef GNU_LINUX
	29	/* get REG_EIP from ucontext.h */
67bf16c0	30	#ifndef __USE_GNU
40abf239	31	#define __USE_GNU
67bf16c0	32	#endif /* __USE_GNU */
40abf239	33	#endif /* GNU_LINUX */
	34	#include <ucontext.h>
	35	#endif /* HAVE_UCONTEXT_H */
	36
	37
05c447dd	38	/* master signals descriptor struct */
c17faa4b	39	static struct quagga_sigevent_master_t {
d62a17ae	40	struct thread *t;
	41
	42	struct quagga_signal_t *signals;
	43	int sigc;
c49b3069	44
d62a17ae	45	volatile sig_atomic_t caught;
05c447dd	46	} sigmaster;
c49b3069	47
d62a17ae	48	/* Generic signal handler
c49b3069	49	* Schedules signal event thread
c49b3069	50	*/
d62a17ae	51	static void quagga_signal_handler(int signo)
c49b3069	52	{
d62a17ae	53	int i;
	54	struct quagga_signal_t *sig;
	55
	56	for (i = 0; i < sigmaster.sigc; i++) {
	57	sig = &(sigmaster.signals[i]);
	58
	59	if (sig->signal == signo)
	60	sig->caught = 1;
	61	}
	62
	63	sigmaster.caught = 1;
	64	}
c49b3069	65
976c5cc1 MS	66	/*
	67	* Check whether any signals have been received and are pending. This is done
	68	* with the application's key signals blocked. The complete set of signals
	69	* is returned in 'setp', so the caller can restore them when appropriate.
	70	* If there are pending signals, returns 'true', 'false' otherwise.
	71	*/
	72	bool frr_sigevent_check(sigset_t *setp)
	73	{
	74	sigset_t blocked;
	75	int i;
	76	bool ret;
	77
	78	sigemptyset(setp);
	79	sigemptyset(&blocked);
	80
	81	/* Set up mask of application's signals */
	82	for (i = 0; i < sigmaster.sigc; i++)
	83	sigaddset(&blocked, sigmaster.signals[i].signal);
	84
	85	pthread_sigmask(SIG_BLOCK, &blocked, setp);
	86
	87	/* Now that the application's signals are blocked, test. */
	88	ret = (sigmaster.caught != 0);
	89
	90	return ret;
	91	}
	92
05c447dd	93	/* check if signals have been caught and run appropriate handlers */
d62a17ae	94	int quagga_sigevent_process(void)
c49b3069	95	{
d62a17ae	96	struct quagga_signal_t *sig;
d62a17ae	97	int i;
05c447dd	98	#ifdef SIGEVENT_BLOCK_SIGNALS
d62a17ae	99	/* shouldnt need to block signals, but potentially may be needed */
	100	sigset_t newmask, oldmask;
	101
	102	/*
	103	* Block most signals, but be careful not to defer SIGTRAP because
	104	* doing so breaks gdb, at least on NetBSD 2.0. Avoid asking to
	105	* block SIGKILL, just because we shouldn't be able to do so.
	106	*/
	107	sigfillset(&newmask);
	108	sigdelset(&newmask, SIGTRAP);
	109	sigdelset(&newmask, SIGKILL);
	110
	111	if ((sigprocmask(SIG_BLOCK, &newmask, &oldmask)) < 0) {
450971aa	112	flog_err_sys(EC_LIB_SYSTEM_CALL,
09c866e3	113	"quagga_signal_timer: couldnt block signals!");
d62a17ae	114	return -1;
d62a17ae	115	}
05c447dd	116	#endif /* SIGEVENT_BLOCK_SIGNALS */
05c447dd	117
d62a17ae	118	if (sigmaster.caught > 0) {
	119	sigmaster.caught = 0;
	120	/* must not read or set sigmaster.caught after here,
	121	* race condition with per-sig caught flags if one does
	122	*/
	123
	124	for (i = 0; i < sigmaster.sigc; i++) {
	125	sig = &(sigmaster.signals[i]);
	126
	127	if (sig->caught > 0) {
	128	sig->caught = 0;
	129	if (sig->handler)
	130	sig->handler();
	131	}
	132	}
	133	}
c49b3069	134
05c447dd	135	#ifdef SIGEVENT_BLOCK_SIGNALS
d62a17ae	136	if (sigprocmask(SIG_UNBLOCK, &oldmask, NULL) < 0)
	137	;
	138	return -1;
05c447dd	139	#endif /* SIGEVENT_BLOCK_SIGNALS */
05c447dd	140
d62a17ae	141	return 0;
c49b3069	142	}
c49b3069	143
05c447dd	144	#ifdef SIGEVENT_SCHEDULE_THREAD
05c447dd	145	/* timer thread to check signals. Shouldnt be needed */
d62a17ae	146	int quagga_signal_timer(struct thread *t)
05c447dd	147	{
d62a17ae	148	struct quagga_sigevent_master_t *sigm;
d62a17ae	149
	150	sigm = THREAD_ARG(t);
	151	sigm->t = NULL;
	152	thread_add_timer(sigm->t->master, quagga_signal_timer, &sigmaster,
	153	QUAGGA_SIGNAL_TIMER_INTERVAL, &sigm->t);
	154	return quagga_sigevent_process();
05c447dd	155	}
	156	#endif /* SIGEVENT_SCHEDULE_THREAD */
	157
c49b3069	158	/* Initialization of signal handles. */
40abf239	159	/* Signal wrapper. */
d62a17ae	160	static int signal_set(int signo)
c49b3069	161	{
d62a17ae	162	int ret;
	163	struct sigaction sig;
	164	struct sigaction osig;
	165
	166	sig.sa_handler = &quagga_signal_handler;
	167	sigfillset(&sig.sa_mask);
	168	sig.sa_flags = 0;
	169	if (signo == SIGALRM) {
c49b3069	170	#ifdef SA_INTERRUPT
d62a17ae	171	sig.sa_flags \|= SA_INTERRUPT; /* SunOS */
c49b3069	172	#endif
d62a17ae	173	} else {
c49b3069	174	#ifdef SA_RESTART
d62a17ae	175	sig.sa_flags \|= SA_RESTART;
c49b3069	176	#endif /* SA_RESTART */
d62a17ae	177	}
c49b3069	178
d62a17ae	179	ret = sigaction(signo, &sig, &osig);
	180	if (ret < 0)
	181	return ret;
	182	else
	183	return 0;
c49b3069	184	}
c49b3069	185
40abf239	186	/* XXX This function should be enhanced to support more platforms
40abf239	187	(it currently works only on Linux/x86). */
d62a17ae	188	static void program_counter(void context)
40abf239	189	{
	190	#ifdef HAVE_UCONTEXT_H
	191	#ifdef GNU_LINUX
d62a17ae	192	/* these are from GNU libc, rather than Linux, strictly speaking */
d62a17ae	193	#if defined(REG_EIP)
bccbd141	194	# define REG_INDEX REG_EIP
d62a17ae	195	#elif defined(REG_RIP)
bccbd141	196	# define REG_INDEX REG_RIP
d62a17ae	197	#elif defined(__powerpc__)
bccbd141	198	# define REG_INDEX 32
d62a17ae	199	#endif
d62a17ae	200	#endif /* GNU_LINUX */
bccbd141 JT	201
bccbd141 JT	202	#ifdef REG_INDEX
d62a17ae	203	#ifdef HAVE_UCONTEXT_T_UC_MCONTEXT_GREGS
bccbd141	204	# define REGS gregs[REG_INDEX]
d62a17ae	205	#elif defined(HAVE_UCONTEXT_T_UC_MCONTEXT_UC_REGS)
bccbd141	206	# define REGS uc_regs->gregs[REG_INDEX]
d62a17ae	207	#endif /* HAVE_UCONTEXT_T_UC_MCONTEXT_GREGS */
bccbd141 JT	208	#endif /* REG_INDEX */
	209
	210	#ifdef REGS
d62a17ae	211	if (context)
	212	return (void )(((ucontext_t )context)->uc_mcontext.REGS);
	213	#elif defined(HAVE_UCONTEXT_T_UC_MCONTEXT_REGS__NIP)
	214	/* older Linux / struct pt_regs ? */
	215	if (context)
	216	return (void )(((ucontext_t )context)->uc_mcontext.regs->nip);
bccbd141 JT	217	#endif /* REGS */
bccbd141 JT	218
40abf239	219	#endif /* HAVE_UCONTEXT_H */
d62a17ae	220	return NULL;
40abf239	221	}
40abf239	222
d62a17ae	223	static void __attribute__((noreturn))
5e4f10b1	224	exit_handler(int signo, siginfo_t siginfo, void context)
59a06a91	225	{
c22f6d8c	226	void *pc = program_counter(context);
c22f6d8c DL	227
c22f6d8c DL	228	zlog_signal(signo, "exiting...", siginfo, pc);
d62a17ae	229	_exit(128 + signo);
59a06a91	230	}
59a06a91	231
d62a17ae	232	static void __attribute__((noreturn))
5e4f10b1	233	core_handler(int signo, siginfo_t siginfo, void context)
59a06a91	234	{
c22f6d8c	235	void *pc = program_counter(context);
c22f6d8c	236
d62a17ae	237	/* make sure we don't hang in here. default for SIGALRM is terminate.
	238	* - if we're in backtrace for more than a second, abort. */
	239	struct sigaction sa_default = {.sa_handler = SIG_DFL};
5be4799d	240
d62a17ae	241	sigaction(SIGALRM, &sa_default, NULL);
5be4799d	242	sigaction(signo, &sa_default, NULL);
3f11a103	243
d62a17ae	244	sigset_t sigset;
5be4799d	245
d62a17ae	246	sigemptyset(&sigset);
	247	sigaddset(&sigset, SIGALRM);
	248	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
3f11a103	249
d62a17ae	250	alarm(1);
3f11a103	251
c22f6d8c DL	252	zlog_signal(signo, "aborting...", siginfo, pc);
c22f6d8c DL	253
d62a17ae	254	/* dump memory stats on core */
9eed278b	255	log_memstats(stderr, "core_handler");
23961e75 DS	256
23961e75 DS	257	zlog_tls_buffer_fini();
5be4799d DL	258
	259	/* give the kernel a chance to generate a coredump */
	260	sigaddset(&sigset, signo);
	261	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
	262	raise(signo);
	263
	264	/* only chance to end up here is if the default action for signo is
	265	* something other than kill or coredump the process
	266	*/
	267	_exit(128 + signo);
59a06a91	268	}
59a06a91	269
d62a17ae	270	static void trap_default_signals(void)
59a06a91	271	{
d62a17ae	272	static const int core_signals[] = {
3fb4be22	273	SIGQUIT, SIGILL, SIGABRT,
59a06a91	274	#ifdef SIGEMT
d62a17ae	275	SIGEMT,
59a06a91	276	#endif
d62a17ae	277	SIGFPE, SIGBUS, SIGSEGV,
59a06a91	278	#ifdef SIGSYS
d62a17ae	279	SIGSYS,
59a06a91	280	#endif
59a06a91	281	#ifdef SIGXCPU
d62a17ae	282	SIGXCPU,
59a06a91	283	#endif
59a06a91	284	#ifdef SIGXFSZ
d62a17ae	285	SIGXFSZ,
59a06a91	286	#endif
d62a17ae	287	};
	288	static const int exit_signals[] = {
	289	SIGHUP, SIGINT, SIGALRM, SIGTERM, SIGUSR1, SIGUSR2,
59a06a91	290	#ifdef SIGPOLL
d62a17ae	291	SIGPOLL,
59a06a91	292	#endif
59a06a91	293	#ifdef SIGVTALRM
d62a17ae	294	SIGVTALRM,
59a06a91	295	#endif
59a06a91	296	#ifdef SIGSTKFLT
d62a17ae	297	SIGSTKFLT,
59a06a91	298	#endif
d62a17ae	299	};
	300	static const int ignore_signals[] = {
	301	SIGPIPE,
	302	};
	303	static const struct {
	304	const int *sigs;
d7c0a89a	305	unsigned int nsigs;
5e4f10b1	306	void (handler)(int signo, siginfo_t info, void *context);
d62a17ae	307	} sigmap[] = {
	308	{core_signals, array_size(core_signals), core_handler},
	309	{exit_signals, array_size(exit_signals), exit_handler},
	310	{ignore_signals, array_size(ignore_signals), NULL},
	311	};
d7c0a89a	312	unsigned int i;
d62a17ae	313
d62a17ae	314	for (i = 0; i < array_size(sigmap); i++) {
d7c0a89a	315	unsigned int j;
d62a17ae	316
	317	for (j = 0; j < sigmap[i].nsigs; j++) {
	318	struct sigaction oact;
	319	if ((sigaction(sigmap[i].sigs[j], NULL, &oact) == 0)
	320	&& (oact.sa_handler == SIG_DFL)) {
	321	struct sigaction act;
	322	sigfillset(&act.sa_mask);
	323	if (sigmap[i].handler == NULL) {
	324	act.sa_handler = SIG_IGN;
	325	act.sa_flags = 0;
	326	} else {
d62a17ae	327	/* Request extra arguments to signal
	328	* handler. */
	329	act.sa_sigaction = sigmap[i].handler;
	330	act.sa_flags = SA_SIGINFO;
3f11a103	331	#ifdef SA_RESETHAND
d62a17ae	332	/* don't try to print backtraces
	333	* recursively */
	334	if (sigmap[i].handler == core_handler)
	335	act.sa_flags \|= SA_RESETHAND;
31364274	336	#endif
d62a17ae	337	}
	338	if (sigaction(sigmap[i].sigs[j], &act, NULL)
	339	< 0)
ff9d9d5b	340	flog_err(
450971aa	341	EC_LIB_SYSTEM_CALL,
d62a17ae	342	"Unable to set signal handler for signal %d: %s",
	343	sigmap[i].sigs[j],
	344	safe_strerror(errno));
	345	}
	346	}
	347	}
59a06a91	348	}
59a06a91	349
d62a17ae	350	void signal_init(struct thread_master *m, int sigc,
d62a17ae	351	struct quagga_signal_t signals[])
c49b3069	352	{
c49b3069	353
d62a17ae	354	int i = 0;
	355	struct quagga_signal_t *sig;
	356
	357	/* First establish some default handlers that can be overridden by
	358	the application. */
	359	trap_default_signals();
	360
	361	while (i < sigc) {
	362	sig = &signals[i];
	363	if (signal_set(sig->signal) < 0)
	364	exit(-1);
	365	i++;
	366	}
	367
	368	sigmaster.sigc = sigc;
	369	sigmaster.signals = signals;
	370
	371	#ifdef SIGEVENT_SCHEDULE_THREAD
	372	sigmaster.t = NULL;
	373	thread_add_timer(m, quagga_signal_timer, &sigmaster,
	374	QUAGGA_SIGNAL_TIMER_INTERVAL, &sigmaster.t);
05c447dd	375	#endif /* SIGEVENT_SCHEDULE_THREAD */
c49b3069	376	}