I/O safety

hanna-kruppe · vorner · commit 09d1e0811aca · 2025-12-26T12:33:00.000+01:00
Use OwnedFd instead of IntoRawFd, as it enforces the ownership of the
file descriptor.

Updating minimal rust version to 1.66.0 (introduction of OwnedFd).
diff --git a/Cargo.toml b/Cargo.toml
@@ -12,7 +12,7 @@ readme = "README.md"
 keywords = ["signal", "unix", "daemon"]
 license = "MIT OR Apache-2.0"
 edition = "2018"
-rust-version = "1.31"
+rust-version = "1.66"
 
 [badges]
 maintenance = { status = "actively-developed" }
diff --git a/signal-hook-async-std/src/lib.rs b/signal-hook-async-std/src/lib.rs
@@ -92,7 +92,7 @@ impl<E: Exfiltrator> SignalsInfo<E> {
         S: Borrow<c_int>,
     {
         let (read, write) = Async::<UnixStream>::pair()?;
-        let inner = SignalDelivery::with_pipe(read, write, exfiltrator, signals)?;
+        let inner = SignalDelivery::with_pipe(read, write.into_inner()?, exfiltrator, signals)?;
         Ok(Self(OwningSignalIterator::new(inner)))
     }
 
diff --git a/signal-hook-mio/Cargo.toml b/signal-hook-mio/Cargo.toml
@@ -14,7 +14,7 @@ keywords = ["signal", "unix", "mio"]
 license = "MIT OR Apache-2.0"
 
 edition = "2018"
-rust-version = "1.36"
+rust-version = "1.66"
 
 [badges]
 travis-ci = { repository = "vorner/signal-hook" }
diff --git a/signal-hook-mio/src/lib.rs b/signal-hook-mio/src/lib.rs
@@ -25,6 +25,7 @@ macro_rules! implement_signals_with_pipe {
     ($pipe:path) => {
         use std::borrow::Borrow;
         use std::io::Error;
+        use std::os::fd::{FromRawFd, IntoRawFd, OwnedFd};
 
         use signal_hook::iterator::backend::{self, SignalDelivery};
         use signal_hook::iterator::exfiltrator::{Exfiltrator, SignalOnly};
@@ -61,7 +62,10 @@ macro_rules! implement_signals_with_pipe {
                 S: Borrow<c_int>,
             {
                 let (read, write) = Pipe::pair()?;
-                let delivery = SignalDelivery::with_pipe(read, write, exfiltrator, signals)?;
+                // For mio 1.0 we could use OwnedFd::from, but older mio versions don't have that
+                // due to their lower MSRV, so we need to go through RawFd.
+                let write_fd = unsafe { OwnedFd::from_raw_fd(write.into_raw_fd()) };
+                let delivery = SignalDelivery::with_pipe(read, write_fd, exfiltrator, signals)?;
                 Ok(Self(delivery))
             }
 
diff --git a/signal-hook-mio/tests/mio_0_6.rs b/signal-hook-mio/tests/mio_0_6.rs
@@ -16,7 +16,7 @@ use libc::c_int;
 fn mio_wakeup() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1]).unwrap();
+    let mut signals = Signals::new([SIGUSR1]).unwrap();
     let token = Token(0);
     let poll = Poll::new().unwrap();
     poll.register(&signals, token, Ready::readable(), PollOpt::level())
@@ -47,7 +47,7 @@ fn mio_wakeup() {
 fn mio_multiple_signals() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1, SIGUSR2]).unwrap();
+    let mut signals = Signals::new([SIGUSR1, SIGUSR2]).unwrap();
     let poll = Poll::new().unwrap();
     let token = Token(0);
     poll.register(&signals, token, Ready::readable(), PollOpt::level())
@@ -79,7 +79,7 @@ fn mio_multiple_signals() {
 fn mio_parallel_multiple() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1]).unwrap();
+    let mut signals = Signals::new([SIGUSR1]).unwrap();
     let poll = Poll::new().unwrap();
     let token = Token(0);
     poll.register(&signals, token, Ready::readable(), PollOpt::level())
diff --git a/signal-hook-mio/tests/mio_0_7.rs b/signal-hook-mio/tests/mio_0_7.rs
@@ -51,7 +51,7 @@ fn mio_wakeup() {
 fn mio_multiple_signals() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1, SIGUSR2]).unwrap();
+    let mut signals = Signals::new([SIGUSR1, SIGUSR2]).unwrap();
     let mut poll = Poll::new().unwrap();
     let token = Token(0);
     poll.registry()
