// This defines the `signals_receipts_premade` module.
signals_receipts::premade! {
    SIGINT => |receipt| println!("Interrupted {} times since last.", receipt.cur_count);
    SIGTERM => |control| control.break_loop();
}

fn main() {
    use crate::signals_receipts_premade::SignalsReceipts;
    use signals_receipts::Premade as _;
    use std::thread::spawn;

    SignalsReceipts::install_all_handlers();
    let consumer = spawn(SignalsReceipts::consume_loop);
    consumer.join();
    println!("Terminated.");
}

// This defines the `channel_notify_facility_premade` module.
signals_receipts::channel_notify_facility! { SIGINT, SIGQUIT, SIGTERM }

fn main() {
    use crate::channel_notify_facility_premade::SignalsChannel;
    use signals_receipts::{channel_notify_facility::{
                               SignalsChannel as _, Receiver},
                           SignalNumber};

    #[derive(Debug)]
    enum MySignalRepr {
        Interrupt,
        Quit
    }
    impl TryFrom<SignalNumber> for MySignalRepr {
        type Error = &'static str;
        fn try_from(value: SignalNumber) -> Result<Self, Self::Error> {
            match value {
                libc::SIGINT  => Ok(Self::Interrupt),
                libc::SIGQUIT => Ok(Self::Quit),
                _ => Err("unrecognized signal")
            }
        }
    }

    // The capacity of the signals-notifications channel.
    let bound = 10;
    // This installs the signal handlers and creates the consumer thread.
    // Delivered signals are converted to `MySignalRepr`.
    let receiver: Receiver<MySignalRepr, _> =
        SignalsChannel::install(Some(bound)).unwrap();

    for sig in receiver.as_ref() {
        match sig {
            MySignalRepr::Interrupt => println!("Interrupted."),
            MySignalRepr::Quit => { println!("Quitted."); break; },
            // If SIGTERM is delivered while having this install, it's not sent
            // on this channel, because converting it to `MySignalRepr` fails.
        }
    }

    // This uninstalls the signal handlers but keeps the consumer thread
    // as dormant in case re-installing is done later.
    SignalsChannel::uninstall(receiver).unwrap();

    // This re-installs the signal handlers and reuses the same consumer thread.
    // Delivered signals are not converted with this choice of type.
    let receiver: Receiver<SignalNumber, _> =
        SignalsChannel::install(None).unwrap();

    // (Just a way to wait until termination signal.)  SIGTERM is now sent on
    // this different channel, because there's no conversion failure.
    receiver.as_ref().iter().any(|sig_num| libc::SIGTERM == sig_num);

    // This uninstalls and terminates the consumer thread.
    // (Re-installing could still be done again.)
    SignalsChannel::finish(receiver).unwrap();
}

It provides an impressive degree of abilities, for being so limited by async-signal-safety. Its iterator over incoming signals is simple to initialize and use across threads, and using only that is sometimes sufficient. It can provide the extra info of SA_SIGINFO. A reason to not use signal_hook is when having its full suite of abilities, but mostly unused, would definitely be overkill. If you're not sure it would be overkill, you might want to choose signal_hook instead. But other reasons to use signals_receipts are that it's no_std and that it can fully uninstall the signal handlers, whereas signal_hook isn't (it requires std) and can't (it can only emulate uninstalling).

• BSD
  • FreeBSD 14.0
  • NetBSD 9.1
  • OpenBSD 7.5
• Linux
  • Adélie 1.0 (uses musl)
  • Alpine 3.18 (uses musl)
  • Chimera (uses musl)
  • Debian 12
  • NixOS 24.05
  • openSUSE 15.5
  • RHEL (Rocky) 9.4
  • Ubuntu 23.10
• Mac
  • 10.13 High Sierra
  • 12 Monterey
• Solaris
  • OpenIndiana 2024.04

All glibc- or musl-based Linux OSs, and all macOS and Mac OS X versions, should already work. It might already work on further POSIX OSs. If not, adding support for other POSIX OSs should be easy but might require making tweaks to this crate's conditional compilation.