Merge pull request #189 from hanna-kruppe/small-cleanups

Various small cleanups in signal-hook-registry

Author: vorner

signal-hook-registry/src/lib.rs

@@ -177,16 +177,16 @@ impl Slot {
         //
         // See #169.
 
-        new.sa_sigaction = handler as usize; // If it doesn't compile on AIX, upgrade the libc dependency
+        new.sa_sigaction = handler as *const () as usize; // If it doesn't compile on AIX, upgrade the libc dependency
 
-        // Android is broken and uses different int types than the rest (and different depending on
-        // the pointer width). This converts the flags to the proper type no matter what it is on
-        // the given platform.
         #[cfg(target_os = "nto")]
         let flags = 0;
-        // SA_RESTART is supported by qnx https://www.qnx.com/support/knowledgebase.html?id=50130000000SmiD
+        // SA_RESTART is not supported by qnx https://www.qnx.com/support/knowledgebase.html?id=50130000000SmiD
         #[cfg(not(target_os = "nto"))]
         let flags = libc::SA_RESTART;
+        // Android is broken and uses different int types than the rest (and different depending on
+        // the pointer width). This converts the flags to the proper type no matter what it is on
+        // the given platform.
         #[allow(unused_assignments)]
         let mut siginfo = flags;
         siginfo = libc::SA_SIGINFO as _;
@@ -246,9 +246,13 @@ impl Prev {
     fn execute(&self, sig: c_int) {
         let fptr = self.info;
         if fptr != 0 && fptr != SIG_DFL && fptr != SIG_IGN {
+            // `sighandler_t` is an integer type. Transmuting it directly from an integer to a
+            // function pointer seems dubious w.r.t. pointer provenance -- at least Miri complains
+            // about it. Casting to a raw pointer first side-steps the issue.
+            let fptr = fptr as *mut ();
             // FFI ‒ calling the original signal handler.
             unsafe {
-                let action = mem::transmute::<usize, extern "C" fn(c_int)>(fptr);
+                let action = mem::transmute::<*mut (), extern "C" fn(c_int)>(fptr);
                 action(sig);
             }
         }
@@ -258,6 +262,10 @@ impl Prev {
     unsafe fn execute(&self, sig: c_int, info: *mut siginfo_t, data: *mut c_void) {
         let fptr = self.info.sa_sigaction;
         if fptr != 0 && fptr != libc::SIG_DFL && fptr != libc::SIG_IGN {
+            // `sa_sigaction` is usually stored as integer type. Transmuting it directly from an
+            // integer to a function pointer seems dubious w.r.t. pointer provenance -- at least
+            // Miri complains about it. Casting to a raw pointer first side-steps the issue.
+            let fptr = fptr as *mut ();
             // Android is broken and uses different int types than the rest (and different
             // depending on the pointer width). This converts the flags to the proper type no
             // matter what it is on the given platform.
@@ -269,11 +277,11 @@ impl Prev {
             let mut siginfo = self.info.sa_flags;
             siginfo = libc::SA_SIGINFO as _;
             if self.info.sa_flags & siginfo == 0 {
-                let action = mem::transmute::<usize, extern "C" fn(c_int)>(fptr);
+                let action = mem::transmute::<*mut (), extern "C" fn(c_int)>(fptr);
                 action(sig);
             } else {
                 type SigAction = extern "C" fn(c_int, *mut siginfo_t, *mut c_void);
-                let action = mem::transmute::<usize, SigAction>(fptr);
+                let action = mem::transmute::<*mut (), SigAction>(fptr);
                 action(sig, info, data);
             }
         }