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/windows/fd.rs

@@ -1,7 +1,9 @@
 use super::file_serial_no;
-use super::oshandle::OsFile;
+use super::oshandle::RawOsHandle;
 use crate::path;
-use crate::sys::oshandle::AsFile;
+use crate::sys::osdir::OsDir;
+use crate::sys::osfile::OsFile;
+use crate::sys::AsFile;
 use crate::wasi::{types, Result};
 use log::trace;
 use std::convert::TryInto;
@@ -39,7 +41,10 @@ pub(crate) fn fdstat_get(file: &File) -> Result<types::Fdflags> {
 // handle came from `CreateFile`, but the Rust's libstd will use `GetStdHandle`
 // rather than `CreateFile`. Relevant discussion can be found in:
 // https://github.com/rust-lang/rust/issues/40490
-pub(crate) fn fdstat_set_flags(file: &File, fdflags: types::Fdflags) -> Result<Option<OsFile>> {
+pub(crate) fn fdstat_set_flags(
+    file: &File,
+    fdflags: types::Fdflags,
+) -> Result<Option<RawOsHandle>> {
     let handle = file.as_raw_handle();
     let access_mode = winx::file::query_access_information(handle)?;
     let new_access_mode = file_access_mode_from_fdflags(
@@ -49,7 +54,7 @@ pub(crate) fn fdstat_set_flags(file: &File, fdflags: types::Fdflags) -> Result<O
             | access_mode.contains(AccessMode::FILE_APPEND_DATA),
     );
     unsafe {
-        Ok(Some(OsFile::from_raw_handle(winx::file::reopen_file(
+        Ok(Some(RawOsHandle::from_raw_handle(winx::file::reopen_file(
             handle,
             new_access_mode,
             fdflags.into(),
@@ -120,13 +125,13 @@ fn file_access_mode_from_fdflags(fdflags: types::Fdflags, read: bool, write: boo
 // ..       gets cookie = 2
 // other entries, in order they were returned by FindNextFileW get subsequent integers as their cookies
 pub(crate) fn readdir(
-    file: &OsFile,
+    dirfd: &OsDir,
     cookie: types::Dircookie,
 ) -> Result<Box<dyn Iterator<Item = Result<(types::Dirent, String)>>>> {
     use winx::file::get_file_path;
 
     let cookie = cookie.try_into()?;
-    let path = get_file_path(&file.as_file())?;
+    let path = get_file_path(&*dirfd.as_file()?)?;
     // std::fs::ReadDir doesn't return . and .., so we need to emulate it
     let path = Path::new(&path);
     // The directory /.. is the same as / on Unix (at least on ext4), so emulate this behavior too

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

@@ -1,18 +1,87 @@
 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;
 
-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::mem::ManuallyDrop;
+use std::os::windows::prelude::{AsRawHandle, FromRawHandle};
 use std::path::Path;
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::{io, string};
 use winapi::shared::winerror;
 use winx::file::{CreationDisposition, Flags};
 
+impl<T: AsRawHandle> AsFile for T {
+    fn as_file(&self) -> io::Result<ManuallyDrop<File>> {
+        let file = unsafe { File::from_raw_handle(self.as_raw_handle()) };
+        Ok(ManuallyDrop::new(file))
+    }
+}
+
+pub(super) fn get_file_type(file: &File) -> io::Result<types::Filetype> {
+    let file_type = unsafe { winx::file::get_file_type(file.as_raw_handle())? };
+    let file_type = if file_type.is_char() {
+        // character file: LPT device or console
+        // TODO: rule out LPT device
+        types::Filetype::CharacterDevice
+    } else if file_type.is_disk() {
+        // disk file: file, dir or disk device
+        let meta = file.metadata()?;
+        if meta.is_dir() {
+            types::Filetype::Directory
+        } else if meta.is_file() {
+            types::Filetype::RegularFile
+        } else {
+            return Err(io::Error::from_raw_os_error(libc::EINVAL));
+        }
+    } else if file_type.is_pipe() {
+        // pipe object: socket, named pipe or anonymous pipe
+        // TODO: what about pipes, etc?
+        types::Filetype::SocketStream
+    } else {
+        return Err(io::Error::from_raw_os_error(libc::EINVAL));
+    };
+    Ok(file_type)
+}
+
+pub(super) fn get_rights(file_type: &types::Filetype) -> io::Result<HandleRights> {
+    let (base, inheriting) = match file_type {
+        types::Filetype::BlockDevice => (
+            types::Rights::block_device_base(),
+            types::Rights::block_device_inheriting(),
+        ),
+        types::Filetype::CharacterDevice => (types::Rights::tty_base(), types::Rights::tty_base()),
+        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 rights = HandleRights::new(base, inheriting);
+    Ok(rights)
+}
+
 pub fn preopen_dir<P: AsRef<Path>>(path: P) -> io::Result<File> {
     use std::fs::OpenOptions;
     use std::os::windows::fs::OpenOptionsExt;

crates/wasi-common/src/sys/windows/osdir.rs

@@ -0,0 +1,51 @@
+use super::oshandle::RawOsHandle;
+use crate::handle::HandleRights;
+use crate::wasi::{types, RightsExt};
+use std::cell::Cell;
+use std::convert::TryFrom;
+use std::fs::File;
+use std::io;
+use std::os::windows::prelude::{AsRawHandle, FromRawHandle, IntoRawHandle};
+
+#[derive(Debug)]
+pub(crate) struct OsDir {
+    pub(crate) rights: Cell<HandleRights>,
+    pub(crate) handle: RawOsHandle,
+}
+
+impl OsDir {
+    pub(crate) fn new(rights: HandleRights, handle: RawOsHandle) -> io::Result<Self> {
+        let rights = Cell::new(rights);
+        Ok(Self { rights, handle })
+    }
+}
+
+impl TryFrom<File> for OsDir {
+    type Error = io::Error;
+
+    fn try_from(file: File) -> io::Result<Self> {
+        let ft = file.metadata()?.file_type();
+        if !ft.is_dir() {
+            return Err(io::Error::from_raw_os_error(libc::EINVAL));
+        }
+        let rights = get_rights(&file)?;
+        let handle = unsafe { RawOsHandle::from_raw_handle(file.into_raw_handle()) };
+        Self::new(rights, handle)
+    }
+}
+
+fn get_rights(file: &File) -> io::Result<HandleRights> {
+    use winx::file::{query_access_information, AccessMode};
+    let mut rights = HandleRights::new(
+        types::Rights::directory_base(),
+        types::Rights::directory_inheriting(),
+    );
+    let mode = query_access_information(file.as_raw_handle())?;
+    if mode.contains(AccessMode::FILE_GENERIC_READ) {
+        rights.base |= types::Rights::FD_READ;
+    }
+    if mode.contains(AccessMode::FILE_GENERIC_WRITE) {
+        rights.base |= types::Rights::FD_WRITE;
+    }
+    Ok(rights)
+}

crates/wasi-common/src/sys/windows/osfile.rs

@@ -0,0 +1,38 @@
+use super::oshandle::RawOsHandle;
+use crate::handle::HandleRights;
+use crate::sys::osfile::OsFile;
+use crate::wasi::{types, RightsExt};
+use std::convert::TryFrom;
+use std::fs::File;
+use std::io;
+use std::os::windows::prelude::{AsRawHandle, FromRawHandle, IntoRawHandle};
+
+impl TryFrom<File> for OsFile {
+    type Error = io::Error;
+
+    fn try_from(file: File) -> io::Result<Self> {
+        let ft = file.metadata()?.file_type();
+        if !ft.is_file() {
+            return Err(io::Error::from_raw_os_error(libc::EINVAL));
+        }
+        let rights = get_rights(&file)?;
+        let handle = unsafe { RawOsHandle::from_raw_handle(file.into_raw_handle()) };
+        Ok(Self::new(rights, handle))
+    }
+}
+
+fn get_rights(file: &File) -> io::Result<HandleRights> {
+    use winx::file::{query_access_information, AccessMode};
+    let mut rights = HandleRights::new(
+        types::Rights::regular_file_base(),
+        types::Rights::regular_file_inheriting(),
+    );
+    let mode = query_access_information(file.as_raw_handle())?;
+    if mode.contains(AccessMode::FILE_GENERIC_READ) {
+        rights.base |= types::Rights::FD_READ;
+    }
+    if mode.contains(AccessMode::FILE_GENERIC_WRITE) {
+        rights.base |= types::Rights::FD_WRITE;
+    }
+    Ok(rights)
+}

crates/wasi-common/src/sys/windows/oshandle.rs

@@ -1,16 +1,19 @@
-use crate::entry::EntryRights;
-use crate::sys::oshandle::{AsFile, OsHandle, OsHandleExt};
-use crate::wasi::{types, RightsExt};
+use crate::sys::AsFile;
 use std::cell::Cell;
-use std::fs::{File, OpenOptions};
+use std::fs::File;
 use std::io;
 use std::mem::ManuallyDrop;
 use std::os::windows::prelude::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
 
 #[derive(Debug)]
-pub(crate) struct OsFile(Cell<RawHandle>);
+pub(crate) struct RawOsHandle(Cell<RawHandle>);
 
-impl OsFile {
+impl RawOsHandle {
+    /// Tries cloning `self`.
+    pub(crate) fn try_clone(&self) -> io::Result<Self> {
+        let handle = self.as_file()?.try_clone()?;
+        Ok(Self(Cell::new(handle.into_raw_handle())))
+    }
     /// Consumes `other` taking the ownership of the underlying
     /// `RawHandle` file handle.
     pub(crate) fn update_from(&self, other: Self) {
@@ -22,14 +25,9 @@ impl OsFile {
             File::from_raw_handle(old_handle);
         }
     }
-    /// Clones `self`.
-    pub(crate) fn try_clone(&self) -> io::Result<Self> {
-        let handle = self.as_file().try_clone()?;
-        Ok(Self(Cell::new(handle.into_raw_handle())))
-    }
 }
 
-impl Drop for OsFile {
+impl Drop for RawOsHandle {
     fn drop(&mut self) {
         unsafe {
             File::from_raw_handle(self.as_raw_handle());
@@ -37,133 +35,22 @@ impl Drop for OsFile {
     }
 }
 
-impl AsRawHandle for OsFile {
+impl AsRawHandle for RawOsHandle {
     fn as_raw_handle(&self) -> RawHandle {
         self.0.get()
     }
 }
 
-impl FromRawHandle for OsFile {
+impl FromRawHandle for RawOsHandle {
     unsafe fn from_raw_handle(handle: RawHandle) -> Self {
         Self(Cell::new(handle))
     }
 }
 
-impl IntoRawHandle for OsFile {
+impl IntoRawHandle for RawOsHandle {
     fn into_raw_handle(self) -> RawHandle {
         // We need to prevent dropping of the OsFile
         let wrapped = ManuallyDrop::new(self);
         wrapped.0.get()
     }
 }
-
-impl AsFile for OsFile {
-    fn as_file(&self) -> ManuallyDrop<File> {
-        let file = unsafe { File::from_raw_handle(self.0.get()) };
-        ManuallyDrop::new(file)
-    }
-}
-
-impl AsRawHandle for OsHandle {
-    fn as_raw_handle(&self) -> RawHandle {
-        match self {
-            Self::OsFile(file) => file.as_raw_handle(),
-            Self::Stdin => io::stdin().as_raw_handle(),
-            Self::Stdout => io::stdout().as_raw_handle(),
-            Self::Stderr => io::stderr().as_raw_handle(),
-        }
-    }
-}
-
-impl AsFile for OsHandle {
-    fn as_file(&self) -> ManuallyDrop<File> {
-        let file = unsafe { File::from_raw_handle(self.as_raw_handle()) };
-        ManuallyDrop::new(file)
-    }
-}
-
-impl From<File> for OsHandle {
-    fn from(file: File) -> Self {
-        Self::from(unsafe { OsFile::from_raw_handle(file.into_raw_handle()) })
-    }
-}
-
-impl OsHandleExt for OsHandle {
-    fn get_file_type(&self) -> io::Result<types::Filetype> {
-        let file_type = unsafe { winx::file::get_file_type(self.as_raw_handle())? };
-        let file_type = if file_type.is_char() {
-            // character file: LPT device or console
-            // TODO: rule out LPT device
-            types::Filetype::CharacterDevice
-        } else if file_type.is_disk() {
-            // disk file: file, dir or disk device
-            let file = self.as_file();
-            let meta = file.metadata()?;
-            if meta.is_dir() {
-                types::Filetype::Directory
-            } else if meta.is_file() {
-                types::Filetype::RegularFile
-            } else {
-                return Err(io::Error::from_raw_os_error(libc::EINVAL));
-            }
-        } else if file_type.is_pipe() {
-            // pipe object: socket, named pipe or anonymous pipe
-            // TODO: what about pipes, etc?
-            types::Filetype::SocketStream
-        } else {
-            return Err(io::Error::from_raw_os_error(libc::EINVAL));
-        };
-        Ok(file_type)
-    }
-
-    fn get_rights(&self, file_type: types::Filetype) -> io::Result<EntryRights> {
-        use winx::file::{query_access_information, AccessMode};
-        let (base, inheriting) = match file_type {
-            types::Filetype::BlockDevice => (
-                types::Rights::block_device_base(),
-                types::Rights::block_device_inheriting(),
-            ),
-            types::Filetype::CharacterDevice => {
-                (types::Rights::tty_base(), types::Rights::tty_base())
-            }
-            types::Filetype::Directory => (
-                types::Rights::directory_base(),
-                types::Rights::directory_inheriting(),
-            ),
-            types::Filetype::RegularFile => (
-                types::Rights::regular_file_base(),
-                types::Rights::regular_file_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(),
-            ),
-        };
-        let mut rights = EntryRights::new(base, inheriting);
-        match file_type {
-            types::Filetype::Directory | types::Filetype::RegularFile => {
-                let mode = query_access_information(self.as_raw_handle())?;
-                if mode.contains(AccessMode::FILE_GENERIC_READ) {
-                    rights.base |= types::Rights::FD_READ;
-                }
-                if mode.contains(AccessMode::FILE_GENERIC_WRITE) {
-                    rights.base |= types::Rights::FD_WRITE;
-                }
-            }
-            _ => {
-                // TODO: is there a way around this? On windows, it seems
-                // we cannot check access rights for anything but dirs and regular files
-            }
-        }
-        Ok(rights)
-    }
-
-    fn from_null() -> io::Result<Self> {
-        let file = OpenOptions::new().read(true).write(true).open("NUL")?;
-        Ok(Self::from(file))
-    }
-}

crates/wasi-common/src/sys/windows/osother.rs

@@ -0,0 +1,31 @@
+use super::oshandle::RawOsHandle;
+use super::{get_file_type, get_rights};
+use crate::handle::Handle;
+use crate::sys::osother::{OsOther, OsOtherExt};
+use crate::wasi::types;
+use std::convert::TryFrom;
+use std::fs::{File, OpenOptions};
+use std::io;
+use std::os::windows::prelude::{FromRawHandle, IntoRawHandle};
+
+impl TryFrom<File> for OsOther {
+    type Error = io::Error;
+
+    fn try_from(file: File) -> io::Result<Self> {
+        let file_type = get_file_type(&file)?;
+        if file_type == types::Filetype::RegularFile || file_type == types::Filetype::Directory {
+            return Err(io::Error::from_raw_os_error(libc::EINVAL));
+        }
+        let rights = get_rights(&file_type)?;
+        let handle = unsafe { RawOsHandle::from_raw_handle(file.into_raw_handle()) };
+        Ok(Self::new(file_type, rights, handle))
+    }
+}
+
+impl OsOtherExt for OsOther {
+    fn from_null() -> io::Result<Box<dyn Handle>> {
+        let file = OpenOptions::new().read(true).write(true).open("NUL")?;
+        let file = Self::try_from(file)?;
+        Ok(Box::new(file))
+    }
+}

crates/wasi-common/src/sys/windows/path.rs

@@ -1,7 +1,8 @@
-use super::oshandle::OsFile;
-use crate::entry::EntryRights;
-use crate::sys::oshandle::{AsFile, OsHandle};
+use crate::handle::{Handle, HandleRights};
+use crate::sys::osdir::OsDir;
+use crate::sys::AsFile;
 use crate::wasi::{types, Errno, Result};
+use std::convert::TryFrom;
 use std::ffi::{OsStr, OsString};
 use std::fs::{self, Metadata, OpenOptions};
 use std::os::windows::ffi::{OsStrExt, OsStringExt};
@@ -10,7 +11,7 @@ use std::path::{Path, PathBuf};
 use winapi::shared::winerror;
 use winx::file::AccessMode;
 
-fn strip_trailing_slashes_and_concatenate(dirfd: &OsFile, path: &str) -> Result<Option<PathBuf>> {
+fn strip_trailing_slashes_and_concatenate(dirfd: &OsDir, path: &str) -> Result<Option<PathBuf>> {
     if path.ends_with('/') {
         let suffix = path.trim_end_matches('/');
         concatenate(dirfd, Path::new(suffix)).map(Some)
@@ -28,7 +29,7 @@ fn strip_extended_prefix<P: AsRef<OsStr>>(path: P) -> OsString {
     }
 }
 
-fn concatenate<P: AsRef<Path>>(file: &OsFile, path: P) -> Result<PathBuf> {
+fn concatenate<P: AsRef<Path>>(file: &OsDir, path: P) -> Result<PathBuf> {
     use winx::file::get_file_path;
 
     // WASI is not able to deal with absolute paths
@@ -37,7 +38,7 @@ fn concatenate<P: AsRef<Path>>(file: &OsFile, path: P) -> Result<PathBuf> {
         return Err(Errno::Notcapable);
     }
 
-    let dir_path = get_file_path(&file.as_file())?;
+    let dir_path = get_file_path(&*file.as_file()?)?;
     // concatenate paths
     let mut out_path = PathBuf::from(dir_path);
     out_path.push(path.as_ref());
@@ -89,10 +90,10 @@ pub(crate) fn from_host<S: AsRef<OsStr>>(s: S) -> Result<String> {
 }
 
 pub(crate) fn open_rights(
-    input_rights: &EntryRights,
+    input_rights: &HandleRights,
     oflags: types::Oflags,
     fdflags: types::Fdflags,
-) -> EntryRights {
+) -> HandleRights {
     // which rights are needed on the dirfd?
     let mut needed_base = types::Rights::PATH_OPEN;
     let mut needed_inheriting = input_rights.base | input_rights.inheriting;
@@ -113,10 +114,10 @@ pub(crate) fn open_rights(
         needed_inheriting |= types::Rights::FD_SYNC;
     }
 
-    EntryRights::new(needed_base, needed_inheriting)
+    HandleRights::new(needed_base, needed_inheriting)
 }
 
-pub(crate) fn readlinkat(dirfd: &OsFile, s_path: &str) -> Result<String> {
+pub(crate) fn readlinkat(dirfd: &OsDir, s_path: &str) -> Result<String> {
     use winx::file::get_file_path;
 
     let path = concatenate(dirfd, Path::new(s_path))?;
@@ -126,7 +127,7 @@ pub(crate) fn readlinkat(dirfd: &OsFile, s_path: &str) -> Result<String> {
             // we need to strip the prefix from the absolute path
             // as otherwise we will error out since WASI is not capable
             // of dealing with absolute paths
-            let dir_path = get_file_path(&dirfd.as_file())?;
+            let dir_path = get_file_path(&*dirfd.as_file()?)?;
             let dir_path = PathBuf::from(strip_extended_prefix(dir_path));
             let target_path = target_path
                 .strip_prefix(dir_path)
@@ -151,16 +152,16 @@ pub(crate) fn readlinkat(dirfd: &OsFile, s_path: &str) -> Result<String> {
     Err(err.into())
 }
 
-pub(crate) fn create_directory(file: &OsFile, path: &str) -> Result<()> {
+pub(crate) fn create_directory(file: &OsDir, path: &str) -> Result<()> {
     let path = concatenate(file, path)?;
     std::fs::create_dir(&path)?;
     Ok(())
 }
 
 pub(crate) fn link(
-    old_dirfd: &OsFile,
+    old_dirfd: &OsDir,
     old_path: &str,
-    new_dirfd: &OsFile,
+    new_dirfd: &OsDir,
     new_path: &str,
     follow_symlinks: bool,
 ) -> Result<()> {
@@ -197,13 +198,13 @@ pub(crate) fn link(
 }
 
 pub(crate) fn open(
-    dirfd: &OsFile,
+    dirfd: &OsDir,
     path: &str,
     read: bool,
     write: bool,
     oflags: types::Oflags,
     fdflags: types::Fdflags,
-) -> Result<OsHandle> {
+) -> Result<Box<dyn Handle>> {
     use winx::file::{AccessMode, CreationDisposition, Flags};
 
     let is_trunc = oflags.contains(&types::Oflags::TRUNC);
@@ -280,11 +281,11 @@ pub(crate) fn open(
         .access_mode(access_mode.bits())
         .custom_flags(flags.bits())
         .open(&path)?;
-    let handle = OsHandle::from(file);
+    let handle = <Box<dyn Handle>>::try_from(file)?;
     Ok(handle)
 }
 
-pub(crate) fn readlink(dirfd: &OsFile, path: &str, buf: &mut [u8]) -> Result<usize> {
+pub(crate) fn readlink(dirfd: &OsDir, path: &str, buf: &mut [u8]) -> Result<usize> {
     use winx::file::get_file_path;
 
     let path = concatenate(dirfd, path)?;
@@ -294,7 +295,7 @@ pub(crate) fn readlink(dirfd: &OsFile, path: &str, buf: &mut [u8]) -> Result<usi
     // we need to strip the prefix from the absolute path
     // as otherwise we will error out since WASI is not capable
     // of dealing with absolute paths
-    let dir_path = get_file_path(&dirfd.as_file())?;
+    let dir_path = get_file_path(&*dirfd.as_file()?)?;
     let dir_path = PathBuf::from(strip_extended_prefix(dir_path));
     let target_path = target_path
         .strip_prefix(dir_path)
@@ -322,9 +323,9 @@ pub(crate) fn readlink(dirfd: &OsFile, path: &str, buf: &mut [u8]) -> Result<usi
 }
 
 pub(crate) fn rename(
-    old_dirfd: &OsFile,
+    old_dirfd: &OsDir,
     old_path_: &str,
-    new_dirfd: &OsFile,
+    new_dirfd: &OsDir,
     new_path_: &str,
 ) -> Result<()> {
     use std::fs;
@@ -390,7 +391,7 @@ pub(crate) fn rename(
     }
 }
 
-pub(crate) fn symlink(old_path: &str, new_dirfd: &OsFile, new_path_: &str) -> Result<()> {
+pub(crate) fn symlink(old_path: &str, new_dirfd: &OsDir, new_path_: &str) -> Result<()> {
     use std::os::windows::fs::{symlink_dir, symlink_file};
 
     let old_path = concatenate(new_dirfd, Path::new(old_path))?;
@@ -447,7 +448,7 @@ pub(crate) fn symlink(old_path: &str, new_dirfd: &OsFile, new_path_: &str) -> Re
     }
 }
 
-pub(crate) fn unlink_file(dirfd: &OsFile, path: &str) -> Result<()> {
+pub(crate) fn unlink_file(dirfd: &OsDir, path: &str) -> Result<()> {
     use std::fs;
 
     let path = concatenate(dirfd, path)?;
@@ -489,7 +490,7 @@ pub(crate) fn unlink_file(dirfd: &OsFile, path: &str) -> Result<()> {
     }
 }
 
-pub(crate) fn remove_directory(dirfd: &OsFile, path: &str) -> Result<()> {
+pub(crate) fn remove_directory(dirfd: &OsDir, path: &str) -> Result<()> {
     let path = concatenate(dirfd, path)?;
     std::fs::remove_dir(&path).map_err(Into::into)
 }

crates/wasi-common/src/sys/windows/poll.rs

@@ -1,11 +1,14 @@
-use super::super::oshandle::OsHandle;
+use crate::handle::Handle;
 use crate::poll::{ClockEventData, FdEventData};
-use crate::sys::oshandle::AsFile;
+use crate::sys::osdir::OsDir;
+use crate::sys::osfile::OsFile;
+use crate::sys::osother::OsOther;
+use crate::sys::stdio::{Stderr, Stdin, Stdout};
+use crate::sys::AsFile;
 use crate::wasi::{types, Errno, Result};
 use lazy_static::lazy_static;
 use log::{debug, error, trace, warn};
 use std::convert::TryInto;
-use std::os::windows::io::AsRawHandle;
 use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender, TryRecvError};
 use std::sync::Mutex;
 use std::thread;
@@ -141,32 +144,31 @@ fn handle_timeout_event(timeout_event: ClockEventData, events: &mut Vec<types::E
 }
 
 fn handle_rw_event(event: FdEventData, out_events: &mut Vec<types::Event>) {
-    let handle = event
-        .handle
-        .as_any()
-        .downcast_ref::<OsHandle>()
-        .expect("can poll FdEvent for OS resources only");
-    let size = match handle {
-        OsHandle::OsFile(file) => {
-            if event.r#type == types::Eventtype::FdRead {
-                file.as_file()
-                    .metadata()
-                    .map(|m| m.len())
-                    .map_err(Into::into)
-            } else {
-                // The spec is unclear what nbytes should actually be for __WASI_EVENTTYPE_FD_WRITE and
-                // the implementation on Unix just returns 0 here, so it's probably fine
-                // to do the same on Windows for now.
-                // cf. https://github.com/WebAssembly/WASI/issues/148
-                Ok(0)
-            }
-        }
+    let handle = &event.handle;
+    let size = if let Some(_) = handle.as_any().downcast_ref::<Stdin>() {
         // We return the only universally correct lower bound, see the comment later in the function.
-        OsHandle::Stdin => Ok(1),
+        Ok(1)
+    } else if let Some(_) = handle.as_any().downcast_ref::<Stdout>() {
+        // On Unix, ioctl(FIONREAD) will return 0 for stdout. Emulate the same behavior on Windows.
+        Ok(0)
+    } else if let Some(_) = handle.as_any().downcast_ref::<Stderr>() {
         // On Unix, ioctl(FIONREAD) will return 0 for stdout/stderr. Emulate the same behavior on Windows.
-        OsHandle::Stdout | OsHandle::Stderr => Ok(0),
+        Ok(0)
+    } else {
+        if event.r#type == types::Eventtype::FdRead {
+            handle
+                .as_file()
+                .and_then(|f| f.metadata())
+                .map(|m| m.len())
+                .map_err(Into::into)
+        } else {
+            // The spec is unclear what nbytes should actually be for __WASI_EVENTTYPE_FD_WRITE and
+            // the implementation on Unix just returns 0 here, so it's probably fine
+            // to do the same on Windows for now.
+            // cf. https://github.com/WebAssembly/WASI/issues/148
+            Ok(0)
+        }
     };
-
     let new_event = make_rw_event(&event, size);
     out_events.push(new_event);
 }
@@ -206,33 +208,42 @@ pub(crate) fn oneoff(
     let mut pipe_events = vec![];
 
     for event in fd_events {
-        let handle = event
-            .handle
-            .as_any()
-            .downcast_ref::<OsHandle>()
-            .expect("can poll FdEvent for OS resources only");
-        match handle {
-            OsHandle::Stdin if event.r#type == types::Eventtype::FdRead => stdin_events.push(event),
-            // stdout/stderr are always considered ready to write because there seems to
+        let handle = &event.handle;
+        if let Some(_) = handle.as_any().downcast_ref::<OsFile>() {
+            immediate_events.push(event);
+        } else if let Some(_) = handle.as_any().downcast_ref::<OsDir>() {
+            immediate_events.push(event);
+        } else if let Some(_) = handle.as_any().downcast_ref::<Stdin>() {
+            stdin_events.push(event);
+        } else if let Some(_) = handle.as_any().downcast_ref::<Stdout>() {
+            // stdout are always considered ready to write because there seems to
             // be no way of checking if a write to stdout would block.
             //
             // If stdin is polled for anything else then reading, then it is also
             // considered immediately ready, following the behavior on Linux.
-            OsHandle::Stdin | OsHandle::Stderr | OsHandle::Stdout => immediate_events.push(event),
-            OsHandle::OsFile(file) => {
-                let ftype = unsafe { winx::file::get_file_type(file.as_raw_handle()) }?;
-                if ftype.is_unknown() || ftype.is_char() {
-                    debug!("poll_oneoff: unsupported file type: {:?}", ftype);
-                    handle_error_event(event, Errno::Notsup, events);
-                } else if ftype.is_disk() {
-                    immediate_events.push(event);
-                } else if ftype.is_pipe() {
-                    pipe_events.push(event);
-                } else {
-                    unreachable!();
-                }
+            immediate_events.push(event);
+        } else if let Some(_) = handle.as_any().downcast_ref::<Stderr>() {
+            // stderr are always considered ready to write because there seems to
+            // be no way of checking if a write to stdout would block.
+            //
+            // If stdin is polled for anything else then reading, then it is also
+            // considered immediately ready, following the behavior on Linux.
+            immediate_events.push(event);
+        } else if let Some(other) = handle.as_any().downcast_ref::<OsOther>() {
+            if other.get_file_type() == types::Filetype::SocketStream {
+                // We map pipe to SocketStream
+                pipe_events.push(event);
+            } else {
+                debug!(
+                    "poll_oneoff: unsupported file type: {}",
+                    other.get_file_type()
+                );
+                handle_error_event(event, Errno::Notsup, events);
             }
-        };
+        } else {
+            log::error!("can poll FdEvent for OS resources only");
+            return Err(Errno::Badf);
+        }
     }
 
     let immediate = !immediate_events.is_empty();

crates/wasi-common/src/sys/windows/stdio.rs

@@ -0,0 +1,59 @@
+use super::{get_file_type, get_rights};
+use crate::handle::Handle;
+use crate::sys::stdio::{Stderr, StderrExt, Stdin, StdinExt, Stdout, StdoutExt};
+use std::cell::Cell;
+use std::fs::File;
+use std::io;
+use std::mem::ManuallyDrop;
+use std::os::windows::prelude::{AsRawHandle, FromRawHandle, RawHandle};
+
+impl AsRawHandle for Stdin {
+    fn as_raw_handle(&self) -> RawHandle {
+        io::stdin().as_raw_handle()
+    }
+}
+
+impl AsRawHandle for Stdout {
+    fn as_raw_handle(&self) -> RawHandle {
+        io::stdout().as_raw_handle()
+    }
+}
+
+impl AsRawHandle for Stderr {
+    fn as_raw_handle(&self) -> RawHandle {
+        io::stderr().as_raw_handle()
+    }
+}
+
+impl StdinExt for Stdin {
+    fn stdin() -> io::Result<Box<dyn Handle>> {
+        let file = unsafe { File::from_raw_handle(io::stdin().as_raw_handle()) };
+        let file = ManuallyDrop::new(file);
+        let file_type = get_file_type(&file)?;
+        let rights = get_rights(&file_type)?;
+        let rights = Cell::new(rights);
+        Ok(Box::new(Self { file_type, rights }))
+    }
+}
+
+impl StdoutExt for Stdout {
+    fn stdout() -> io::Result<Box<dyn Handle>> {
+        let file = unsafe { File::from_raw_handle(io::stdin().as_raw_handle()) };
+        let file = ManuallyDrop::new(file);
+        let file_type = get_file_type(&file)?;
+        let rights = get_rights(&file_type)?;
+        let rights = Cell::new(rights);
+        Ok(Box::new(Self { file_type, rights }))
+    }
+}
+
+impl StderrExt for Stderr {
+    fn stderr() -> io::Result<Box<dyn Handle>> {
+        let file = unsafe { File::from_raw_handle(io::stdin().as_raw_handle()) };
+        let file = ManuallyDrop::new(file);
+        let file_type = get_file_type(&file)?;
+        let rights = get_rights(&file_type)?;
+        let rights = Cell::new(rights);
+        Ok(Box::new(Self { file_type, rights }))
+    }
+}