Initial reorg.

This is largely the same as #305, but updated for the current tree.

crates/wasi-common/src/sys/unix/fdentry_impl.rs

@@ -0,0 +1,135 @@
+use crate::fdentry::Descriptor;
+use crate::{wasi, Error, Result};
+use std::io;
+use std::os::unix::prelude::{AsRawFd, FileTypeExt, FromRawFd, RawFd};
+
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "linux")] {
+        pub(crate) use super::linux::osfile::*;
+        pub(crate) use super::linux::fdentry_impl::*;
+    } else if #[cfg(any(
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "freebsd",
+            target_os = "openbsd",
+            target_os = "ios",
+            target_os = "dragonfly"
+    ))] {
+        pub(crate) use super::bsd::osfile::*;
+        pub(crate) use super::bsd::fdentry_impl::*;
+    }
+}
+
+impl AsRawFd for Descriptor {
+    fn as_raw_fd(&self) -> RawFd {
+        match self {
+            Self::OsFile(file) => file.as_raw_fd(),
+            Self::Stdin => io::stdin().as_raw_fd(),
+            Self::Stdout => io::stdout().as_raw_fd(),
+            Self::Stderr => io::stderr().as_raw_fd(),
+        }
+    }
+}
+
+/// This function is unsafe because it operates on a raw file descriptor.
+pub(crate) unsafe fn determine_type_and_access_rights<Fd: AsRawFd>(
+    fd: &Fd,
+) -> Result<(
+    wasi::__wasi_filetype_t,
+    wasi::__wasi_rights_t,
+    wasi::__wasi_rights_t,
+)> {
+    let (file_type, mut rights_base, rights_inheriting) = determine_type_rights(fd)?;
+
+    use nix::fcntl::{fcntl, OFlag, F_GETFL};
+    let flags_bits = fcntl(fd.as_raw_fd(), F_GETFL)?;
+    let flags = OFlag::from_bits_truncate(flags_bits);
+    let accmode = flags & OFlag::O_ACCMODE;
+    if accmode == OFlag::O_RDONLY {
+        rights_base &= !wasi::__WASI_RIGHT_FD_WRITE;
+    } else if accmode == OFlag::O_WRONLY {
+        rights_base &= !wasi::__WASI_RIGHT_FD_READ;
+    }
+
+    Ok((file_type, rights_base, rights_inheriting))
+}
+
+/// This function is unsafe because it operates on a raw file descriptor.
+pub(crate) unsafe fn determine_type_rights<Fd: AsRawFd>(
+    fd: &Fd,
+) -> Result<(
+    wasi::__wasi_filetype_t,
+    wasi::__wasi_rights_t,
+    wasi::__wasi_rights_t,
+)> {
+    let (file_type, rights_base, rights_inheriting) = {
+        // we just make a `File` here for convenience; we don't want it to close when it drops
+        let file = std::mem::ManuallyDrop::new(std::fs::File::from_raw_fd(fd.as_raw_fd()));
+        let ft = file.metadata()?.file_type();
+        if ft.is_block_device() {
+            log::debug!("Host fd {:?} is a block device", fd.as_raw_fd());
+            (
+                wasi::__WASI_FILETYPE_BLOCK_DEVICE,
+                wasi::RIGHTS_BLOCK_DEVICE_BASE,
+                wasi::RIGHTS_BLOCK_DEVICE_INHERITING,
+            )
+        } else if ft.is_char_device() {
+            log::debug!("Host fd {:?} is a char device", fd.as_raw_fd());
+            if isatty(fd)? {
+                (
+                    wasi::__WASI_FILETYPE_CHARACTER_DEVICE,
+                    wasi::RIGHTS_TTY_BASE,
+                    wasi::RIGHTS_TTY_BASE,
+                )
+            } else {
+                (
+                    wasi::__WASI_FILETYPE_CHARACTER_DEVICE,
+                    wasi::RIGHTS_CHARACTER_DEVICE_BASE,
+                    wasi::RIGHTS_CHARACTER_DEVICE_INHERITING,
+                )
+            }
+        } else if ft.is_dir() {
+            log::debug!("Host fd {:?} is a directory", fd.as_raw_fd());
+            (
+                wasi::__WASI_FILETYPE_DIRECTORY,
+                wasi::RIGHTS_DIRECTORY_BASE,
+                wasi::RIGHTS_DIRECTORY_INHERITING,
+            )
+        } else if ft.is_file() {
+            log::debug!("Host fd {:?} is a file", fd.as_raw_fd());
+            (
+                wasi::__WASI_FILETYPE_REGULAR_FILE,
+                wasi::RIGHTS_REGULAR_FILE_BASE,
+                wasi::RIGHTS_REGULAR_FILE_INHERITING,
+            )
+        } else if ft.is_socket() {
+            log::debug!("Host fd {:?} is a socket", fd.as_raw_fd());
+            use nix::sys::socket;
+            match socket::getsockopt(fd.as_raw_fd(), socket::sockopt::SockType)? {
+                socket::SockType::Datagram => (
+                    wasi::__WASI_FILETYPE_SOCKET_DGRAM,
+                    wasi::RIGHTS_SOCKET_BASE,
+                    wasi::RIGHTS_SOCKET_INHERITING,
+                ),
+                socket::SockType::Stream => (
+                    wasi::__WASI_FILETYPE_SOCKET_STREAM,
+                    wasi::RIGHTS_SOCKET_BASE,
+                    wasi::RIGHTS_SOCKET_INHERITING,
+                ),
+                _ => return Err(Error::EINVAL),
+            }
+        } else if ft.is_fifo() {
+            log::debug!("Host fd {:?} is a fifo", fd.as_raw_fd());
+            (
+                wasi::__WASI_FILETYPE_UNKNOWN,
+                wasi::RIGHTS_REGULAR_FILE_BASE,
+                wasi::RIGHTS_REGULAR_FILE_INHERITING,
+            )
+        } else {
+            log::debug!("Host fd {:?} is unknown", fd.as_raw_fd());
+            return Err(Error::EINVAL);
+        }
+    };
+
+    Ok((file_type, rights_base, rights_inheriting))
+}