Enum landlock::AccessFs

#[repr(u64)]
#[non_exhaustive]
pub enum AccessFs {
    Execute,
    WriteFile,
    ReadFile,
    ReadDir,
    RemoveDir,
    RemoveFile,
    MakeChar,
    MakeDir,
    MakeReg,
    MakeSock,
    MakeFifo,
    MakeBlock,
    MakeSym,
    Refer,
}

File system access right.

Each variant of AccessFs is an access right for the file system. A set of access rights can be created with BitFlags<AccessFs>.

Example

use landlock::{ABI, Access, AccessFs, BitFlags, make_bitflags};

let exec = AccessFs::Execute;

let exec_set: BitFlags<AccessFs> = exec.into();

let file_content = make_bitflags!(AccessFs::{Execute | WriteFile | ReadFile});

let fs_v1 = AccessFs::from_all(ABI::V1);

let without_exec = fs_v1 & !AccessFs::Execute;

assert_eq!(fs_v1 | AccessFs::Refer, AccessFs::from_all(ABI::V2));

Warning

To avoid compile time behavior at run time, which may look like undefined behavior, don’t use BitFlags::<AccessFs>::all() nor BitFlags::ALL, but AccessFs::from_all(ABI::V1) instead. See ABI for the rational.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Execute

Execute a file.

WriteFile

Open a file with write access.

ReadFile

Open a file with read access.

ReadDir

Open a directory or list its content.

RemoveDir

Remove an empty directory or rename one.

RemoveFile

Unlink (or rename) a file.

MakeChar

Create (or rename or link) a character device.

MakeDir

Create (or rename) a directory.

MakeReg

Create (or rename or link) a regular file.

MakeSock

Create (or rename or link) a UNIX domain socket.

MakeFifo

Create (or rename or link) a named pipe.

MakeBlock

Create (or rename or link) a block device.

MakeSym

Create (or rename or link) a symbolic link.

Refer

Link or rename a file from or to a different directory.

Trait Implementations

impl Access for AccessFs

fn from_read(abi: ABI) -> BitFlags<Self>

Gets the access rights identified as read-only according to a specific ABI. Exclusive with from_write().

fn from_write(abi: ABI) -> BitFlags<Self>

Gets the access rights identified as write-only according to a specific ABI. Exclusive with from_read().

fn from_all(abi: ABI) -> BitFlags<Self>

Gets the access rights defined by a specific ABI. Union of from_read() and from_write().

impl BitAnd<AccessFs> for AccessFs

type Output = BitFlags<AccessFs, <AccessFs as RawBitFlags>::Numeric>

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> Self::Output

Performs the & operation.

impl BitFlag for AccessFs

fn empty() -> BitFlags<Self, Self::Numeric>

Create a BitFlags with no flags set (in other words, with a value of 0).

fn all() -> BitFlags<Self, Self::Numeric>

Create a BitFlags with all flags set.

impl BitOr<AccessFs> for AccessFs

type Output = BitFlags<AccessFs, <AccessFs as RawBitFlags>::Numeric>

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Self::Output

Performs the | operation.

impl BitXor<AccessFs> for AccessFs

type Output = BitFlags<AccessFs, <AccessFs as RawBitFlags>::Numeric>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Self) -> Self::Output

Performs the ^ operation.

impl Clone for AccessFs

fn clone(&self) -> AccessFs

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AccessFs

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

Formats the value using the given formatter.

impl Not for AccessFs

type Output = BitFlags<AccessFs, <AccessFs as RawBitFlags>::Numeric>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq<AccessFs> for AccessFs

fn eq(&self, other: &AccessFs) -> 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 RawBitFlags for AccessFs

type Numeric = u64

The underlying integer type.

const EMPTY: Self::Numeric = {transmute(0x0000000000000000): <fs::AccessFs as enumflags2::_internal::RawBitFlags>::Numeric}

A value with no bits set.

const DEFAULT: Self::Numeric = {transmute(0x0000000000000000): <fs::AccessFs as enumflags2::_internal::RawBitFlags>::Numeric}

The value used by the Default implementation. Equivalent to EMPTY, unless customized.

const ALL_BITS: Self::Numeric = {transmute(0x0000000000003fff): <fs::AccessFs as enumflags2::_internal::RawBitFlags>::Numeric}

A value with all flag bits set.

const BITFLAGS_TYPE_NAME: &'static str = _

The name of the type for debug formatting purposes.

fn bits(self) -> Self::Numeric

Return the bits as a number type.

impl Copy for AccessFs

impl Eq for AccessFs

impl<F> Rule<AccessFs> for PathBeneath<F>where F: AsFd,

impl StructuralEq for AccessFs

impl StructuralPartialEq for AccessFs