@@ -84,7 +84,7 @@ fn mio_multiple_signals() {
 fn mio_parallel_multiple() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1]).unwrap();
+    let mut signals = Signals::new([SIGUSR1]).unwrap();
     let mut poll = Poll::new().unwrap();
     let token = Token(0);
     poll.registry()
diff --git a/signal-hook-mio/tests/mio_0_8.rs b/signal-hook-mio/tests/mio_0_8.rs
@@ -17,7 +17,7 @@ use libc::c_int;
 fn mio_wakeup() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1]).unwrap();
+    let mut signals = Signals::new([SIGUSR1]).unwrap();
     let mut poll = Poll::new().unwrap();
     let token = Token(0);
     poll.registry()
@@ -51,7 +51,7 @@ fn mio_wakeup() {
 fn mio_multiple_signals() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1, SIGUSR2]).unwrap();
+    let mut signals = Signals::new([SIGUSR1, SIGUSR2]).unwrap();
     let mut poll = Poll::new().unwrap();
     let token = Token(0);
     poll.registry()
@@ -84,7 +84,7 @@ fn mio_multiple_signals() {
 fn mio_parallel_multiple() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1]).unwrap();
+    let mut signals = Signals::new([SIGUSR1]).unwrap();
     let mut poll = Poll::new().unwrap();
     let token = Token(0);
     poll.registry()
diff --git a/signal-hook-mio/tests/mio_1_0.rs b/signal-hook-mio/tests/mio_1_0.rs
@@ -17,7 +17,7 @@ use libc::c_int;
 fn mio_wakeup() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1]).unwrap();
+    let mut signals = Signals::new([SIGUSR1]).unwrap();
     let mut poll = Poll::new().unwrap();
     let token = Token(0);
     poll.registry()
@@ -51,7 +51,7 @@ fn mio_wakeup() {
 fn mio_multiple_signals() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1, SIGUSR2]).unwrap();
+    let mut signals = Signals::new([SIGUSR1, SIGUSR2]).unwrap();
     let mut poll = Poll::new().unwrap();
     let token = Token(0);
     poll.registry()
@@ -84,7 +84,7 @@ fn mio_multiple_signals() {
 fn mio_parallel_multiple() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR1]).unwrap();
+    let mut signals = Signals::new([SIGUSR1]).unwrap();
     let mut poll = Poll::new().unwrap();
     let token = Token(0);
     poll.registry()
