Use safe-io

A6GibKm · A6GibKm · commit f5849f103721 · 2024-06-02T16:45:34.000+02:00
For the from_owned_fd it might make sense to implement From or replace
the unsafe from_fd/take_fd methods.
diff --git a/gio/src/desktop_app_info.rs b/gio/src/desktop_app_info.rs
@@ -3,7 +3,7 @@
 #[cfg(all(unix, feature = "v2_58"))]
 use std::boxed::Box as Box_;
 #[cfg(all(unix, feature = "v2_58"))]
-use std::os::unix::io::AsRawFd;
+use std::os::unix::io::{AsFd, AsRawFd};
 #[cfg(all(unix, feature = "v2_58"))]
 use std::ptr;
 
@@ -54,21 +54,16 @@ mod sealed {
 pub trait DesktopAppInfoExtManual: sealed::Sealed + IsA<DesktopAppInfo> {
     #[cfg_attr(docsrs, doc(cfg(all(feature = "v2_58", unix))))]
     #[doc(alias = "g_desktop_app_info_launch_uris_as_manager_with_fds")]
-    fn launch_uris_as_manager_with_fds<
-        P: IsA<AppLaunchContext>,
-        T: AsRawFd,
-        U: AsRawFd,
-        V: AsRawFd,
-    >(
+    fn launch_uris_as_manager_with_fds<P: IsA<AppLaunchContext>>(
         &self,
         uris: &[&str],
         launch_context: Option<&P>,
         spawn_flags: glib::SpawnFlags,
         user_setup: Option<Box_<dyn FnOnce() + 'static>>,
         pid_callback: Option<&mut dyn (FnMut(&DesktopAppInfo, glib::Pid))>,
-        stdin_fd: &mut T,
-        stdout_fd: &mut U,
-        stderr_fd: &mut V,
+        stdin_fd: Option<impl AsFd>,
+        stdout_fd: Option<impl AsFd>,
+        stderr_fd: Option<impl AsFd>,
     ) -> Result<(), Error> {
         let user_setup_data: Box_<Option<Box_<dyn FnOnce() + 'static>>> = Box_::new(user_setup);
         unsafe extern "C" fn user_setup_func(user_data: glib::ffi::gpointer) {
@@ -105,6 +100,10 @@ pub trait DesktopAppInfoExtManual: sealed::Sealed + IsA<DesktopAppInfo> {
         let super_callback0: Box_<Option<Box_<dyn FnOnce() + 'static>>> = user_setup_data;
         let super_callback1: &Option<&mut dyn (FnMut(&DesktopAppInfo, glib::Pid))> =
             &pid_callback_data;
+
+        let stdin_raw_fd = stdin_fd.map_or(-1, |fd| fd.as_fd().as_raw_fd());
+        let stdout_raw_fd = stdout_fd.map_or(-1, |fd| fd.as_fd().as_raw_fd());
+        let stderr_raw_fd = stderr_fd.map_or(-1, |fd| fd.as_fd().as_raw_fd());
         unsafe {
             let mut error = ptr::null_mut();
             let _ = ffi::g_desktop_app_info_launch_uris_as_manager_with_fds(
@@ -116,9 +115,9 @@ pub trait DesktopAppInfoExtManual: sealed::Sealed + IsA<DesktopAppInfo> {
                 Box_::into_raw(super_callback0) as *mut _,
                 pid_callback,
                 super_callback1 as *const _ as *mut _,
-                stdin_fd.as_raw_fd(),
-                stdout_fd.as_raw_fd(),
-                stderr_fd.as_raw_fd(),
+                stdin_raw_fd,
+                stdout_raw_fd,
+                stderr_raw_fd,
                 &mut error,
             );
             if error.is_null() {
diff --git a/gio/src/socket.rs b/gio/src/socket.rs
@@ -1,7 +1,7 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
 #[cfg(unix)]
-use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
 #[cfg(windows)]
 use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket};
 #[cfg(feature = "v2_60")]
@@ -19,14 +19,16 @@ impl Socket {
     #[cfg(unix)]
     #[cfg_attr(docsrs, doc(cfg(unix)))]
     #[allow(clippy::missing_safety_doc)]
-    pub unsafe fn from_fd(fd: impl IntoRawFd) -> Result<Socket, glib::Error> {
+    pub fn from_fd(fd: OwnedFd) -> Result<Socket, glib::Error> {
         let fd = fd.into_raw_fd();
         let mut error = ptr::null_mut();
-        let ret = ffi::g_socket_new_from_fd(fd, &mut error);
-        if error.is_null() {
-            Ok(from_glib_full(ret))
-        } else {
-            Err(from_glib_full(error))
+        unsafe {
+            let ret = ffi::g_socket_new_from_fd(fd, &mut error);
+            if error.is_null() {
+                Ok(from_glib_full(ret))
+            } else {
+                Err(from_glib_full(error))
+            }
         }
     }
     #[cfg(windows)]
diff --git a/gio/src/unix_input_stream.rs b/gio/src/unix_input_stream.rs
@@ -1,7 +1,7 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
 #[cfg(unix)]
-use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
+use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
 
 use glib::{prelude::*, translate::*};
 #[cfg(all(not(unix), docsrs))]
@@ -12,16 +12,13 @@ use crate::{ffi, InputStream, UnixInputStream};
 impl UnixInputStream {
     // rustdoc-stripper-ignore-next
     /// Creates a new [`Self`] that takes ownership of the passed in fd.
-    ///
-    /// # Safety
-    /// You must not close the fd unless you've previously called [`UnixInputStreamExtManual::set_close_fd`]
-    /// with `true` on this stream. At which point you may only do so when all references to this
-    /// stream have been dropped.
     #[doc(alias = "g_unix_input_stream_new")]
-    pub unsafe fn take_fd(fd: impl IntoRawFd) -> UnixInputStream {
+    pub fn take_fd(fd: OwnedFd) -> UnixInputStream {
         let fd = fd.into_raw_fd();
         let close_fd = true.into_glib();
-        InputStream::from_glib_full(ffi::g_unix_input_stream_new(fd, close_fd)).unsafe_cast()
+        unsafe {
+            InputStream::from_glib_full(ffi::g_unix_input_stream_new(fd, close_fd)).unsafe_cast()
+        }
     }
 
     // rustdoc-stripper-ignore-next
diff --git a/gio/src/unix_output_stream.rs b/gio/src/unix_output_stream.rs
@@ -1,7 +1,7 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
 #[cfg(unix)]
-use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
+use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
 
 use glib::{prelude::*, translate::*};
 #[cfg(all(not(unix), docsrs))]
@@ -12,16 +12,13 @@ use crate::{ffi, OutputStream, UnixOutputStream};
 impl UnixOutputStream {
     // rustdoc-stripper-ignore-next
     /// Creates a new [`Self`] that takes ownership of the passed in fd.
-    ///
-    /// # Safety
-    /// You must not close the fd unless you've previously called [`UnixOutputStreamExtManual::set_close_fd`]
-    /// on this stream. At which point you may only do so when all references to this stream have
-    /// been dropped.
     #[doc(alias = "g_unix_output_stream_new")]
-    pub unsafe fn take_fd(fd: impl IntoRawFd) -> UnixOutputStream {
+    pub fn take_fd(fd: OwnedFd) -> UnixOutputStream {
         let fd = fd.into_raw_fd();
         let close_fd = true.into_glib();
-        OutputStream::from_glib_full(ffi::g_unix_output_stream_new(fd, close_fd)).unsafe_cast()
+        unsafe {
+            OutputStream::from_glib_full(ffi::g_unix_output_stream_new(fd, close_fd)).unsafe_cast()
+        }
     }
 
     // rustdoc-stripper-ignore-next
diff --git a/glib/src/functions.rs b/glib/src/functions.rs
@@ -7,7 +7,7 @@ use std::boxed::Box as Box_;
 use std::mem;
 #[cfg(not(windows))]
 #[cfg(feature = "v2_58")]
-use std::os::unix::io::AsRawFd;
+use std::os::unix::io::{AsFd, AsRawFd};
 #[cfg(not(windows))]
 use std::os::unix::io::{FromRawFd, IntoRawFd, RawFd};
 use std::ptr;
@@ -24,15 +24,15 @@ use crate::{Error, Pid, SpawnFlags};
 #[cfg_attr(docsrs, doc(cfg(all(feature = "v2_58", not(windows)))))]
 #[allow(clippy::too_many_arguments)]
 #[doc(alias = "g_spawn_async_with_fds")]
-pub fn spawn_async_with_fds<P: AsRef<std::path::Path>, T: AsRawFd, U: AsRawFd, V: AsRawFd>(
+pub fn spawn_async_with_fds<P: AsRef<std::path::Path>>(
     working_directory: P,
     argv: &[&str],
     envp: &[&str],
     flags: SpawnFlags,
     child_setup: Option<Box_<dyn FnOnce() + 'static>>,
-    stdin_fd: T,
-    stdout_fd: U,
-    stderr_fd: V,
+    stdin_fd: Option<impl AsFd>,
+    stdout_fd: Option<impl AsFd>,
+    stderr_fd: Option<impl AsFd>,
 ) -> Result<Pid, Error> {
     let child_setup_data: Box_<Option<Box_<dyn FnOnce() + 'static>>> = Box_::new(child_setup);
     unsafe extern "C" fn child_setup_func(user_data: ffi::gpointer) {
@@ -47,6 +47,9 @@ pub fn spawn_async_with_fds<P: AsRef<std::path::Path>, T: AsRawFd, U: AsRawFd, V
         None
     };
     let super_callback0: Box_<Option<Box_<dyn FnOnce() + 'static>>> = child_setup_data;
+    let stdin_raw_fd = stdin_fd.map_or(-1, |fd| fd.as_fd().as_raw_fd());
+    let stdout_raw_fd = stdout_fd.map_or(-1, |fd| fd.as_fd().as_raw_fd());
+    let stderr_raw_fd = stderr_fd.map_or(-1, |fd| fd.as_fd().as_raw_fd());
     unsafe {
         let mut child_pid = mem::MaybeUninit::uninit();
         let mut error = ptr::null_mut();
@@ -58,9 +61,9 @@ pub fn spawn_async_with_fds<P: AsRef<std::path::Path>, T: AsRawFd, U: AsRawFd, V
             child_setup,
             Box_::into_raw(super_callback0) as *mut _,
             child_pid.as_mut_ptr(),
-            stdin_fd.as_raw_fd(),
-            stdout_fd.as_raw_fd(),
-            stderr_fd.as_raw_fd(),
+            stdin_raw_fd,
+            stdout_raw_fd,
+            stderr_raw_fd,
             &mut error,
         );
         let child_pid = from_glib(child_pid.assume_init());
diff --git a/glib/src/log.rs b/glib/src/log.rs
@@ -1,7 +1,7 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
 #[cfg(unix)]
-use std::os::unix::io::AsRawFd;
+use std::os::unix::io::{AsFd, AsRawFd};
 use std::{
     boxed::Box as Box_,
     sync::{Arc, Mutex, OnceLock},
@@ -972,16 +972,20 @@ pub fn log_variant(log_domain: Option<&str>, log_level: LogLevel, fields: &crate
 #[cfg_attr(docsrs, doc(cfg(unix)))]
 #[doc(alias = "g_log_writer_supports_color")]
 #[inline]
-pub fn log_writer_supports_color<T: AsRawFd>(output_fd: T) -> bool {
-    unsafe { from_glib(ffi::g_log_writer_supports_color(output_fd.as_raw_fd())) }
+pub fn log_writer_supports_color(output_fd: impl AsFd) -> bool {
+    unsafe {
+        from_glib(ffi::g_log_writer_supports_color(
+            output_fd.as_fd().as_raw_fd(),
+        ))
+    }
 }
 
 #[cfg(unix)]
 #[cfg_attr(docsrs, doc(cfg(unix)))]
 #[doc(alias = "g_log_writer_is_journald")]
 #[inline]
-pub fn log_writer_is_journald<T: AsRawFd>(output_fd: T) -> bool {
-    unsafe { from_glib(ffi::g_log_writer_is_journald(output_fd.as_raw_fd())) }
+pub fn log_writer_is_journald(output_fd: impl AsFd) -> bool {
+    unsafe { from_glib(ffi::g_log_writer_is_journald(output_fd.as_fd().as_raw_fd())) }
 }
 
 #[doc(alias = "g_log_writer_format_fields")]
