Struct EntryXatBlob 

pub struct EntryXatBlob { /* private fields */ }

Wraps an AAEntryXATBlob handle.

Implementations

impl EntryXatBlob

pub fn new() -> Result<Self>

Wraps AAEntryXATBlobCreate.

pub fn from_encoded_data(data: &[u8]) -> Result<Self>

Wraps AAEntryXATBlobCreateWithEncodedData.

Examples found in repository

examples/09_aa_entry_blobs.rs (line 39)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let artifact_dir = artifact_dir("aa-entry-blobs");
    let dir = path_string(&artifact_dir);
    let source_name = "source.txt";
    let target_name = "target.txt";
    let source_path = path_string(&artifact_dir.join(source_name));
    let target_path = path_string(&artifact_dir.join(target_name));
    fs::write(&source_path, b"blob source")?;
    fs::write(&target_path, b"blob target")?;

    Command::new("xattr")
        .args(["-w", "com.example.compression-rs", "example", &source_path])
        .status()?;

    let acl_entry = AccessControlEntry {
        tag: 1,
        perms: 1 << 1,
        flags: 0,
        qualifier_type: AceQualifierType::User,
        qualifier: env::var("USER")?.into_bytes(),
    };
    let mut acl = EntryAclBlob::new()?;
    acl.append_entry(&acl_entry)?;
    let xat = EntryXatBlob::from_path(&dir, source_name, ArchiveFlags::empty())?;
    if !acl.is_empty() {
        let encoded = acl.encoded_data()?;
        let decoded = EntryAclBlob::from_encoded_data(&encoded)?;
        decoded.apply_to_path(&dir, target_name, ArchiveFlags::REPLACE_ATTRIBUTES)?;
    }
    let encoded_xat = xat.encoded_data()?;
    let decoded_xat = EntryXatBlob::from_encoded_data(&encoded_xat)?;
    decoded_xat.apply_to_path(&dir, target_name, ArchiveFlags::REPLACE_ATTRIBUTES)?;

    println!(
        "acl_entries={} xattrs={}",
        acl.entry_count(),
        xat.entry_count()
    );
    println!("✅ AppleArchive ACL/XAT blob helpers OK");
    Ok(())
}

pub fn from_path(dir: &str, path: &str, flags: ArchiveFlags) -> Result<Self>

Wraps AAEntryXATBlobCreateWithPath.

Examples found in repository

examples/09_aa_entry_blobs.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let artifact_dir = artifact_dir("aa-entry-blobs");
    let dir = path_string(&artifact_dir);
    let source_name = "source.txt";
    let target_name = "target.txt";
    let source_path = path_string(&artifact_dir.join(source_name));
    let target_path = path_string(&artifact_dir.join(target_name));
    fs::write(&source_path, b"blob source")?;
    fs::write(&target_path, b"blob target")?;

    Command::new("xattr")
        .args(["-w", "com.example.compression-rs", "example", &source_path])
        .status()?;

    let acl_entry = AccessControlEntry {
        tag: 1,
        perms: 1 << 1,
        flags: 0,
        qualifier_type: AceQualifierType::User,
        qualifier: env::var("USER")?.into_bytes(),
    };
    let mut acl = EntryAclBlob::new()?;
    acl.append_entry(&acl_entry)?;
    let xat = EntryXatBlob::from_path(&dir, source_name, ArchiveFlags::empty())?;
    if !acl.is_empty() {
        let encoded = acl.encoded_data()?;
        let decoded = EntryAclBlob::from_encoded_data(&encoded)?;
        decoded.apply_to_path(&dir, target_name, ArchiveFlags::REPLACE_ATTRIBUTES)?;
    }
    let encoded_xat = xat.encoded_data()?;
    let decoded_xat = EntryXatBlob::from_encoded_data(&encoded_xat)?;
    decoded_xat.apply_to_path(&dir, target_name, ArchiveFlags::REPLACE_ATTRIBUTES)?;

    println!(
        "acl_entries={} xattrs={}",
        acl.entry_count(),
        xat.entry_count()
    );
    println!("✅ AppleArchive ACL/XAT blob helpers OK");
    Ok(())
}

pub fn apply_to_path( &self, dir: &str, path: &str, flags: ArchiveFlags, ) -> Result<()>

Wraps AAEntryXATBlobApplyToPath.

Examples found in repository

examples/09_aa_entry_blobs.rs (line 40)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let artifact_dir = artifact_dir("aa-entry-blobs");
    let dir = path_string(&artifact_dir);
    let source_name = "source.txt";
    let target_name = "target.txt";
    let source_path = path_string(&artifact_dir.join(source_name));
    let target_path = path_string(&artifact_dir.join(target_name));
    fs::write(&source_path, b"blob source")?;
    fs::write(&target_path, b"blob target")?;

    Command::new("xattr")
        .args(["-w", "com.example.compression-rs", "example", &source_path])
        .status()?;

    let acl_entry = AccessControlEntry {
        tag: 1,
        perms: 1 << 1,
        flags: 0,
        qualifier_type: AceQualifierType::User,
        qualifier: env::var("USER")?.into_bytes(),
    };
    let mut acl = EntryAclBlob::new()?;
    acl.append_entry(&acl_entry)?;
    let xat = EntryXatBlob::from_path(&dir, source_name, ArchiveFlags::empty())?;
    if !acl.is_empty() {
        let encoded = acl.encoded_data()?;
        let decoded = EntryAclBlob::from_encoded_data(&encoded)?;
        decoded.apply_to_path(&dir, target_name, ArchiveFlags::REPLACE_ATTRIBUTES)?;
    }
    let encoded_xat = xat.encoded_data()?;
    let decoded_xat = EntryXatBlob::from_encoded_data(&encoded_xat)?;
    decoded_xat.apply_to_path(&dir, target_name, ArchiveFlags::REPLACE_ATTRIBUTES)?;

    println!(
        "acl_entries={} xattrs={}",
        acl.entry_count(),
        xat.entry_count()
    );
    println!("✅ AppleArchive ACL/XAT blob helpers OK");
    Ok(())
}

