cbf7cbfa39
* 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
98 lines
3.0 KiB
Rust
98 lines
3.0 KiB
Rust
use crate::handle::{Handle, HandleRights};
|
|
use crate::wasi::types::Filetype;
|
|
use crate::wasi::{Errno, Result};
|
|
use std::ops::Deref;
|
|
use std::path::PathBuf;
|
|
use std::rc::Rc;
|
|
|
|
pub(crate) struct EntryHandle(Rc<dyn Handle>);
|
|
|
|
impl EntryHandle {
|
|
pub(crate) fn new<T: Handle + 'static>(handle: T) -> Self {
|
|
Self(Rc::new(handle))
|
|
}
|
|
|
|
pub(crate) fn get(&self) -> Self {
|
|
Self(Rc::clone(&self.0))
|
|
}
|
|
}
|
|
|
|
impl From<Box<dyn Handle>> for EntryHandle {
|
|
fn from(handle: Box<dyn Handle>) -> Self {
|
|
Self(handle.into())
|
|
}
|
|
}
|
|
|
|
impl Deref for EntryHandle {
|
|
type Target = dyn Handle;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&*self.0
|
|
}
|
|
}
|
|
|
|
/// An abstraction struct serving as a wrapper for a `Handle` object.
|
|
///
|
|
/// Here, the `handle` field stores an instance of `Handle` type (such as a file descriptor, or
|
|
/// stdin handle), and accessing it can only be done via the provided `Entry::as_handle` method
|
|
/// which require a set of base and inheriting rights to be specified, verifying whether the stored
|
|
/// `Handle` object is valid for the rights specified.
|
|
pub(crate) struct Entry {
|
|
handle: EntryHandle,
|
|
pub(crate) preopen_path: Option<PathBuf>,
|
|
// TODO: directories
|
|
}
|
|
|
|
impl Entry {
|
|
pub(crate) fn new(handle: EntryHandle) -> Self {
|
|
let preopen_path = None;
|
|
Self {
|
|
handle,
|
|
preopen_path,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn get_file_type(&self) -> Filetype {
|
|
self.handle.get_file_type()
|
|
}
|
|
|
|
pub(crate) fn get_rights(&self) -> HandleRights {
|
|
self.handle.get_rights()
|
|
}
|
|
|
|
pub(crate) fn set_rights(&self, rights: HandleRights) {
|
|
self.handle.set_rights(rights)
|
|
}
|
|
|
|
/// Convert this `Entry` into a `Handle` object provided the specified
|
|
/// `rights` rights are set on this `Entry` object.
|
|
///
|
|
/// The `Entry` can only be converted into a valid `Handle` object if
|
|
/// the specified set of base rights, and inheriting rights encapsulated within `rights`
|
|
/// `HandleRights` structure is a subset of rights attached to this `Entry`. The check is
|
|
/// performed using `Entry::validate_rights` method. If the check fails, `Errno::Notcapable`
|
|
/// is returned.
|
|
pub(crate) fn as_handle(&self, rights: &HandleRights) -> Result<EntryHandle> {
|
|
self.validate_rights(rights)?;
|
|
Ok(self.handle.get())
|
|
}
|
|
|
|
/// Check if this `Entry` object satisfies the specified `HandleRights`; i.e., if
|
|
/// rights attached to this `Entry` object are a superset.
|
|
///
|
|
/// Upon unsuccessful check, `Errno::Notcapable` is returned.
|
|
pub(crate) fn validate_rights(&self, rights: &HandleRights) -> Result<()> {
|
|
let this_rights = self.handle.get_rights();
|
|
if this_rights.contains(rights) {
|
|
Ok(())
|
|
} else {
|
|
log::trace!(
|
|
" | validate_rights failed: required rights = {}; actual rights = {}",
|
|
rights,
|
|
this_rights,
|
|
);
|
|
Err(Errno::Notcapable)
|
|
}
|
|
}
|
|
}
|