Add signal::sigaction_current()

Provide a way to query the currently installed sigaction.

The decision to add `sigaction_current()` instead of just exposing the
`sigaction_inner()` function was to avoid any confusion over the
semantics of passing in a `None` `sigaction` argument (eg: someone
thinking that it meant remove or reset the action).

This builds towards #2172.

src/sys/signal.rs

@@ -864,6 +864,16 @@ impl SigAction {
     }
 }
 
+unsafe fn sigaction_inner(signal: Signal, sigaction: Option<&SigAction>) -> Result<SigAction> {
+    let mut oldact = mem::MaybeUninit::<libc::sigaction>::uninit();
+
+    let res = libc::sigaction(signal as libc::c_int,
+            sigaction.map_or(ptr::null(), |sigaction| &sigaction.sigaction as *const libc::sigaction),
+                              oldact.as_mut_ptr());
+
+    Errno::result(res).map(|_| SigAction { sigaction: oldact.assume_init() })
+}
+
 /// Changes the action taken by a process on receipt of a specific signal.
 ///
 /// `signal` can be any signal except `SIGKILL` or `SIGSTOP`. On success, it returns the previous
@@ -882,13 +892,23 @@ impl SigAction {
 ///   pointer is valid.  In that case, this function effectively dereferences a
 ///   raw pointer of unknown provenance.
 pub unsafe fn sigaction(signal: Signal, sigaction: &SigAction) -> Result<SigAction> {
-    let mut oldact = mem::MaybeUninit::<libc::sigaction>::uninit();
-
-    let res = libc::sigaction(signal as libc::c_int,
-                              &sigaction.sigaction as *const libc::sigaction,
-                              oldact.as_mut_ptr());
+    sigaction_inner(signal, Some(sigaction))
+}
 
-    Errno::result(res).map(|_| SigAction { sigaction: oldact.assume_init() })
+/// Gets the current action a process will take on receipt of a specific signal.
+///
+/// `signal` can be any signal except `SIGKILL` or `SIGSTOP`. On success, it returns the current
+/// action for the given signal. The current action will always remain in place, unchanged.
+///
+/// # Safety
+///
+/// There is no guarantee that the old signal handler was installed
+/// correctly.  If it was installed by this crate, it will be.  But if it was
+/// installed by, for example, C code, then there is no guarantee its function
+/// pointer is valid.  In that case, this function effectively dereferences a
+/// raw pointer of unknown provenance.
+pub unsafe fn sigaction_current(signal: Signal) -> Result<SigAction> {
+    sigaction_inner(signal, None)
 }
 
 /// Signal management (see [signal(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/signal.html))

test/sys/test_signal.rs

@@ -35,6 +35,48 @@ fn test_old_sigaction_flags() {
     unsafe { sigaction(SIGINT, &oact) }.unwrap();
 }
 
+#[test]
+fn test_current_sigaction() {
+    let _m = crate::SIGNAL_MTX.lock();
+
+    let oact = unsafe {
+        sigaction(
+            SIGINT,
+            &SigAction::new(
+                SigHandler::SigDfl,
+                SaFlags::empty(),
+                SigSet::empty(),
+            ),
+        )
+    }
+    .unwrap();
+
+    assert_eq!(
+        unsafe { sigaction_current(SIGINT) }.unwrap().handler(),
+        SigHandler::SigDfl
+    );
+
+    unsafe {
+        sigaction(
+            SIGINT,
+            &SigAction::new(
+                SigHandler::SigIgn,
+                SaFlags::empty(),
+                SigSet::empty(),
+            ),
+        )
+    }
+    .unwrap();
+
+    assert_eq!(
+        unsafe { sigaction_current(SIGINT) }.unwrap().handler(),
+        SigHandler::SigIgn
+    );
+
+    // restore original
+    unsafe { sigaction(SIGINT, &oact) }.unwrap();
+}
+
 #[test]
 fn test_sigprocmask_noop() {
     sigprocmask(SigmaskHow::SIG_BLOCK, None, None)