ah-signal.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
# ifndef AH_SIGNAL_H
# define AH_SIGNAL_H
 
# include <csignal>
# include <cstring>
# include <iostream>
# include <stdexcept>
# include <string>
# include <initializer_list>
# include <aleph.H>
 
class SignalError : public std::runtime_error
{
  int signal_num_;
  int errno_code_;
 
public:
  SignalError(const std::string & msg, int signo = -1, int err = 0)
    : std::runtime_error(msg), signal_num_(signo), errno_code_(err) {}
 
  [[nodiscard]] int signal_number() const noexcept { return signal_num_; }
 
  [[nodiscard]] int error_code() const noexcept { return errno_code_; }
};
 
class SignalSet
{
  sigset_t set_;
 
public:
  SignalSet() noexcept { sigemptyset(&set_); }
 
  SignalSet(std::initializer_list<int> signals) noexcept
  {
    sigemptyset(&set_);
    for (int sig : signals)
      sigaddset(&set_, sig);
  }
 
  [[nodiscard]] static SignalSet full() noexcept
  {
    SignalSet s;
    sigfillset(&s.set_);
    return s;
  }
 
  [[nodiscard]] static SignalSet empty() noexcept { return SignalSet(); }
 
  SignalSet & add(int signo) noexcept
  {
    sigaddset(&set_, signo);
    return *this;
  }
 
  SignalSet & remove(int signo) noexcept
  {
    sigdelset(&set_, signo);
    return *this;
  }
 
  SignalSet & clear() noexcept
  {
    sigemptyset(&set_);
    return *this;
  }
 
  SignalSet & fill() noexcept
  {
    sigfillset(&set_);
    return *this;
  }
 
  [[nodiscard]] bool contains(int signo) const noexcept
  {
    return sigismember(&set_, signo) == 1;
  }
 
  [[nodiscard]] sigset_t * get() noexcept { return &set_; }
 
  [[nodiscard]] const sigset_t * get() const noexcept { return &set_; }
 
  operator sigset_t *() noexcept { return &set_; }
 
  operator const sigset_t *() const noexcept { return &set_; }
};
 
class SignalBlocker
{
  sigset_t old_mask_;
  bool active_ = true;
 
public:
  explicit SignalBlocker(const SignalSet & signals)
  {
    if (sigprocmask(SIG_BLOCK, signals.get(), &old_mask_) < 0)
      throw SignalError("sigprocmask(SIG_BLOCK) failed", -1, errno);
  }
 
  SignalBlocker(std::initializer_list<int> signals)
    : SignalBlocker(SignalSet(signals)) {}
 
  explicit SignalBlocker(int signo)
    : SignalBlocker(SignalSet({signo})) {}
 
  ~SignalBlocker()
  {
    if (active_)
      sigprocmask(SIG_SETMASK, &old_mask_, nullptr);
  }
 
  void release() noexcept { active_ = false; }
 
  [[nodiscard]] const sigset_t & previous_mask() const noexcept
  {
    return old_mask_;
  }
 
  // Non-copyable
  SignalBlocker(const SignalBlocker &) = delete;
  SignalBlocker & operator=(const SignalBlocker &) = delete;
 
  // Movable
  SignalBlocker(SignalBlocker && other) noexcept
    : old_mask_(other.old_mask_), active_(other.active_)
  {
    other.active_ = false;
  }
 
  SignalBlocker & operator=(SignalBlocker && other) noexcept
  {
    if (this != &other)
      {
        if (active_)
          sigprocmask(SIG_SETMASK, &old_mask_, nullptr);
        old_mask_ = other.old_mask_;
        active_ = other.active_;
        other.active_ = false;
      }
    return *this;
  }
};
 
class Signal
{
public:
  using Handler = void (*)(int);
 
private:
  struct sigaction old_action_;
  int signal_number_;
  bool restart_calls_;
  bool active_ = true;
 
  // Internal constructor that doesn't abort on error
  struct NoAbortTag {};
 
  Signal(NoAbortTag, int signo, Handler func, bool restart_calls, int & error_out)
    : signal_number_(signo), restart_calls_(restart_calls)
  {
    error_out = 0;
    struct sigaction act;
 
    act.sa_handler = func;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
 
    if (signo == SIGALRM)
      {
#ifdef SA_INTERRUPT
        act.sa_flags |= SA_INTERRUPT;
#endif
      }
    else if (restart_calls_)
      {
#ifdef SA_RESTART
        act.sa_flags |= SA_RESTART;
#endif
      }
 
    if (sigaction(signo, &act, &old_action_) < 0)
      {
        error_out = errno;
        active_ = false;
      }
  }
 
public:
  Signal(int signo, Handler func, bool restart_calls = true)
    : signal_number_(signo), restart_calls_(restart_calls)
  {
    struct sigaction act;
 
    act.sa_handler = func;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
 
    if (signo == SIGALRM)
      {
#ifdef SA_INTERRUPT
        act.sa_flags |= SA_INTERRUPT;
#endif
      }
    else if (restart_calls_)
      {
#ifdef SA_RESTART
        act.sa_flags |= SA_RESTART;
#endif
      }
 
    if (sigaction(signo, &act, &old_action_) < 0)
      {
        std::cerr << "Cannot modify the action associated with the signal "
                  << signo << std::endl;
        abort();
      }
  }
 
 
  [[nodiscard]] static Signal create(int signo, Handler func,
                                     bool restart_calls = true)
  {
    int error = 0;
    Signal sig(NoAbortTag{}, signo, func, restart_calls, error);
    if (error != 0)
      throw SignalError("Cannot modify signal action for signal " +
                        std::to_string(signo) + ": " + std::strerror(error),
                        signo, error);
    return sig;
  }
 
