Struct cap_primitives::fs::OpenOptions

pub struct OpenOptions { /* private fields */ }

Options and flags which can be used to configure how a file is opened.

This corresponds to std::fs::OpenOptions.

This OpenOptions has no open method. To open a file with an OptionOptions, first obtain a Dir containing the path, and then call Dir::open_with.

We need to define our own version because the libstd `OpenOptions` doesn't have public accessors that we can use.

Implementations

impl OpenOptions

pub const fn new() -> Self

Creates a blank new set of options ready for configuration.

This corresponds to std::fs::OpenOptions::new.

Examples found in repository

src/fs/dir_entry.rs (line 31)

    pub fn open(&self) -> io::Result<fs::File> {
        self.open_with(OpenOptions::new().read(true))
    }

src/windows/fs/copy.rs (line 12)

pub(crate) fn copy_impl(
    from_start: &fs::File,
    from_path: &Path,
    to_start: &fs::File,
    to_path: &Path,
) -> io::Result<u64> {
    let from = open(from_start, from_path, OpenOptions::new().read(true))?;
    let to = open(
        to_start,
        to_path,
        OpenOptions::new().create(true).truncate(true).write(true),
    )?;
    fs::copy(get_path(&from)?, get_path(&to)?)
}

src/windows/fs/dir_utils.rs (line 66)

pub(crate) fn dir_options() -> OpenOptions {
    // Set `FILE_FLAG_BACKUP_SEMANTICS` so that we can open directories. Unset
    // `FILE_SHARE_DELETE` so that directories can't be renamed or deleted
    // underneath us, since we use paths to implement many directory operations.
    OpenOptions::new()
        .read(true)
        .dir_required(true)
        .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)
        .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)
        .clone()
}

/// Like `dir_options`, but additionally request the ability to read the
/// directory entries.
pub(crate) fn readdir_options() -> OpenOptions {
    dir_options().readdir_required(true).clone()
}

/// Return an `OpenOptions` for canonicalizing paths.
pub(crate) fn canonicalize_options() -> OpenOptions {
    OpenOptions::new()
        .read(true)
        .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)
        .clone()
}

src/windows/fs/dir_entry_inner.rs (line 54)

    pub(crate) fn full_metadata(&self) -> io::Result<Metadata> {
        // If we can open the file, we can get a more complete Metadata which
        // includes `file_index`, `volume_serial_number`, and
        // `number_of_links`.
        let mut opts = OpenOptions::new();
        opts.access_mode(0);
        opts.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS);
        opts.follow(FollowSymlinks::No);
        let opened = self.open(&opts)?;
        Metadata::from_file(&opened)
    }

src/windows/fs/read_link_impl.rs (line 15)

pub(crate) fn read_link_impl(start: &fs::File, path: &Path) -> io::Result<PathBuf> {
    // Open the link with no access mode, instead of generic read.
    // By default FILE_LIST_DIRECTORY is denied for the junction "C:\Documents and
    // Settings", so this is needed for a common case.
    let mut opts = OpenOptions::new();
    opts.access_mode(0);
    opts.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS);
    opts.follow(FollowSymlinks::No);
    let file = open(start, path, &opts)?;
    winx::file::read_link(&file)
}

src/windows/fs/set_times_impl.rs (line 42)

fn set_times_inner(
    start: &fs::File,
    path: &Path,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>,
    custom_flags: u32,
) -> io::Result<()> {
    let custom_flags = custom_flags | FILE_FLAG_BACKUP_SEMANTICS;

    // On Windows, `set_times` requires write permissions.
    let file = open(
        start,
        path,
        OpenOptions::new().write(true).custom_flags(custom_flags),
    )?;
    fs_set_times::SetTimes::set_times(
        &file,
        atime.map(SystemTimeSpec::into_std),
        mtime.map(SystemTimeSpec::into_std),
    )
}

Additional examples can be found in:

• src/windows/fs/stat_unchecked.rs
• src/fs/manually/open.rs

pub fn read(&mut self, read: bool) -> &mut Self

Sets the option for read access.

This corresponds to std::fs::OpenOptions::read.

Examples found in repository

src/fs/dir_entry.rs (line 31)

    pub fn open(&self) -> io::Result<fs::File> {
        self.open_with(OpenOptions::new().read(true))
    }

src/windows/fs/copy.rs (line 12)

pub(crate) fn copy_impl(
    from_start: &fs::File,
    from_path: &Path,
    to_start: &fs::File,
    to_path: &Path,
) -> io::Result<u64> {
    let from = open(from_start, from_path, OpenOptions::new().read(true))?;
    let to = open(
        to_start,
        to_path,
        OpenOptions::new().create(true).truncate(true).write(true),
    )?;
    fs::copy(get_path(&from)?, get_path(&to)?)
}

src/windows/fs/dir_utils.rs (line 67)

