Introduce strongly-typed system primitives (#1561)

* Introduce strongly-typed system primitives

This commit does a lot of reshuffling and even some more. It introduces
strongly-typed system primitives which are: `OsFile`, `OsDir`, `Stdio`,
and `OsOther`. Those primitives are separate structs now, each implementing
a subset of `Handle` methods, rather than all being an enumeration of some
supertype such as `OsHandle`. To summarise the structs:

* `OsFile` represents a regular file, and implements fd-ops
  of `Handle` trait
* `OsDir` represents a directory, and primarily implements path-ops, plus
  `readdir` and some common fd-ops such as `fdstat`, etc.
* `Stdio` represents a stdio handle, and implements a subset of fd-ops
  such as `fdstat` _and_ `read_` and `write_vectored` calls
* `OsOther` currently represents anything else and implements a set similar
  to that implemented by `Stdio`

This commit is effectively an experiment and an excercise into better
understanding what's going on for each OS resource/type under-the-hood.
It's meant to give us some intuition in order to move on with the idea
of having strongly-typed handles in WASI both in the syscall impl as well
as at the libc level.

Some more minor changes include making `OsHandle` represent an OS-specific
wrapper for a raw OS handle (Unix fd or Windows handle). Also, since `OsDir`
is tricky across OSes, we also have a supertype of `OsHandle` called
`OsDirHandle` which may store a `DIR*` stream pointer (mainly BSD). Last but not
least, the `Filetype` and `Rights` are now computed when the resource is created,
rather than every time we call `Handle::get_file_type` and `Handle::get_rights`.
Finally, in order to facilitate the latter, I've converted `EntryRights` into
`HandleRights` and pushed them into each `Handle` implementor.

* Do not adjust rights on Stdio

* Clean up testing for TTY and escaping writes

* Implement AsFile for dyn Handle

This cleans up a lot of repeating boilerplate code todo with
dynamic dispatch.

* Delegate definition of OsDir to OS-specific modules

Delegates defining `OsDir` struct to OS-specific modules (BSD, Linux,
Emscripten, Windows). This way, `OsDir` can safely re-use `OsHandle`
for raw OS handle storage, and can store some aux data such as an
initialized stream ptr in case of BSD. As a result, we can safely
get rid of `OsDirHandle` which IMHO was causing unnecessary noise and
overcomplicating the design. On the other hand, delegating definition
of `OsDir` to OS-specific modules isn't super clean in and of itself
either. Perhaps there's a better way of handling this?

* Check if filetype of OS handle matches WASI filetype when creating

It seems prudent to check if the passed in `File` instance is of
type matching that of the requested WASI filetype. In other words,
we'd like to avoid situations where `OsFile` is created from a
pipe.

* Make AsFile fallible

Return `EBADF` in `AsFile` in case a `Handle` cannot be made into
a `std::fs::File`.

* Remove unnecessary as_file conversion

* Remove unnecessary check for TTY for Stdio handle type

* Fix incorrect stdio ctors on Unix

* Split Stdio into three separate types: Stdin, Stdout, Stderr

* Rename PendingEntry::File to PendingEntry::OsHandle to avoid confusion

* Rename OsHandle to RawOsHandle

Also, since `RawOsHandle` on *nix doesn't need interior mutability
wrt the inner raw file descriptor, we can safely swap the `RawFd`
for `File` instance.

* Add docs explaining what OsOther is

* Allow for stdio to be non-character-device (e.g., piped)

* Return error on bad preopen rather than panic

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

@@ -1,8 +1,12 @@
 pub(crate) mod clock;
 pub(crate) mod fd;
+pub(crate) mod osdir;
+pub(crate) mod osfile;
 pub(crate) mod oshandle;
+pub(crate) mod osother;
 pub(crate) mod path;
 pub(crate) mod poll;
+pub(crate) mod stdio;
 
 cfg_if::cfg_if! {
     if #[cfg(target_os = "linux")] {
@@ -22,16 +26,105 @@ cfg_if::cfg_if! {
     }
 }
 
-use crate::wasi::{types, Errno, Result};
+use crate::handle::HandleRights;
+use crate::sys::AsFile;
+use crate::wasi::{types, Errno, Result, RightsExt};
 use std::convert::{TryFrom, TryInto};
 use std::fs::File;
 use std::io;
+use std::mem::ManuallyDrop;
+use std::os::unix::prelude::{AsRawFd, FileTypeExt, FromRawFd};
 use std::path::Path;
 use yanix::clock::ClockId;
 use yanix::file::{AtFlag, OFlag};
 
 pub(crate) use sys_impl::*;
 
+impl<T: AsRawFd> AsFile for T {
+    fn as_file(&self) -> io::Result<ManuallyDrop<File>> {
+        let file = unsafe { File::from_raw_fd(self.as_raw_fd()) };
+        Ok(ManuallyDrop::new(file))
+    }
+}
+
+pub(super) fn get_file_type(file: &File) -> io::Result<types::Filetype> {
+    let ft = file.metadata()?.file_type();
+    let file_type = if ft.is_block_device() {
+        log::debug!("Host fd {:?} is a block device", file.as_raw_fd());
+        types::Filetype::BlockDevice
+    } else if ft.is_char_device() {
+        log::debug!("Host fd {:?} is a char device", file.as_raw_fd());
+        types::Filetype::CharacterDevice
+    } else if ft.is_dir() {
+        log::debug!("Host fd {:?} is a directory", file.as_raw_fd());
+        types::Filetype::Directory
+    } else if ft.is_file() {
+        log::debug!("Host fd {:?} is a file", file.as_raw_fd());
+        types::Filetype::RegularFile
+    } else if ft.is_socket() {
+        log::debug!("Host fd {:?} is a socket", file.as_raw_fd());
+        use yanix::socket::{get_socket_type, SockType};
+        match unsafe { get_socket_type(file.as_raw_fd())? } {
+            SockType::Datagram => types::Filetype::SocketDgram,
+            SockType::Stream => types::Filetype::SocketStream,
+            _ => return Err(io::Error::from_raw_os_error(libc::EINVAL)),
+        }
+    } else if ft.is_fifo() {
+        log::debug!("Host fd {:?} is a fifo", file.as_raw_fd());
+        types::Filetype::Unknown
+    } else {
+        log::debug!("Host fd {:?} is unknown", file.as_raw_fd());
+        return Err(io::Error::from_raw_os_error(libc::EINVAL));
+    };
+    Ok(file_type)
+}
+
+pub(super) fn get_rights(file: &File, file_type: &types::Filetype) -> io::Result<HandleRights> {
+    use yanix::{fcntl, file::OFlag};
+    let (base, inheriting) = match file_type {
+        types::Filetype::BlockDevice => (
+            types::Rights::block_device_base(),
+            types::Rights::block_device_inheriting(),
+        ),
+        types::Filetype::CharacterDevice => {
+            use yanix::file::isatty;
+            if unsafe { isatty(file.as_raw_fd())? } {
+                (types::Rights::tty_base(), types::Rights::tty_base())
+            } else {
+                (
+                    types::Rights::character_device_base(),
+                    types::Rights::character_device_inheriting(),
+                )
+            }
+        }
+        types::Filetype::SocketDgram | types::Filetype::SocketStream => (
+            types::Rights::socket_base(),
+            types::Rights::socket_inheriting(),
+        ),
+        types::Filetype::SymbolicLink | types::Filetype::Unknown => (
+            types::Rights::regular_file_base(),
+            types::Rights::regular_file_inheriting(),
+        ),
+        types::Filetype::Directory => (
+            types::Rights::directory_base(),
+            types::Rights::directory_inheriting(),
+        ),
+        types::Filetype::RegularFile => (
+            types::Rights::regular_file_base(),
+            types::Rights::regular_file_inheriting(),
+        ),
+    };
+    let mut rights = HandleRights::new(base, inheriting);
+    let flags = unsafe { fcntl::get_status_flags(file.as_raw_fd())? };
+    let accmode = flags & OFlag::ACCMODE;
+    if accmode == OFlag::RDONLY {
+        rights.base &= !types::Rights::FD_WRITE;
+    } else if accmode == OFlag::WRONLY {
+        rights.base &= !types::Rights::FD_READ;
+    }
+    Ok(rights)
+}
+
 pub fn preopen_dir<P: AsRef<Path>>(path: P) -> io::Result<File> {
     File::open(path)
 }