Struct cap_primitives::fs::Permissions

pub struct Permissions { /* private fields */ }

Representation of the various permissions on a file.

This corresponds to std::fs::Permissions.

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

Implementations

impl Permissions

pub fn from_std(std: Permissions) -> Self

Constructs a new instance of Self from the given std::fs::Permissions.

Examples found in repository

src/fs/metadata.rs (line 54)

    fn from_parts(std: fs::Metadata, ext: MetadataExt, file_type: FileType) -> Self {
        Self {
            file_type,
            len: std.len(),
            permissions: Permissions::from_std(std.permissions()),
            modified: std.modified().ok().map(SystemTime::from_std),
            accessed: std.accessed().ok().map(SystemTime::from_std),
            created: std.created().ok().map(SystemTime::from_std),
            ext,
        }
    }

pub fn into_std(self, file: &File) -> Result<Permissions>

Consumes self and produces a new instance of std::fs::Permissions.

The `file` parameter works around the fact that we can't construct a `Permissions` object ourselves on Windows.

Examples found in repository

src/rustix/fs/set_permissions_impl.rs (line 20)

pub(crate) fn set_permissions_impl(
    start: &fs::File,
    path: &Path,
    perm: Permissions,
) -> io::Result<()> {
    let std_perm = perm.into_std(start)?;

    // Try `fchmod` with a normal handle. Normal handles need some kind of
    // access, so first try read.
    match open(start, path, OpenOptions::new().read(true)) {
        Ok(file) => return set_file_permissions(&file, std_perm),
        Err(err) => match Errno::from_io_error(&err) {
            Some(Errno::ACCESS) => (),
            _ => return Err(err),
        },
    }

    // Next try write.
    match open(start, path, OpenOptions::new().write(true)) {
        Ok(file) => return set_file_permissions(&file, std_perm),
        Err(err) => match Errno::from_io_error(&err) {
            Some(Errno::ACCESS) | Some(Errno::ISDIR) => (),
            _ => return Err(err),
        },
    }

    // If neither of those worked, we're out of luck.
    Err(Errno::NOTSUP.into())
}

pub const fn readonly(&self) -> bool

Returns true if these permissions describe a readonly (unwritable) file.

This corresponds to std::fs::Permissions::readonly.

pub fn set_readonly(&mut self, readonly: bool)

Modifies the readonly flag for this set of permissions.

This corresponds to std::fs::Permissions::set_readonly.

Trait Implementations

impl Clone for Permissions

fn clone(&self) -> Permissions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Permissions

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

Formats the value using the given formatter.

impl PartialEq<Permissions> for Permissions

fn eq(&self, other: &Permissions) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PermissionsExt for Permissions

fn mode(&self) -> u32

Returns the underlying raw st_mode bits that contain the standard Unix permissions for this file.

fn set_mode(&mut self, mode: u32)

Sets the underlying raw bits for this set of permissions.

fn from_mode(mode: u32) -> Self

Creates a new instance of Permissions from the given set of Unix permission bits.

impl Eq for Permissions

impl StructuralEq for Permissions

impl StructuralPartialEq for Permissions