pub(crate) fn dir_options() -> OpenOptions {
    // Set `FILE_FLAG_BACKUP_SEMANTICS` so that we can open directories. Unset
    // `FILE_SHARE_DELETE` so that directories can't be renamed or deleted
    // underneath us, since we use paths to implement many directory operations.
    OpenOptions::new()
        .read(true)
        .dir_required(true)
        .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)
        .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)
        .clone()
}

/// Like `dir_options`, but additionally request the ability to read the
/// directory entries.
pub(crate) fn readdir_options() -> OpenOptions {
    dir_options().readdir_required(true).clone()
}

/// Return an `OpenOptions` for canonicalizing paths.
pub(crate) fn canonicalize_options() -> OpenOptions {
    OpenOptions::new()
        .read(true)
        .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)
        .clone()
}

pub fn write(&mut self, write: bool) -> &mut Self

Sets the option for write access.

This corresponds to std::fs::OpenOptions::write.

Examples found in repository

src/windows/fs/copy.rs (line 16)

pub(crate) fn copy_impl(
    from_start: &fs::File,
    from_path: &Path,
    to_start: &fs::File,
    to_path: &Path,
) -> io::Result<u64> {
    let from = open(from_start, from_path, OpenOptions::new().read(true))?;
    let to = open(
        to_start,
        to_path,
        OpenOptions::new().create(true).truncate(true).write(true),
    )?;
    fs::copy(get_path(&from)?, get_path(&to)?)
}

src/windows/fs/set_times_impl.rs (line 42)

fn set_times_inner(
    start: &fs::File,
    path: &Path,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>,
    custom_flags: u32,
) -> io::Result<()> {
    let custom_flags = custom_flags | FILE_FLAG_BACKUP_SEMANTICS;

    // On Windows, `set_times` requires write permissions.
    let file = open(
        start,
        path,
        OpenOptions::new().write(true).custom_flags(custom_flags),
    )?;
    fs_set_times::SetTimes::set_times(
        &file,
        atime.map(SystemTimeSpec::into_std),
        mtime.map(SystemTimeSpec::into_std),
    )
}

pub fn append(&mut self, append: bool) -> &mut Self

Sets the option for the append mode.

This corresponds to std::fs::OpenOptions::append.

pub fn truncate(&mut self, truncate: bool) -> &mut Self

Sets the option for truncating a previous file.

This corresponds to std::fs::OpenOptions::truncate.

Examples found in repository

src/windows/fs/copy.rs (line 16)

pub(crate) fn copy_impl(
    from_start: &fs::File,
    from_path: &Path,
    to_start: &fs::File,
    to_path: &Path,
) -> io::Result<u64> {
    let from = open(from_start, from_path, OpenOptions::new().read(true))?;
    let to = open(
        to_start,
        to_path,
        OpenOptions::new().create(true).truncate(true).write(true),
    )?;
    fs::copy(get_path(&from)?, get_path(&to)?)
}

pub fn create(&mut self, create: bool) -> &mut Self

Sets the option to create a new file.

This corresponds to std::fs::OpenOptions::create.

Examples found in repository

src/windows/fs/copy.rs (line 16)

pub(crate) fn copy_impl(
    from_start: &fs::File,
    from_path: &Path,
    to_start: &fs::File,
    to_path: &Path,
) -> io::Result<u64> {
    let from = open(from_start, from_path, OpenOptions::new().read(true))?;
    let to = open(
        to_start,
        to_path,
        OpenOptions::new().create(true).truncate(true).write(true),
    )?;
    fs::copy(get_path(&from)?, get_path(&to)?)
}

pub fn create_new(&mut self, create_new: bool) -> &mut Self

Sets the option to always create a new file.

This corresponds to std::fs::OpenOptions::create_new.

Trait Implementations

impl Clone for OpenOptions

fn clone(&self) -> OpenOptions

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OpenOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl OpenOptionsExt for OpenOptions

fn share_mode(&mut self, val: u32) -> &mut Self

To prevent race conditions on Windows, handles for directories must be opened without FILE_SHARE_DELETE.

fn access_mode(&mut self, access: u32) -> &mut Self

Overrides the dwDesiredAccess argument to the call to CreateFile with the specified value.

fn custom_flags(&mut self, flags: u32) -> &mut Self

Sets extra flags for the dwFileFlags argument to the call to CreateFile2 to the specified value (or combines it with attributes and security_qos_flags to set the dwFlagsAndAttributes for CreateFile).

fn attributes(&mut self, val: u32) -> &mut Self

Sets the dwFileAttributes argument to the call to CreateFile2 to the specified value (or combines it with custom_flags and security_qos_flags to set the dwFlagsAndAttributes for CreateFile).

fn security_qos_flags(&mut self, flags: u32) -> &mut Self

Sets the dwSecurityQosFlags argument to the call to CreateFile2 to the specified value (or combines it with custom_flags and attributes to set the dwFlagsAndAttributes for CreateFile).