Ability to look up names of signals

+ Incorporate to the debug output of Origin, which will look much nicer
in the logs.

Author: vorner

CHANGELOG.md

@@ -1,3 +1,7 @@
+* `low_level::signal_name` to look up human readable name.
+* The `Origin`'s debug output now contains the human readable name of the
+  signal.
+
 # 0.3.2
 
 * Allow extracting Origin from the raw `siginfo_t` structure by hand, without

src/low_level/mod.rs

@@ -12,9 +12,12 @@ pub mod channel;
 pub mod pipe;
 #[cfg(feature = "extended-siginfo-raw")]
 pub mod siginfo;
+mod signal_details;
 
 pub use signal_hook_registry::{register, unregister};
 
+pub use self::signal_details::signal_name;
+
 /// The usual raise, just the safe wrapper around it.
 ///
 /// This is async-signal-safe.

src/low_level/siginfo.rs

@@ -2,7 +2,12 @@
 //!
 //! See [`Origin`].
 
+use std::fmt::{Debug, Formatter, Result as FmtResult};
+
 use libc::{c_int, pid_t, siginfo_t, uid_t};
+
+use crate::low_level;
+
 // Careful: make sure the signature and the constants match the C source
 extern "C" {
     fn sighook_signal_cause(info: &siginfo_t) -> ICause;
@@ -176,7 +181,7 @@ impl From<ICause> for Cause {
 ///
 /// This is produced by the [`WithOrigin`] exfiltrator (or can be [extracted][Origin::extract] from
 /// `siginfo_t` by hand).
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Eq, PartialEq)]
 #[non_exhaustive]
 pub struct Origin {
     /// The signal that happened.
@@ -204,6 +209,21 @@ pub struct Origin {
     pub cause: Cause,
 }
 
+impl Debug for Origin {
+    fn fmt(&self, fmt: &mut Formatter) -> FmtResult {
+        fn named_signal(sig: c_int) -> String {
+            low_level::signal_name(sig)
+                .map(|n| format!("{} ({})", n, sig))
+                .unwrap_or_else(|| sig.to_string())
+        }
+        fmt.debug_struct("Origin")
+            .field("signal", &named_signal(self.signal))
+            .field("process", &self.process)
+            .field("cause", &self.cause)
+            .finish()
+    }
+}
+
 impl Origin {
     /// Extracts the Origin from a raw `siginfo_t` structure.
     ///

src/low_level/signal_details.rs

@@ -0,0 +1,93 @@
+//! Providing auxiliary information for signals.
+
+use libc::c_int;
+
+use crate::consts::signal::*;
+
+struct Details {
+    signal: c_int,
+    name: &'static str,
+}
+
+macro_rules! s {
+    ($name: expr) => {
+        Details {
+            signal: $name,
+            name: stringify!($name),
+        }
+    };
+}
+
+#[cfg(not(windows))]
+const DETAILS: &[Details] = &[
+    s!(SIGABRT),
+    s!(SIGALRM),
+    s!(SIGBUS),
+    s!(SIGCHLD),
+    s!(SIGCONT),
+    s!(SIGFPE),
+    s!(SIGHUP),
+    s!(SIGILL),
+    s!(SIGINT),
+    s!(SIGIO),
+    s!(SIGKILL),
+    s!(SIGPIPE),
+    s!(SIGPROF),
+    s!(SIGQUIT),
+    s!(SIGSEGV),
+    s!(SIGSTOP),
+    s!(SIGSYS),
+    s!(SIGTERM),
+    s!(SIGTRAP),
+    s!(SIGTSTP),
+    s!(SIGTTIN),
+    s!(SIGTTOU),
+    s!(SIGURG),
+    s!(SIGUSR1),
+    s!(SIGUSR2),
+    s!(SIGVTALRM),
+    s!(SIGWINCH),
+    s!(SIGXCPU),
+    s!(SIGXFSZ),
+];
+
+#[cfg(windows)]
+const DETAILS: &[Details] = &[
+    s!(SIGABRT),
+    s!(SIGFPE),
+    s!(SIGILL),
+    s!(SIGINT),
+    s!(SIGSEGV),
+    s!(SIGTERM),
+];
+
+/// Provides a human-readable name of a signal.
+///
+/// Note that the name does not have to be known (in case it is some less common, or non-standard
+/// signal).
+///
+/// # Examples
+///
+/// ```
+/// # use signal_hook::low_level::signal_name;
+/// assert_eq!("SIGKILL", signal_name(9).unwrap());
+/// assert!(signal_name(142).is_none());
+/// ```
+pub fn signal_name(signal: c_int) -> Option<&'static str> {
+    DETAILS.iter().find(|d| d.signal == signal).map(|d| d.name)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn existing() {
+        assert_eq!("SIGTERM", signal_name(SIGTERM).unwrap());
+    }
+
+    #[test]
+    fn unknown() {
+        assert!(signal_name(128).is_none());
+    }
+}