pub fn entry_count(&self) -> u32

Wraps AAEntryXATBlobGetEntry.

Examples found in repository

examples/09_aa_entry_blobs.rs (line 45)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let artifact_dir = artifact_dir("aa-entry-blobs");
    let dir = path_string(&artifact_dir);
    let source_name = "source.txt";
    let target_name = "target.txt";
    let source_path = path_string(&artifact_dir.join(source_name));
    let target_path = path_string(&artifact_dir.join(target_name));
    fs::write(&source_path, b"blob source")?;
    fs::write(&target_path, b"blob target")?;

    Command::new("xattr")
        .args(["-w", "com.example.compression-rs", "example", &source_path])
        .status()?;

    let acl_entry = AccessControlEntry {
        tag: 1,
        perms: 1 << 1,
        flags: 0,
        qualifier_type: AceQualifierType::User,
        qualifier: env::var("USER")?.into_bytes(),
    };
    let mut acl = EntryAclBlob::new()?;
    acl.append_entry(&acl_entry)?;
    let xat = EntryXatBlob::from_path(&dir, source_name, ArchiveFlags::empty())?;
    if !acl.is_empty() {
        let encoded = acl.encoded_data()?;
        let decoded = EntryAclBlob::from_encoded_data(&encoded)?;
        decoded.apply_to_path(&dir, target_name, ArchiveFlags::REPLACE_ATTRIBUTES)?;
    }
    let encoded_xat = xat.encoded_data()?;
    let decoded_xat = EntryXatBlob::from_encoded_data(&encoded_xat)?;
    decoded_xat.apply_to_path(&dir, target_name, ArchiveFlags::REPLACE_ATTRIBUTES)?;

    println!(
        "acl_entries={} xattrs={}",
        acl.entry_count(),
        xat.entry_count()
    );
    println!("✅ AppleArchive ACL/XAT blob helpers OK");
    Ok(())
}

pub fn is_empty(&self) -> bool

Wraps AAEntryXATBlobGetEntry.

pub fn entry(&self, index: u32) -> Result<NamedBlobEntry>

Wraps AAEntryXATBlobGetEntry.

pub fn entries(&self) -> Result<Vec<NamedBlobEntry>>

Wraps AAEntryXATBlobAppendEntry.

pub fn append_entry(&mut self, entry: &NamedBlobEntry) -> Result<()>

Wraps AAEntryXATBlobAppendEntry.

pub fn set_entry(&mut self, index: u32, entry: &NamedBlobEntry) -> Result<()>

Wraps AAEntryXATBlobSetEntry.

pub fn clear(&mut self) -> Result<()>

Wraps AAEntryXATBlobClear.

pub fn remove_entry(&mut self, index: u32) -> Result<()>

Wraps AAEntryXATBlobRemoveEntry.

pub fn encoded_size(&self) -> usize

Wraps AAEntryXATBlobGetEncodedData.

pub fn encoded_data(&self) -> Result<Vec<u8>>

Wraps AAEntryXATBlobGetEncodedData.

Examples found in repository

examples/09_aa_entry_blobs.rs (line 38)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let artifact_dir = artifact_dir("aa-entry-blobs");
    let dir = path_string(&artifact_dir);
    let source_name = "source.txt";
    let target_name = "target.txt";
    let source_path = path_string(&artifact_dir.join(source_name));
    let target_path = path_string(&artifact_dir.join(target_name));
    fs::write(&source_path, b"blob source")?;
    fs::write(&target_path, b"blob target")?;

    Command::new("xattr")
        .args(["-w", "com.example.compression-rs", "example", &source_path])
        .status()?;

    let acl_entry = AccessControlEntry {
        tag: 1,
        perms: 1 << 1,
        flags: 0,
        qualifier_type: AceQualifierType::User,
        qualifier: env::var("USER")?.into_bytes(),
    };
    let mut acl = EntryAclBlob::new()?;
    acl.append_entry(&acl_entry)?;
    let xat = EntryXatBlob::from_path(&dir, source_name, ArchiveFlags::empty())?;
    if !acl.is_empty() {
        let encoded = acl.encoded_data()?;
        let decoded = EntryAclBlob::from_encoded_data(&encoded)?;
        decoded.apply_to_path(&dir, target_name, ArchiveFlags::REPLACE_ATTRIBUTES)?;
    }
    let encoded_xat = xat.encoded_data()?;
    let decoded_xat = EntryXatBlob::from_encoded_data(&encoded_xat)?;
    decoded_xat.apply_to_path(&dir, target_name, ArchiveFlags::REPLACE_ATTRIBUTES)?;

    println!(
        "acl_entries={} xattrs={}",
        acl.entry_count(),
        xat.entry_count()
    );
    println!("✅ AppleArchive ACL/XAT blob helpers OK");
    Ok(())
}

Trait Implementations

impl Clone for EntryXatBlob

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EntryXatBlob

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

Formats the value using the given formatter.

impl Drop for EntryXatBlob

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.