  [[nodiscard]] static Signal try_create(int signo, Handler func,
                                         bool restart_calls, int & error_out)
  {
    return Signal(NoAbortTag{}, signo, func, restart_calls, error_out);
  }
 
  ~Signal()
  {
    if (active_)
      {
        if (sigaction(signal_number_, &old_action_, nullptr) < 0)
          {
            std::cerr << "Cannot restore signal handler for signal "
                      << signal_number_ << std::endl;
            abort();
          }
      }
  }
 
  void release() noexcept { active_ = false; }
 
  [[nodiscard]] int signal_number() const noexcept { return signal_number_; }
 
  [[nodiscard]] bool restarts_calls() const noexcept { return restart_calls_; }
 
  [[nodiscard]] bool is_active() const noexcept { return active_; }
 
  [[nodiscard]] Handler previous_handler() const noexcept
  {
    return old_action_.sa_handler;
  }
 
  [[nodiscard]] const struct sigaction & previous_action() const noexcept
  {
    return old_action_;
  }
 
  // Non-copyable (would cause double restoration)
  Signal(const Signal &) = delete;
  Signal & operator=(const Signal &) = delete;
 
  Signal(Signal && other) noexcept
    : old_action_(other.old_action_),
      signal_number_(other.signal_number_),
      restart_calls_(other.restart_calls_),
      active_(other.active_)
  {
    other.active_ = false;
  }
 
  Signal & operator=(Signal && other) noexcept
  {
    if (this != &other)
      {
        // Restore our handler first if active (ignore errors in move)
        if (active_)
          sigaction(signal_number_, &old_action_, nullptr);
 
        old_action_ = other.old_action_;
        signal_number_ = other.signal_number_;
        restart_calls_ = other.restart_calls_;
        active_ = other.active_;
        other.active_ = false;
      }
    return *this;
  }
};
 
[[nodiscard]] inline int wait_for_signal(const SignalSet & signals)
{
  int sig = 0;
  int result = sigwait(signals.get(), &sig);
  if (result != 0)
    throw SignalError("sigwait failed", -1, result);
  return sig;
}
 
inline bool send_signal_to_self(int signo) noexcept
{
  return raise(signo) == 0;
}
 
[[nodiscard]] inline std::string signal_name(int signo)
{
  switch (signo)
    {
    case SIGHUP:    return "SIGHUP";
    case SIGINT:    return "SIGINT";
    case SIGQUIT:   return "SIGQUIT";
    case SIGILL:    return "SIGILL";
    case SIGABRT:   return "SIGABRT";
    case SIGFPE:    return "SIGFPE";
    case SIGKILL:   return "SIGKILL";
    case SIGSEGV:   return "SIGSEGV";
    case SIGPIPE:   return "SIGPIPE";
    case SIGALRM:   return "SIGALRM";
    case SIGTERM:   return "SIGTERM";
    case SIGUSR1:   return "SIGUSR1";
    case SIGUSR2:   return "SIGUSR2";
    case SIGCHLD:   return "SIGCHLD";
    case SIGCONT:   return "SIGCONT";
    case SIGSTOP:   return "SIGSTOP";
    case SIGTSTP:   return "SIGTSTP";
    case SIGTTIN:   return "SIGTTIN";
    case SIGTTOU:   return "SIGTTOU";
#ifdef SIGBUS
    case SIGBUS:    return "SIGBUS";
#endif
#ifdef SIGTRAP
    case SIGTRAP:   return "SIGTRAP";
#endif
#ifdef SIGURG
    case SIGURG:    return "SIGURG";
#endif
#ifdef SIGXCPU
    case SIGXCPU:   return "SIGXCPU";
#endif
#ifdef SIGXFSZ
    case SIGXFSZ:   return "SIGXFSZ";
#endif
#ifdef SIGVTALRM
    case SIGVTALRM: return "SIGVTALRM";
#endif
#ifdef SIGPROF
    case SIGPROF:   return "SIGPROF";
#endif
#ifdef SIGWINCH
    case SIGWINCH:  return "SIGWINCH";
#endif
#ifdef SIGIO
    case SIGIO:     return "SIGIO";
#endif
#ifdef SIGSYS
    case SIGSYS:    return "SIGSYS";
#endif
    default:        return "Signal " + std::to_string(signo);
    }
}
 
[[nodiscard]] inline std::string signal_description(int signo)
{
  const char * desc = strsignal(signo);
  if (desc)
    return desc;
  return signal_name(signo);
}
 
# endif // AH_SIGNAL_H