Cargo.lock

@@ -31,7 +31,7 @@ checksum = "a5f43f184355eefb8d17fc948dbecf6c13be3c141f20d834ae842193a448c72a"
 
 [[package]]
 name = "posix-acl"
-version = "0.1.5"
+version = "0.1.1"
 dependencies = [
  "acl-sys",
  "anyhow",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "posix-acl"
-version = "0.1.6"
+version = "0.1.1"
 edition = "2021"
 
 [dependencies]

src/lib.rs

@@ -35,22 +35,22 @@ pub static ACL_NONE: PermSet = PermSet::empty();
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Qualifier {
     UserObj,
-    User(u32),
     GroupObj,
+    Other,
+    User(u32),
     Group(u32),
     Mask,
-    Other,
 }
 
 impl Qualifier {
     pub fn get_tag(&self) -> i32 {
         match self {
             Qualifier::UserObj => ACL_USER_OBJ,
-            Qualifier::User(_) => ACL_USER,
             Qualifier::GroupObj => ACL_GROUP_OBJ,
+            Qualifier::Other => ACL_OTHER,
+            Qualifier::User(_) => ACL_USER,
             Qualifier::Group(_) => ACL_GROUP,
             Qualifier::Mask => ACL_MASK,
-            Qualifier::Other => ACL_OTHER,
         }
     }
 
@@ -63,16 +63,10 @@ impl Qualifier {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct ACLEntry(pub Qualifier, pub PermSet);
 
-impl PartialOrd for ACLEntry {
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.0.cmp(&other.0))
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
 pub struct PosixACL {
     pub entries: Vec<ACLEntry>,
 }
@@ -123,6 +117,8 @@ impl PosixACL {
                 return Err(anyhow!("Failed to get ACL entry"));
             }
 
+            println!("entry: {:?}", entry);
+
             let mut tag_type: i32 = 0;
             check_return(
                 unsafe { acl_get_tag_type(entry, &mut tag_type) },
@@ -165,6 +161,7 @@ impl PosixACL {
                 "acl_get_permset",
             );
 
+            println!("permset: {:?}", permset);
             let perm = if permset.is_null() {
                 0
             } else {
@@ -176,46 +173,6 @@ impl PosixACL {
             entries.push(ACLEntry(qual, permset));
         }
 
-                // There should be at leas a UserObj, GroupObj, Other and Mask on the non default ACL entries. If they dont exist, create them
-
-        if !default {
-            let mut found_user = false;
-            let mut found_group = false;
-            let mut found_other = false;
-            let mut found_mask: Option<PermSet> = None;
-
-            for ent in entries.iter() {
-                match ent.0 {
-                    Qualifier::UserObj => {
-                        found_user = true;
-                    }
-                    Qualifier::GroupObj => {
-                        found_group = true;
-                    }
-                    Qualifier::Other => {
-                        found_other = true;
-                    }
-                    Qualifier::Mask => found_mask = Some(ent.1),
-                    _ => {}
-                }
-            }
-
-            let def_perm = found_mask.unwrap_or(ACL_RWX);
-
-            if !found_user {
-                entries.push(ACLEntry(Qualifier::UserObj, def_perm.clone()));
-            }
-            if !found_group {
-                entries.push(ACLEntry(Qualifier::GroupObj, def_perm.clone()));
-            }
-            if !found_other {
-                entries.push(ACLEntry(Qualifier::Other, def_perm.clone()));
-            }
-            if found_mask.is_none() {
-                entries.push(ACLEntry(Qualifier::Mask, def_perm.clone()));
-            }
-        }
-
         Ok(PosixACL { entries })
     }
 
@@ -244,7 +201,6 @@ impl PosixACL {
     pub fn write<P: AsRef<Path>>(&self, path: P) -> Result<()> {
         // Write ACL to file
         self.write_type(path, ACL_TYPE_ACCESS)?;
-        // TODO: If necessary fix mask
         Ok(())
     }
 
@@ -282,6 +238,11 @@ impl PosixACL {
             return Err(anyhow!("Other entry is required"));
         }
 
+        let has_mask = self.entries.iter().any(|x| matches!(x.0, Qualifier::Mask));
+        if !has_mask {
+            return Err(anyhow!("Mask entry is required"));
+        }
+
         for acl_entry in &self.entries {
             let mut entry = null_mut();
             check_return(
@@ -342,6 +303,7 @@ impl<T> Drop for AclPtr<T> {
 }
 
 pub(crate) fn check_return(ret: i32, func: &str) {
+    println!("ret: {} fnc: {}", ret, func);
     assert_eq!(
         ret,
         0,
@@ -371,11 +333,9 @@ mod test {
         file.write_all(b"Hello, world!").unwrap();
 
         acl.write(path).unwrap();
-        acl.entries.sort();
-
-        let mut acl_r = PosixACL::new_from_file(path, false).unwrap();
-        acl_r.entries.sort();
 
+        let acl_r = PosixACL::new_from_file(path, false).unwrap();
+        println!("{:?}", acl);
         assert_eq!(acl.entries.len(), acl_r.entries.len());
         let missing = acl
             .entries