Struct wasi_cap_std_sync::file::File

pub struct File(_);

Implementations

impl File

pub fn from_cap_std(file: File) -> Self

Examples found in repository

src/dir.rs (line 80)

    pub fn open_file_(
        &self,
        symlink_follow: bool,
        path: &str,
        oflags: OFlags,
        read: bool,
        write: bool,
        fdflags: FdFlags,
    ) -> Result<File, Error> {
        use cap_fs_ext::{FollowSymlinks, OpenOptionsFollowExt};

        let mut opts = cap_std::fs::OpenOptions::new();

        if oflags.contains(OFlags::CREATE | OFlags::EXCLUSIVE) {
            opts.create_new(true);
            opts.write(true);
        } else if oflags.contains(OFlags::CREATE) {
            opts.create(true);
            opts.write(true);
        }
        if oflags.contains(OFlags::TRUNCATE) {
            opts.truncate(true);
        }
        if read {
            opts.read(true);
        }
        if write {
            opts.write(true);
        } else {
            // If not opened write, open read. This way the OS lets us open the file.
            // If FileCaps::READ is not set, read calls will be rejected at the
            // get_cap check.
            opts.read(true);
        }
        if fdflags.contains(FdFlags::APPEND) {
            opts.append(true);
        }

        if symlink_follow {
            opts.follow(FollowSymlinks::Yes);
        } else {
            opts.follow(FollowSymlinks::No);
        }
        // the DSYNC, SYNC, and RSYNC flags are ignored! We do not
        // have support for them in cap-std yet.
        // ideally OpenOptions would just support this though:
        // https://github.com/bytecodealliance/cap-std/issues/146
        if fdflags.intersects(
            wasi_common::file::FdFlags::DSYNC
                | wasi_common::file::FdFlags::SYNC
                | wasi_common::file::FdFlags::RSYNC,
        ) {
            return Err(Error::not_supported().context("SYNC family of FdFlags"));
        }

        let mut f = self.0.open_with(Path::new(path), &opts)?;
        // NONBLOCK does not have an OpenOption either, but we can patch that on with set_fd_flags:
        if fdflags.contains(wasi_common::file::FdFlags::NONBLOCK) {
            let set_fd_flags = f.new_set_fd_flags(system_interface::fs::FdFlags::NONBLOCK)?;
            f.set_fd_flags(set_fd_flags)?;
        }
        Ok(File::from_cap_std(f))
    }

Trait Implementations

impl AsFd for File

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor.

impl WasiFile for File

fn as_any(&self) -> &dyn Any

fn pollable(&self) -> Option<BorrowedFd<'_>>

fn datasync<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn sync<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn get_filetype<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FileType, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn get_fdflags<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FdFlags, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn set_fdflags<'life0, 'async_trait>(
    &'life0 mut self,
    fdflags: FdFlags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn get_filestat<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn set_filestat_size<'life0, 'async_trait>(
    &'life0 mut self,
    size: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn advise<'life0, 'async_trait>(
    &'life0 mut self,
    offset: u64,
    len: u64,
    advice: Advice
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn allocate<'life0, 'async_trait>(
    &'life0 mut self,
    offset: u64,
    len: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn set_times<'life0, 'async_trait>(
    &'life0 mut self,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn read_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    bufs: &'life1 mut [IoSliceMut<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn read_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    bufs: &'life1 mut [IoSliceMut<'a>],
    offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn write_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    bufs: &'life1 [IoSlice<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn write_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    bufs: &'life1 [IoSlice<'a>],
    offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn seek<'life0, 'async_trait>(
    &'life0 mut self,
    pos: SeekFrom
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn peek<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn num_ready_bytes<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

fn isatty(&mut self) -> bool

fn sock_accept<'life0, 'async_trait>(
    &'life0 mut self,
    _fdflags: FdFlags
) -> Pin<Box<dyn Future<Output = Result<Box<dyn WasiFile + 'static, Global>, Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn sock_recv<'a, 'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    _ri_data: &'life1 mut [IoSliceMut<'a>],
    _ri_flags: RiFlags
) -> Pin<Box<dyn Future<Output = Result<(u64, RoFlags), Error>> + Send + 'async_trait, Global>>where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

fn sock_send<'a, 'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    _si_data: &'life1 [IoSlice<'a>],
    _si_flags: SiFlags
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait, Global>>where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

fn sock_shutdown<'life0, 'async_trait>(
    &'life0 mut self,
    _how: SdFlags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn readable<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn writable<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,