diff --git a/signal-hook-tokio/src/lib.rs b/signal-hook-tokio/src/lib.rs
@@ -110,7 +110,7 @@ impl<E: Exfiltrator> SignalsInfo<E> {
         S: Borrow<c_int>,
     {
         let (read, write) = UnixStream::pair()?;
-        let inner = SignalDelivery::with_pipe(read, write, exfiltrator, signals)?;
+        let inner = SignalDelivery::with_pipe(read, write.into_std()?, exfiltrator, signals)?;
         Ok(Self(OwningSignalIterator::new(inner)))
     }
 
diff --git a/src/iterator/backend.rs b/src/iterator/backend.rs
@@ -21,6 +21,7 @@ use std::borrow::{Borrow, BorrowMut};
 use std::fmt::{Debug, Formatter, Result as FmtResult};
 use std::io::Error;
 use std::mem::MaybeUninit;
+use std::os::fd::{AsFd, OwnedFd};
 use std::os::unix::io::AsRawFd;
 use std::ptr;
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -39,9 +40,9 @@ trait SelfPipeWrite: Debug + Send + Sync {
     fn wake_readers(&self);
 }
 
-impl<W: AsRawFd + Debug + Send + Sync> SelfPipeWrite for W {
+impl<W: AsFd + Debug + Send + Sync> SelfPipeWrite for W {
     fn wake_readers(&self) {
-        pipe::wake(self.as_raw_fd(), WakeMethod::Send);
+        pipe::wake(self.as_fd(), WakeMethod::Send);
     }
 }
 
@@ -264,11 +265,11 @@ where
     where
         I: IntoIterator<Item = S>,
         S: Borrow<c_int>,
-        W: 'static + AsRawFd + Debug + Send + Sync,
+        W: 'static + Into<OwnedFd> + Debug + Send + Sync,
     {
         let pending = Arc::new(PendingSignals::new(exfiltrator));
         let pending_add_signal = Arc::clone(&pending);
-        let handle = Handle::new(write, pending_add_signal);
+        let handle = Handle::new(write.into(), pending_add_signal);
         let me = Self {
             read,
             handle,
diff --git a/src/lib.rs b/src/lib.rs
@@ -350,7 +350,6 @@
 pub mod flag;
 #[cfg(all(not(windows), feature = "iterator"))]
 #[cfg_attr(docsrs, doc(cfg(all(not(windows), feature = "iterator"))))]
-#[clippy::msrv = "1.36"]
 pub mod iterator;
 pub mod low_level;
 
diff --git a/src/low_level/mod.rs b/src/low_level/mod.rs
@@ -8,7 +8,6 @@ use libc::c_int;
 
 #[cfg(feature = "channel")]
 #[cfg_attr(docsrs, doc(cfg(feature = "channel")))]
-#[clippy::msrv = "1.34"]
 pub mod channel;
 #[cfg(not(windows))]
 #[cfg_attr(docsrs, doc(cfg(not(windows))))]
diff --git a/src/low_level/pipe.rs b/src/low_level/pipe.rs
@@ -76,7 +76,8 @@
 //! ```
 
 use std::io::{Error, ErrorKind};
-use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
+use std::os::fd::{AsFd, BorrowedFd, OwnedFd};
+use std::os::unix::io::AsRawFd;
 
 use libc::{self, c_int};
 
@@ -94,45 +95,46 @@ pub(crate) enum WakeMethod {
 }
 
 struct WakeFd {
-    fd: RawFd,
+    fd: OwnedFd,
     method: WakeMethod,
 }
 
 impl WakeFd {
     /// Sets close on exec and nonblock on the inner file descriptor.
     fn set_flags(&self) -> Result<(), Error> {
         unsafe {
-            let flags = libc::fcntl(self.as_raw_fd(), libc::F_GETFL, 0);
+            let flags = libc::fcntl(self.fd.as_raw_fd(), libc::F_GETFL, 0);
             if flags == -1 {
                 return Err(Error::last_os_error());
             }
             let flags = flags | libc::O_NONBLOCK | libc::O_CLOEXEC;
-            if libc::fcntl(self.as_raw_fd(), libc::F_SETFL, flags) == -1 {
+            if libc::fcntl(self.fd.as_raw_fd(), libc::F_SETFL, flags) == -1 {
                 return Err(Error::last_os_error());
             }
         }
         Ok(())
     }
+
     fn wake(&self) {
-        wake(self.fd, self.method);
+        wake(self.fd.as_fd(), self.method);
     }
 }
 
-impl AsRawFd for WakeFd {
-    fn as_raw_fd(&self) -> RawFd {
-        self.fd
+impl AsFd for WakeFd {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.fd.as_fd()
     }
 }
 
 impl Drop for WakeFd {
     fn drop(&mut self) {
         unsafe {
-            libc::close(self.fd);
+            libc::close(self.fd.as_raw_fd());
         }
     }
 }
 
-pub(crate) fn wake(pipe: RawFd, method: WakeMethod) {
+pub(crate) fn wake(pipe: BorrowedFd<'_>, method: WakeMethod) {
     unsafe {
         // This writes some data into the pipe.
         //
@@ -146,8 +148,8 @@ pub(crate) fn wake(pipe: RawFd, method: WakeMethod) {
         //   woken up, so not fitting another letter in it is fine.
         let data = b"X" as *const _ as *const _;
         match method {
-            WakeMethod::Write => libc::write(pipe, data, 1),
-            WakeMethod::Send => libc::send(pipe, data, 1, MSG_NOWAIT),
+            WakeMethod::Write => libc::write(pipe.as_raw_fd(), data, 1),
+            WakeMethod::Send => libc::send(pipe.as_raw_fd(), data, 1, MSG_NOWAIT),
         };
     }
 }
@@ -175,8 +177,8 @@ pub(crate) fn wake(pipe: RawFd, method: WakeMethod) {
 ///   on the socket type, this might wake the read end with an empty message).
 /// * If it is not possible, the [`O_NONBLOCK`][libc::O_NONBLOCK] will be set on the file
 ///   descriptor and [`write`][libc::write] will be used instead.
-pub fn register_raw(signal: c_int, pipe: RawFd) -> Result<SigId, Error> {
-    let res = unsafe { libc::send(pipe, &[] as *const _, 0, MSG_NOWAIT) };
+pub fn register_raw(signal: c_int, pipe: OwnedFd) -> Result<SigId, Error> {
+    let res = unsafe { libc::send(pipe.as_raw_fd(), &[] as *const _, 0, MSG_NOWAIT) };
     let fd = match (res, Error::last_os_error().kind()) {
         (0, _) | (-1, ErrorKind::WouldBlock) => WakeFd {
             fd: pipe,
@@ -205,14 +207,15 @@ pub fn register_raw(signal: c_int, pipe: RawFd) -> Result<SigId, Error> {
 /// See [`register_raw`] for further details.
 pub fn register<P>(signal: c_int, pipe: P) -> Result<SigId, Error>
 where
-    P: IntoRawFd + 'static,
+    P: Into<OwnedFd> + 'static,
 {
-    register_raw(signal, pipe.into_raw_fd())
+    register_raw(signal, pipe.into())
 }
 
 #[cfg(test)]
 mod tests {
     use std::io::Read;
+    use std::os::fd::FromRawFd;
     use std::os::unix::net::{UnixDatagram, UnixStream};
 
     use super::*;
@@ -256,7 +259,7 @@ mod tests {
     fn register_with_pipe() -> Result<(), Error> {
         let mut fds = [0; 2];
         unsafe { assert_eq!(0, libc::pipe(fds.as_mut_ptr())) };
-        register_raw(libc::SIGUSR1, fds[1])?;
+        register_raw(libc::SIGUSR1, unsafe { OwnedFd::from_raw_fd(fds[1]) })?;
         wakeup();
         let mut buff = [0; 1];
         unsafe { assert_eq!(1, libc::read(fds[0], buff.as_mut_ptr() as *mut _, 1)) }
diff --git a/tests/iterator.rs b/tests/iterator.rs
@@ -22,13 +22,13 @@ fn send_sigusr2() {
 }
 
 fn setup_without_any_signals() -> (Signals, Handle) {
-    let signals = Signals::new(&[]).unwrap();
+    let signals = Signals::new(&[] as &[i32]).unwrap();
     let controller = signals.handle();
     (signals, controller)
 }
 
 fn setup_for_sigusr2() -> (Signals, Handle) {
-    let signals = Signals::new(&[SIGUSR2]).unwrap();
+    let signals = Signals::new([SIGUSR2]).unwrap();
     let controller = signals.handle();
     (signals, controller)
 }
@@ -84,7 +84,7 @@ fn forever_terminates_when_closed() {
 fn signals_block_wait() {
     let _lock = serial_test::lock();
 
-    let mut signals = Signals::new(&[SIGUSR2]).unwrap();
+    let mut signals = Signals::new([SIGUSR2]).unwrap();
     let (s, r) = mpsc::channel();
     let finish = Arc::new(AtomicBool::new(false));
     let thread_id = thread::spawn({
diff --git a/tests/shutdown.rs b/tests/shutdown.rs
@@ -73,7 +73,7 @@ fn cleanup_inside_signal() {
 #[test]
 fn cleanup_after_signal() {
     fn hook() {
-        let mut signals = signal_hook::iterator::Signals::new(&[libc::SIGTERM]).unwrap();
+        let mut signals = signal_hook::iterator::Signals::new([libc::SIGTERM]).unwrap();
         assert_eq!(Some(SIGTERM), signals.into_iter().next());
         flag::register_conditional_shutdown(SIGTERM, 0, Arc::new(AtomicBool::new(true))).unwrap();
     }

Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ impl<E: Exfiltrator> SignalsInfo<E> {`
`92`	`92`	`S: Borrow<c_int>,`
`93`	`93`	`{`
`94`	`94`	`let (read, write) = Async::<UnixStream>::pair()?;`
`95`		`- let inner = SignalDelivery::with_pipe(read, write, exfiltrator, signals)?;`
	`95`	`+ let inner = SignalDelivery::with_pipe(read, write.into_inner()?, exfiltrator, signals)?;`
`96`	`96`	`Ok(Self(OwningSignalIterator::new(inner)))`
`97`	`97`	`}`
`98`	`98`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ impl<E: Exfiltrator> SignalsInfo<E> {`
`110`	`110`	`S: Borrow<c_int>,`
`111`	`111`	`{`
`112`	`112`	`let (read, write) = UnixStream::pair()?;`
`113`		`- let inner = SignalDelivery::with_pipe(read, write, exfiltrator, signals)?;`
	`113`	`+ let inner = SignalDelivery::with_pipe(read, write.into_std()?, exfiltrator, signals)?;`
`114`	`114`	`Ok(Self(OwningSignalIterator::new(inner)))`
`115`	`115`	`}`
`116`	`116`