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/stdio.rs

@@ -0,0 +1,176 @@
+// The reason we have a separate Stdio wrappers is to correctly facilitate redirects on Windows.
+// To elaborate further, in POSIX, we can get a stdio handle by opening a specific fd {0,1,2}.
+// On Windows however, we need to issue a syscall that's separate from standard Windows "open"
+// to get a console handle, and this is GetStdHandle. This is exactly what Rust does and what
+// is wrapped inside their Stdio object in the libstd. We wrap it here as well because of this
+// nuance on Windows:
+//
+//      The standard handles of a process may be redirected by a call to SetStdHandle, in which
+//      case GetStdHandle returns the redirected handle.
+//
+// The MSDN also says this however:
+//
+//      If the standard handles have been redirected, you can specify the CONIN$ value in a call
+//      to the CreateFile function to get a handle to a console's input buffer. Similarly, you
+//      can specify the CONOUT$ value to get a handle to a console's active screen buffer.
+//
+// TODO it might worth re-investigating the suitability of this type on Windows.
+
+use super::{fd, AsFile};
+use crate::handle::{Handle, HandleRights};
+use crate::sandboxed_tty_writer::SandboxedTTYWriter;
+use crate::wasi::types::{self, Filetype};
+use crate::wasi::Result;
+use std::any::Any;
+use std::cell::Cell;
+use std::io::{self, Read, Write};
+
+pub(crate) trait StdinExt: Sized {
+    /// Create `Stdin` from `io::stdin`.
+    fn stdin() -> io::Result<Box<dyn Handle>>;
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct Stdin {
+    pub(crate) file_type: Filetype,
+    pub(crate) rights: Cell<HandleRights>,
+}
+
+impl Handle for Stdin {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn try_clone(&self) -> io::Result<Box<dyn Handle>> {
+        Ok(Box::new(self.clone()))
+    }
+    fn get_file_type(&self) -> Filetype {
+        self.file_type
+    }
+    fn get_rights(&self) -> HandleRights {
+        self.rights.get()
+    }
+    fn set_rights(&self, new_rights: HandleRights) {
+        self.rights.set(new_rights)
+    }
+    // FdOps
+    fn fdstat_get(&self) -> Result<types::Fdflags> {
+        fd::fdstat_get(&*self.as_file()?)
+    }
+    fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
+        if let Some(_) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
+            // OK, this means we should somehow update the underlying os handle,
+            // and we can't do that with `std::io::std{in, out, err}`, so we'll
+            // panic for now.
+            panic!("Tried updating Fdflags on Stdio handle by re-opening as file!");
+        }
+        Ok(())
+    }
+    fn read_vectored(&self, iovs: &mut [io::IoSliceMut]) -> Result<usize> {
+        let nread = io::stdin().read_vectored(iovs)?;
+        Ok(nread)
+    }
+}
+
+pub(crate) trait StdoutExt: Sized {
+    /// Create `Stdout` from `io::stdout`.
+    fn stdout() -> io::Result<Box<dyn Handle>>;
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct Stdout {
+    pub(crate) file_type: Filetype,
+    pub(crate) rights: Cell<HandleRights>,
+}
+
+impl Handle for Stdout {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn try_clone(&self) -> io::Result<Box<dyn Handle>> {
+        Ok(Box::new(self.clone()))
+    }
+    fn get_file_type(&self) -> Filetype {
+        self.file_type
+    }
+    fn get_rights(&self) -> HandleRights {
+        self.rights.get()
+    }
+    fn set_rights(&self, new_rights: HandleRights) {
+        self.rights.set(new_rights)
+    }
+    // FdOps
+    fn fdstat_get(&self) -> Result<types::Fdflags> {
+        fd::fdstat_get(&*self.as_file()?)
+    }
+    fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
+        if let Some(_) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
+            // OK, this means we should somehow update the underlying os handle,
+            // and we can't do that with `std::io::std{in, out, err}`, so we'll
+            // panic for now.
+            panic!("Tried updating Fdflags on Stdio handle by re-opening as file!");
+        }
+        Ok(())
+    }
+    fn write_vectored(&self, iovs: &[io::IoSlice]) -> Result<usize> {
+        // lock for the duration of the scope
+        let stdout = io::stdout();
+        let mut stdout = stdout.lock();
+        let nwritten = if self.is_tty() {
+            SandboxedTTYWriter::new(&mut stdout).write_vectored(&iovs)?
+        } else {
+            stdout.write_vectored(iovs)?
+        };
+        stdout.flush()?;
+        Ok(nwritten)
+    }
+}
+
+pub(crate) trait StderrExt: Sized {
+    /// Create `Stderr` from `io::stderr`.
+    fn stderr() -> io::Result<Box<dyn Handle>>;
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct Stderr {
+    pub(crate) file_type: Filetype,
+    pub(crate) rights: Cell<HandleRights>,
+}
+
+impl Handle for Stderr {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn try_clone(&self) -> io::Result<Box<dyn Handle>> {
+        Ok(Box::new(self.clone()))
+    }
+    fn get_file_type(&self) -> Filetype {
+        self.file_type
+    }
+    fn get_rights(&self) -> HandleRights {
+        self.rights.get()
+    }
+    fn set_rights(&self, new_rights: HandleRights) {
+        self.rights.set(new_rights)
+    }
+    // FdOps
+    fn fdstat_get(&self) -> Result<types::Fdflags> {
+        fd::fdstat_get(&*self.as_file()?)
+    }
+    fn fdstat_set_flags(&self, fdflags: types::Fdflags) -> Result<()> {
+        if let Some(_) = fd::fdstat_set_flags(&*self.as_file()?, fdflags)? {
+            // OK, this means we should somehow update the underlying os handle,
+            // and we can't do that with `std::io::std{in, out, err}`, so we'll
+            // panic for now.
+            panic!("Tried updating Fdflags on Stdio handle by re-opening as file!");
+        }
+        Ok(())
+    }
+    fn write_vectored(&self, iovs: &[io::IoSlice]) -> Result<usize> {
+        // Always sanitize stderr, even if it's not directly connected to a tty,
+        // because stderr is meant for diagnostics rather than binary output,
+        // and may be redirected to a file which could end up being displayed
+        // on a tty later.
+        let nwritten = SandboxedTTYWriter::new(&mut io::stderr()).write_vectored(&iovs)?;
+        Ok(nwritten)
+    }
+}