Enum Erratum 

#[non_exhaustive]
#[repr(u32)]
pub enum Erratum {
    TcpSocketIdentification = 1,
    ScopedSignalHandling = 2,
    DisconnectedDirectoryHandling = 4,
}

Fixed kernel issues for the running Landlock implementation.

Each variant represents a specific bug fix that may have been backported to the running kernel. Use Erratum::current() before building a Ruleset to decide which features are safe to use.

An ABI version can be converted into the set of applicable errata with BitFlags::<Erratum>::from(abi).

Warning

Most applications should not check errata. Disabling a sandboxing feature because an erratum is not fixed could leave the system less secure than using Landlock’s best-effort protection with the buggy feature enabled. Errata should only be used to add features (e.g., enabling a restriction only when its bug is confirmed fixed), never to remove them.

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.

TcpSocketIdentification = 1

Erratum 1 (ABI 4): non-TCP stream sockets (SMC, MPTCP, SCTP) were incorrectly restricted by TCP access rights during bind(2) and connect(2).

Affects crate::AccessNet::BindTcp and crate::AccessNet::ConnectTcp.

See erratum 1.

ScopedSignalHandling = 2

Erratum 2 (ABI 6): signal scoping was overly restrictive, preventing sandboxed threads from signaling other threads within the same process in different domains.

Affects crate::Scope::Signal.

See erratum 2.

DisconnectedDirectoryHandling = 4

Erratum 3 (ABI 1): access rights could be widened through rename or link actions on disconnected directories under bind mounts, potentially bypassing LANDLOCK_ACCESS_FS_REFER restrictions.

See erratum 3.

Implementations

impl Erratum

pub fn current() -> BitFlags<Self>

Queries the running kernel for fixed errata.

Returns a bitmask of errata that have been fixed in the running kernel. Unknown errata bits from newer kernels are preserved. Returns empty if the kernel doesn’t support the errata interface.

Trait Implementations

impl BitAnd for Erratum

type Output = BitFlags<Erratum>

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitFlag for Erratum

fn empty() -> BitFlags<Self>

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

fn all() -> BitFlags<Self>

Create a BitFlags with all flags set.

fn from_bits(bits: Self::Numeric) -> Result<BitFlags<Self>, FromBitsError<Self>>

Create a BitFlags if the raw value provided does not contain any illegal flags.

fn from_bits_truncate(bits: Self::Numeric) -> BitFlags<Self>

Create a BitFlags from an underlying bitwise value. If any invalid bits are set, ignore them.

unsafe fn from_bits_unchecked(bits: Self::Numeric) -> BitFlags<Self>

Create a BitFlags unsafely, without checking if the bits form a valid bit pattern for the type.

impl BitOr for Erratum

type Output = BitFlags<Erratum>

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitXor for Erratum

type Output = BitFlags<Erratum>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl Clone for Erratum

fn clone(&self) -> Erratum

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Erratum

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

Formats the value using the given formatter.

impl Not for Erratum

type Output = BitFlags<Erratum>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for Erratum

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl RawBitFlags for Erratum

const EMPTY: <Self as RawBitFlags>::Numeric = 0

A value with no bits set.

const DEFAULT: <Self as RawBitFlags>::Numeric = 0

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

const ALL_BITS: <Self as RawBitFlags>::Numeric

A value with all flag bits set.

const BITFLAGS_TYPE_NAME: &'static str = "BitFlags<Erratum>"

The name of the type for debug formatting purposes.

type Numeric = u32

The underlying integer type.

fn bits(self) -> <Self as RawBitFlags>::Numeric

Return the bits as a number type.

impl Copy for Erratum

impl Eq for Erratum

impl StructuralPartialEq for Erratum