Remove is_read_write from rustix. (#1279)

Remove `is_read_write` and `is_file_read_write` from rustix. These are
higher-level functionality that can be implemented on top of rustix.

Author: sunfishcode

src/backend/libc/io/syscalls.rs

@@ -18,8 +18,6 @@ use crate::io::ReadWriteFlags;
 use crate::io::{self, FdFlags};
 use crate::ioctl::{IoctlOutput, RawOpcode};
 use core::cmp::min;
-#[cfg(all(feature = "fs", feature = "net"))]
-use libc_errno::errno;
 #[cfg(not(any(target_os = "espidf", target_os = "horizon")))]
 use {
     crate::backend::MAX_IOV,
@@ -224,60 +222,6 @@ pub(crate) unsafe fn ioctl_readonly(
     ioctl(fd, request, arg)
 }
 
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-#[cfg(all(feature = "fs", feature = "net"))]
-pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
-    use core::mem::MaybeUninit;
-
-    let (mut read, mut write) = crate::fs::fd::_is_file_read_write(fd)?;
-    let mut not_socket = false;
-    if read {
-        // Do a `recv` with `PEEK` and `DONTWAIT` for 1 byte. A 0 indicates
-        // the read side is shut down; an `EWOULDBLOCK` indicates the read
-        // side is still open.
-        match unsafe {
-            c::recv(
-                borrowed_fd(fd),
-                MaybeUninit::<[u8; 1]>::uninit()
-                    .as_mut_ptr()
-                    .cast::<c::c_void>(),
-                1,
-                c::MSG_PEEK | c::MSG_DONTWAIT,
-            )
-        } {
-            0 => read = false,
-            -1 => {
-                #[allow(unreachable_patterns)] // `EAGAIN` may equal `EWOULDBLOCK`
-                match errno().0 {
-                    c::EAGAIN | c::EWOULDBLOCK => (),
-                    c::ENOTSOCK => not_socket = true,
-                    err => return Err(io::Errno(err)),
-                }
-            }
-            _ => (),
-        }
-    }
-    if write && !not_socket {
-        // Do a `send` with `DONTWAIT` for 0 bytes. An `EPIPE` indicates
-        // the write side is shut down.
-        if unsafe { c::send(borrowed_fd(fd), [].as_ptr(), 0, c::MSG_DONTWAIT) } == -1 {
-            #[allow(unreachable_patterns)] // `EAGAIN` may equal `EWOULDBLOCK`
-            match errno().0 {
-                c::EAGAIN | c::EWOULDBLOCK | c::ENOTSOCK => (),
-                c::EPIPE => write = false,
-                err => return Err(io::Errno(err)),
-            }
-        }
-    }
-    Ok((read, write))
-}
-
-#[cfg(target_os = "wasi")]
-#[cfg(all(feature = "fs", feature = "net"))]
-pub(crate) fn is_read_write(_fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
-    todo!("Implement is_read_write for WASI in terms of fd_fdstat_get");
-}
-
 pub(crate) fn fcntl_getfd(fd: BorrowedFd<'_>) -> io::Result<FdFlags> {
     let flags = unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GETFD))? };
     Ok(FdFlags::from_bits_retain(bitcast!(flags)))

src/backend/linux_raw/io/syscalls.rs

@@ -23,8 +23,6 @@ use crate::backend::{c, MAX_IOV};
 use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
 use crate::io::{self, DupFlags, FdFlags, IoSlice, IoSliceMut, ReadWriteFlags};
 use crate::ioctl::{IoctlOutput, RawOpcode};
-#[cfg(all(feature = "fs", feature = "net"))]
-use crate::net::{RecvFlags, SendFlags};
 use core::cmp;
 use linux_raw_sys::general::{F_DUPFD_CLOEXEC, F_GETFD, F_SETFD};
 
@@ -265,49 +263,6 @@ pub(crate) unsafe fn ioctl_readonly(
     ret_c_int(syscall_readonly!(__NR_ioctl, fd, c_uint(request), arg))
 }
 
