boost::asio::signal_set does not restore previous signal handlers - c++

Question

So I have a daemon who can be gracefully shut down using SIGQUIT.
This daemon is running boost::asio::io_service. I use boost::asio::signal_set to catch this signal.
I have encountered a behaviour that I believe to be completely wrong. When I destroy boost::asio::signal_set object it does not restore previous handler of that signal. Previous handler for SIGQUIT was a no-op. So upon receiving this signal after boost::asio::signal_set was destroyed my daemon terminates. My guess is this is because boost::asio::signal_set upon destruction sets default handler, that is to terminate the program, but not the previous handler.
I see this as very inappropriate. What I am asking is am I wrong? Maybe I am missing something?

Answer 1

Boost.Asio does not specify the resulting handler state for a signal that had been added to boost::asio::signal_set and then removed via either signal_set::remove(), signal_set::clear(), or destruction of the signal_set. In particular, the post-condition is not specified for any of the associated operations in the Signal Set Service requirements.
A quick glance a the signal_set_service::add() implementation:
::sigaction(signal_number, &sa, 0)
and the signal_set_service::clear() implementation:
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL;
::sigaction(reg->signal_number_, &sa, 0)
shows that the calls to sigaction() are not handling previously installed handlers, and results in the default handler action being registered when a signal is removed via signal_set_service.
As a signal may be delivered after Boost.Asio sets the signal action to default, but before the application code has been able to assign its own handler, consider using pthread_sigmask() to block all signals within the io_service. Once the signals have been removed from the signal_set, assign the desired handler via sigaction(), then unblock the signals.
Here is a complete example demonstrating this approach:
#include <iostream>
#include <boost/asio.hpp>
void signal_handler(int signal_number)
{
std::cout << "signal_handler(): " << signal_number << std::endl;
}
int main()
{
// Force scope to control io_service lifetime.
{
boost::asio::io_service io_service;
// Boost.Asio will register an internal handler for SIGQUIT.
boost::asio::signal_set signal_set(io_service, SIGQUIT);
signal_set.async_wait(
[](const boost::system::error_code& error,
int signal_number)
{
std::cout << "siganl_set.async_wait handler: "
<< signal_number << std::endl;
// Block SIGQUIT.
sigset_t signal_mask;
sigemptyset(&signal_mask);
sigaddset(&signal_mask, SIGQUIT);
assert(pthread_sigmask(SIG_BLOCK, &signal_mask, NULL) == 0);
});
// Send SIGQUIT to this process.
raise(SIGQUIT);
// By the time raise() returns, Boost.Asio has handled SIGQUIT with its
// own internal handler, queuing it internally. At this point, Boost.Asio
// is ready to dispatch this notification to a user signal handler
// (i.e. those provided to signal_set.async_wait()) within the
// io_service event loop.
// Prior to calling the io_service, SIGQUIT is not blocked.
io_service.run();
// The user provided handler was invoked and has blocked SIGQUIT.
}
// Send SIGQUIT to this process.
raise(SIGQUIT);
// Even though Boost.Asio has set the default handler for SIGQUIT, the
// signal is blocked, so the signal has been placed into a pending state.
// Register a custom handler for SIGQUIT.
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_handler = &signal_handler;
assert(sigaction(SIGQUIT, &sa, 0) == 0);
// Unblock SIGQUIT.
sigset_t signal_mask;
sigemptyset(&signal_mask);
sigaddset(&signal_mask, SIGQUIT);
assert(pthread_sigmask(SIG_UNBLOCK, &signal_mask, NULL) == 0);
// Upon unblocking, the pending SIGQUIT signal is delivered and handled
// by the handler registered via sigaction.
std::cout << "Fin" << std::endl;
}
And its output:
$ ./a.out
siganl_set.async_wait handler: 3
signal_handler(): 3
Fin