Struct ACL 

pub struct ACL {
    pub acl_revision: AclRevision,
    pub ace: Vec<ACE>,
}

Fields

acl_revision: AclRevision

ace: Vec<ACE>

Implementations

impl ACL

pub fn order_aces(&mut self)

Orders the ACEs in the ACL according to the standard order.

Note that since we do not have sufficient information about the inheritance, we only apply order which is independent of inheritance.

The following steps describe the preferred order:

1. ✅ All explicit ACEs are placed in a group before any inherited ACEs.
2. ✅ Within the group of explicit ACEs, access-denied ACEs are placed before access-allowed ACEs.
3. ❌ Inherited ACEs are placed in the order in which they are inherited. ACEs inherited from the child object’s parent come first, then ACEs inherited from the grandparent, and so on up the tree of objects.
4. ❌ For each level of inherited ACEs, access-denied ACEs are placed before access-allowed ACEs.

See more information on Order of ACEs in a DACL - MSDN

pub fn is_ace_sorted(&self) -> bool

Whether ACE ordering rules apply to this ACL.

See order_aces for the ordering rules.

pub fn insert_ace(&mut self, ace: ACE)

Insert an ACE into the ACL, maintaining the correct order. See order_aces for the ordering rules.

Trait Implementations

impl BinRead for ACL

type Args<'__binrw_generated_args_lifetime> = ()

The type used for the args parameter of read_args() and read_options().

fn read_options<R: Read + Seek>( __binrw_generated_var_reader: &mut R, __binrw_generated_var_endian: Endian, __binrw_generated_var_arguments: Self::Args<'_>, ) -> BinResult<Self>

Read Self from the reader using the given Endian and arguments.

fn read_be<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments and assuming big-endian byte order.

fn read_le<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read Self from the reader using default arguments and assuming little-endian byte order.

fn read_ne<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args<'a>: for<'a> Required,

Read T from the reader assuming native-endian byte order.

fn read_be_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader, assuming big-endian byte order, using the given arguments.

fn read_le_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader, assuming little-endian byte order, using the given arguments.

fn read_ne_args<R>(reader: &mut R, args: Self::Args<'_>) -> Result<Self, Error>

where R: Read + Seek,

Read T from the reader, assuming native-endian byte order, using the given arguments.

impl BinWrite for ACL

type Args<'__binrw_generated_args_lifetime> = ()

The type used for the args parameter of write_args() and write_options().

fn write_options<W: Write + Seek>( &self, __binrw_generated_var_writer: &mut W, __binrw_generated_var_endian: Endian, __binrw_generated_var_arguments: Self::Args<'_>, ) -> BinResult<()>

Write Self to the writer using the given Endian and arguments.

fn write_be<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming big-endian byte order.

fn write_le<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming little-endian byte order.

fn write_ne<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming native-endian byte order.

fn write_be_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming big-endian byte order, using the given arguments.

fn write_le_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming little-endian byte order, using the given arguments.

fn write_ne_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming native-endian byte order, using the given arguments.

impl Clone for ACL

fn clone(&self) -> ACL

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ACL

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

Formats the value using the given formatter.

impl PartialEq for ACL

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

impl StructuralPartialEq for ACL