-#[cfg(all(feature = "fs", feature = "net"))]
-pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
-    let (mut read, mut write) = crate::fs::fd::_is_file_read_write(fd)?;
-    let mut not_socket = false;
-    if read {
-        // Do a `recv` with `PEEK` and `DONTWAIT` for 1 byte. A 0 indicates
-        // the read side is shut down; an `EWOULDBLOCK` indicates the read
-        // side is still open.
-        let mut buf = [core::mem::MaybeUninit::<u8>::uninit()];
-        match unsafe {
-            crate::backend::net::syscalls::recv(
-                fd,
-                buf.as_mut_ptr().cast::<u8>(),
-                1,
-                RecvFlags::PEEK | RecvFlags::DONTWAIT,
-            )
-        } {
-            Ok(0) => read = false,
-            Err(err) => {
-                #[allow(unreachable_patterns)] // `EAGAIN` may equal `EWOULDBLOCK`
-                match err {
-                    io::Errno::AGAIN | io::Errno::WOULDBLOCK => (),
-                    io::Errno::NOTSOCK => not_socket = true,
-                    _ => return Err(err),
-                }
-            }
-            Ok(_) => (),
-        }
-    }
-    if write && !not_socket {
-        // Do a `send` with `DONTWAIT` for 0 bytes. An `EPIPE` indicates
-        // the write side is shut down.
-        #[allow(unreachable_patterns)] // `EAGAIN` equals `EWOULDBLOCK`
-        match crate::backend::net::syscalls::send(fd, &[], SendFlags::DONTWAIT) {
-            Err(io::Errno::AGAIN | io::Errno::WOULDBLOCK | io::Errno::NOTSOCK) => (),
-            Err(io::Errno::PIPE) => write = false,
-            Err(err) => return Err(err),
-            Ok(_) => (),
-        }
-    }
-    Ok((read, write))
-}
-
 #[inline]
 pub(crate) fn dup(fd: BorrowedFd<'_>) -> io::Result<OwnedFd> {
     unsafe { ret_owned_fd(syscall_readonly!(__NR_dup, fd)) }

src/fs/fd.rs

@@ -4,9 +4,9 @@
 use crate::fs::Mode;
 #[cfg(not(target_os = "wasi"))]
 use crate::fs::{Gid, Uid};
-use crate::fs::{OFlags, SeekFrom, Timespec};
+use crate::fs::{SeekFrom, Timespec};
 use crate::{backend, io};
-use backend::fd::{AsFd, BorrowedFd};
+use backend::fd::AsFd;
 #[cfg(not(any(
     netbsdlike,
     target_os = "dragonfly",
@@ -127,6 +127,7 @@ pub fn tell<Fd: AsFd>(fd: Fd) -> io::Result<u64> {
 ///
 /// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fchmod.html
 /// [Linux]: https://man7.org/linux/man-pages/man2/fchmod.2.html
+/// [`OFlags::PATH`]: crate::fs::OFlags::PATH
 #[cfg(not(target_os = "wasi"))]
 #[inline]
 pub fn fchmod<Fd: AsFd>(fd: Fd, mode: Mode) -> io::Result<()> {
@@ -252,36 +253,6 @@ pub fn fallocate<Fd: AsFd>(fd: Fd, mode: FallocateFlags, offset: u64, len: u64)
     backend::fs::syscalls::fallocate(fd.as_fd(), mode, offset, len)
 }
 
-/// `fcntl(fd, F_GETFL) & O_ACCMODE`
-///
-/// Returns a pair of booleans indicating whether the file descriptor is
-/// readable and/or writable, respectively. This is only reliable on files; for
-/// example, it doesn't reflect whether sockets have been shut down; for
-/// general I/O handle support, use [`io::is_read_write`].
-#[inline]
-pub fn is_file_read_write<Fd: AsFd>(fd: Fd) -> io::Result<(bool, bool)> {
-    _is_file_read_write(fd.as_fd())
-}
-
-pub(crate) fn _is_file_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
-    let mode = backend::fs::syscalls::fcntl_getfl(fd)?;
-
-    // Check for `O_PATH`.
-    #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
-    if mode.contains(OFlags::PATH) {
-        return Ok((false, false));
-    }
-
-    // Use `RWMODE` rather than `ACCMODE` as `ACCMODE` may include `O_PATH`.
-    // We handled `O_PATH` above.
-    match mode & OFlags::RWMODE {
-        OFlags::RDONLY => Ok((true, false)),
-        OFlags::RDWR => Ok((true, true)),
-        OFlags::WRONLY => Ok((false, true)),
-        _ => unreachable!(),
-    }
-}
-
 /// `fsync(fd)`—Ensures that file data and metadata is written to the
 /// underlying storage device.
 ///

src/io/is_read_write.rs

@@ -12,9 +12,6 @@ mod errno;
 #[cfg(not(windows))]
 mod fcntl;
 mod ioctl;
-#[cfg(not(any(windows, target_os = "redox")))]
-#[cfg(all(feature = "fs", feature = "net"))]
-mod is_read_write;
 #[cfg(not(windows))]
 mod read_write;
 
@@ -25,8 +22,5 @@ pub use errno::{retry_on_intr, Errno, Result};
 #[cfg(not(windows))]
 pub use fcntl::*;
 pub use ioctl::*;
-#[cfg(not(any(windows, target_os = "redox")))]
-#[cfg(all(feature = "fs", feature = "net"))]
-pub use is_read_write::*;
 #[cfg(not(windows))]
 pub use read_write::*;

src/io/mod.rs

@@ -148,9 +148,6 @@ fn test_file() {
         assert!(statvfs.f_frsize > 0);
     }
 
-    #[cfg(all(feature = "fs", feature = "net"))]
-    assert_eq!(rustix::io::is_read_write(&file).unwrap(), (true, false));
-
     assert_ne!(rustix::io::ioctl_fionread(&file).unwrap(), 0);
 }
 

tests/fs/file.rs

@@ -1,13 +1,9 @@
-// `is_read_write` is not yet implemented on Windows. And `ioctl_fionread`
-// on Windows doesn't work on files.
+// `ioctl_fionread` on Windows doesn't work on files.
 #[cfg(not(windows))]
 #[test]
 fn test_ioctls() {
     let file = std::fs::File::open("Cargo.toml").unwrap();
 
-    #[cfg(all(feature = "fs", feature = "net"))]
-    assert_eq!(rustix::io::is_read_write(&file).unwrap(), (true, false));
-
     assert_eq!(
         rustix::io::ioctl_fionread(&file).unwrap(),
         file.metadata().unwrap().len()