⚗️ Add --fflags option to cli and add private chunk for store fflags

ChanTsune · ChanTsune · commit 62cf0395d8ed · 2025-12-24T18:03:31.000+09:00
diff --git a/cli/src/chunk.rs b/cli/src/chunk.rs
@@ -1,3 +1,5 @@
 mod acl;
+mod fflag;
 
 pub use acl::*;
+pub use fflag::*;
diff --git a/cli/src/chunk/fflag.rs b/cli/src/chunk/fflag.rs
@@ -0,0 +1,14 @@
+use pna::{ChunkType, RawChunk};
+
+/// Private chunk type for file flags (fflags).
+/// Name follows PNA chunk naming convention where case has semantic meaning:
+/// - lowercase first letter: ancillary (not critical)
+/// - lowercase second letter: private (not public)
+/// - uppercase third letter: reserved
+/// - lowercase fourth letter: safe to copy
+#[allow(non_upper_case_globals)]
+pub const ffLg: ChunkType = unsafe { ChunkType::from_unchecked(*b"ffLg") };
+
+pub fn fflag_chunk(flag: &str) -> RawChunk {
+    RawChunk::from_data(ffLg, flag.as_bytes())
+}
diff --git a/cli/src/command/append.rs b/cli/src/command/append.rs
@@ -6,9 +6,10 @@ use crate::{
     command::{
         Command, ask_password, check_password,
         core::{
-            AclStrategy, CreateOptions, KeepOptions, OwnerOptions, PathFilter, PathTransformers,
-            PathnameEditor, PermissionStrategy, StoreAs, TimeFilterResolver, TimeOptions,
-            TimestampStrategy, XattrStrategy, collect_items, create_entry, entry_option,
+            AclStrategy, CreateOptions, FflagsStrategy, KeepOptions, OwnerOptions, PathFilter,
+            PathTransformers, PathnameEditor, PermissionStrategy, StoreAs, TimeFilterResolver,
+            TimeOptions, TimestampStrategy, XattrStrategy, collect_items, create_entry,
+            entry_option,
             re::{bsd::SubstitutionRule, gnu::TransformRule},
             read_paths, read_paths_stdin,
         },
@@ -339,6 +340,7 @@ fn append_to_archive(args: AppendCommand) -> anyhow::Result<()> {
         ),
         xattr_strategy: XattrStrategy::from_flags(args.keep_xattr, args.no_keep_xattr),
         acl_strategy: AclStrategy::from_flags(args.keep_acl, args.no_keep_acl),
+        fflags_strategy: FflagsStrategy::Never,
     };
     let owner_options = OwnerOptions::new(
         args.uname,
diff --git a/cli/src/command/core.rs b/cli/src/command/core.rs
@@ -159,12 +159,31 @@ impl AclStrategy {
     }
 }
 
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub(crate) enum FflagsStrategy {
+    Never,
+    Always,
+}
+
+impl FflagsStrategy {
+    pub(crate) const fn from_flags(keep_fflags: bool, no_keep_fflags: bool) -> Self {
+        if no_keep_fflags {
+            Self::Never
+        } else if keep_fflags {
+            Self::Always
+        } else {
+            Self::Never
+        }
+    }
+}
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub(crate) struct KeepOptions {
     pub(crate) timestamp_strategy: TimestampStrategy,
     pub(crate) permission_strategy: PermissionStrategy,
     pub(crate) xattr_strategy: XattrStrategy,
     pub(crate) acl_strategy: AclStrategy,
+    pub(crate) fflags_strategy: FflagsStrategy,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -730,6 +749,23 @@ pub(crate) fn apply_metadata<'p>(
     if let XattrStrategy::Always = keep_options.xattr_strategy {
         log::warn!("Currently extended attribute is not supported on this platform.");
     }
+    if let FflagsStrategy::Always = keep_options.fflags_strategy {
+        match utils::fs::get_flags(path) {
+            Ok(flags) => {
+                for flag in flags {
+                    entry.add_extra_chunk(crate::chunk::fflag_chunk(&flag));
+                }
+            }
+            Err(e) if e.kind() == std::io::ErrorKind::Unsupported => {
+                log::warn!(
+                    "File flags are not supported on filesystem for '{}': {}",
+                    path.display(),
+                    e
+                );
+            }
+            Err(e) => return Err(e),
+        }
+    }
     Ok(entry)
 }
 
diff --git a/cli/src/command/create.rs b/cli/src/command/create.rs
@@ -6,10 +6,10 @@ use crate::{
     command::{
         Command, ask_password, check_password,
         core::{
-            AclStrategy, CreateOptions, KeepOptions, MIN_SPLIT_PART_BYTES, OwnerOptions,
-            PathFilter, PathTransformers, PathnameEditor, PermissionStrategy, StoreAs,
-            TimeFilterResolver, TimeOptions, TimestampStrategy, XattrStrategy, collect_items,
-            create_entry, entry_option,
+            AclStrategy, CreateOptions, FflagsStrategy, KeepOptions, MIN_SPLIT_PART_BYTES,
+            OwnerOptions, PathFilter, PathTransformers, PathnameEditor, PermissionStrategy,
+            StoreAs, TimeFilterResolver, TimeOptions, TimestampStrategy, XattrStrategy,
+            collect_items, create_entry, entry_option,
             re::{bsd::SubstitutionRule, gnu::TransformRule},
             read_paths, read_paths_stdin, write_split_archive,
         },
@@ -423,6 +423,7 @@ fn create_archive(args: CreateCommand) -> anyhow::Result<()> {
         ),
         xattr_strategy: XattrStrategy::from_flags(args.keep_xattr, args.no_keep_xattr),
         acl_strategy: AclStrategy::from_flags(args.keep_acl, args.no_keep_acl),
+        fflags_strategy: FflagsStrategy::Never,
     };
     let owner_options = OwnerOptions::new(
         args.uname,
diff --git a/cli/src/command/extract.rs b/cli/src/command/extract.rs
@@ -9,8 +9,9 @@ use crate::{
     command::{
         Command, ask_password,
         core::{
-            AclStrategy, KeepOptions, OwnerOptions, PathFilter, PathTransformers, PathnameEditor,
-            PermissionStrategy, TimestampStrategy, XattrStrategy, collect_split_archives,
+            AclStrategy, FflagsStrategy, KeepOptions, OwnerOptions, PathFilter, PathTransformers,
+            PathnameEditor, PermissionStrategy, TimestampStrategy, XattrStrategy,
+            collect_split_archives,
             path_lock::PathLocks,
             re::{bsd::SubstitutionRule, gnu::TransformRule},
             read_paths, run_process_archive,
@@ -280,6 +281,7 @@ fn extract_archive(args: ExtractCommand) -> anyhow::Result<()> {
         ),
         xattr_strategy: XattrStrategy::from_flags(args.keep_xattr, args.no_keep_xattr),
         acl_strategy: AclStrategy::from_flags(args.keep_acl, args.no_keep_acl),
+        fflags_strategy: FflagsStrategy::Never,
     };
     let owner_options = OwnerOptions::new(
         args.uname,
@@ -754,6 +756,29 @@ where
     if let AclStrategy::Always = keep_options.acl_strategy {
         log::warn!("Please enable `acl` feature and rebuild and install pna.");
     }
+    if let FflagsStrategy::Always = keep_options.fflags_strategy {
+        let mut flags = Vec::new();
+        for chunk in item.extra_chunks() {
+            if chunk.ty() == crate::chunk::ffLg {
+                if let Ok(flag) = std::str::from_utf8(chunk.data()) {
+                    flags.push(flag.to_string());
+                }
+            }
+        }
+        if !flags.is_empty() {
+            match utils::fs::set_flags(path, &flags) {
+                Ok(()) => {}
+                Err(e) if e.kind() == std::io::ErrorKind::Unsupported => {
+                    log::warn!(
+                        "File flags are not supported on filesystem for '{}': {}",
+                        path.display(),
+                        e
+                    );
+                }
+                Err(e) => return Err(e),
+            }
+        }
+    }
     Ok(())
 }
 
diff --git a/cli/src/command/stdio.rs b/cli/src/command/stdio.rs
@@ -8,9 +8,9 @@ use crate::{
         append::{open_archive_then_seek_to_end, run_append_archive},
         ask_password, check_password,
         core::{
-            AclStrategy, CreateOptions, KeepOptions, OwnerOptions, PathFilter, PathTransformers,
-            PathnameEditor, PermissionStrategy, TimeFilterResolver, TimeOptions, TimestampStrategy,
-            XattrStrategy, collect_items, collect_split_archives, entry_option,
+            AclStrategy, CreateOptions, FflagsStrategy, KeepOptions, OwnerOptions, PathFilter,
+            PathTransformers, PathnameEditor, PermissionStrategy, TimeFilterResolver, TimeOptions,
+            TimestampStrategy, XattrStrategy, collect_items, collect_split_archives, entry_option,
             path_lock::PathLocks,
             re::{bsd::SubstitutionRule, gnu::TransformRule},
             read_paths,
@@ -73,6 +73,7 @@ use std::{env, io, path::PathBuf, sync::Arc, time::SystemTime};
     group(ArgGroup::new("ctime-newer-than-source").args(["newer_ctime", "newer_ctime_than"])),
     group(ArgGroup::new("mtime-older-than-source").args(["older_mtime", "older_mtime_than"])),
     group(ArgGroup::new("mtime-newer-than-source").args(["newer_mtime", "newer_mtime_than"])),
+    group(ArgGroup::new("keep-fflags-flag").args(["keep_fflags", "no_keep_fflags"])),
 )]
 #[cfg_attr(windows, command(
     group(ArgGroup::new("windows-unstable-keep-permission").args(["keep_permission", "no_keep_permission"]).requires("unstable")),
@@ -190,6 +191,18 @@ pub(crate) struct StdioCommand {
         help = "Do not archive acl of files. This is the inverse option of --keep-acl (unstable)"
     )]
     no_keep_acl: bool,
+    #[arg(
+        long,
+        visible_aliases = ["preserve-fflags", "fflags"],
+        help = "Archiving the file flags of the files (unstable)"
+    )]
+    keep_fflags: bool,
+    #[arg(
+        long,
+        visible_aliases = ["no-preserve-fflags", "no-fflags"],
+        help = "Do not archive file flags of files. This is the inverse option of --keep-fflags (unstable)"
+    )]
+    no_keep_fflags: bool,
     #[arg(long, help = "Solid mode archive")]
     pub(crate) solid: bool,
     #[command(flatten)]
@@ -526,6 +539,7 @@ fn run_create_archive(args: StdioCommand) -> anyhow::Result<()> {
         ),
         xattr_strategy: XattrStrategy::from_flags(args.keep_xattr, args.no_keep_xattr),
         acl_strategy: AclStrategy::from_flags(args.keep_acl, args.no_keep_acl),
+        fflags_strategy: FflagsStrategy::from_flags(args.keep_fflags, args.no_keep_fflags),
     };
     let owner_options = OwnerOptions::new(
         args.uname,
@@ -606,6 +620,7 @@ fn run_extract_archive(args: StdioCommand) -> anyhow::Result<()> {
             ),
             xattr_strategy: XattrStrategy::from_flags(args.keep_xattr, args.no_keep_xattr),
             acl_strategy: AclStrategy::from_flags(args.keep_acl, args.no_keep_acl),
+            fflags_strategy: FflagsStrategy::from_flags(args.keep_fflags, args.no_keep_fflags),
         },
         owner_options: OwnerOptions::new(
             args.uname,
@@ -736,6 +751,7 @@ fn run_append(args: StdioCommand) -> anyhow::Result<()> {
         ),
         xattr_strategy: XattrStrategy::from_flags(args.keep_xattr, args.no_keep_xattr),
         acl_strategy: AclStrategy::from_flags(args.keep_acl, args.no_keep_acl),
+        fflags_strategy: FflagsStrategy::from_flags(args.keep_fflags, args.no_keep_fflags),
     };
     let owner_options = OwnerOptions::new(
         args.uname,
diff --git a/cli/src/command/update.rs b/cli/src/command/update.rs
@@ -10,10 +10,11 @@ use crate::{
     command::{
         Command, ask_password, check_password,
         core::{
-            AclStrategy, CreateOptions, KeepOptions, OwnerOptions, PathFilter, PathTransformers,
-            PathnameEditor, PermissionStrategy, TimeFilterResolver, TimeOptions, TimestampStrategy,
-            TransformStrategy, TransformStrategyKeepSolid, TransformStrategyUnSolid, XattrStrategy,
-            collect_items, collect_split_archives, create_entry, entry_option,
+            AclStrategy, CreateOptions, FflagsStrategy, KeepOptions, OwnerOptions, PathFilter,
+            PathTransformers, PathnameEditor, PermissionStrategy, TimeFilterResolver, TimeOptions,
+            TimestampStrategy, TransformStrategy, TransformStrategyKeepSolid,
+            TransformStrategyUnSolid, XattrStrategy, collect_items, collect_split_archives,
+            create_entry, entry_option,
             re::{bsd::SubstitutionRule, gnu::TransformRule},
             read_paths, read_paths_stdin,
         },
@@ -348,6 +349,7 @@ fn update_archive<Strategy: TransformStrategy>(args: UpdateCommand) -> anyhow::R
         ),
         xattr_strategy: XattrStrategy::from_flags(args.keep_xattr, args.no_keep_xattr),
         acl_strategy: AclStrategy::from_flags(args.keep_acl, args.no_keep_acl),
+        fflags_strategy: FflagsStrategy::Never,
     };
     let owner_options = OwnerOptions::new(
         args.uname,
diff --git a/cli/src/utils/fs.rs b/cli/src/utils/fs.rs
@@ -66,6 +66,50 @@ pub(crate) fn lchown<P: AsRef<Path>>(
     inner(path.as_ref(), owner, group)
 }
 
+pub(crate) fn get_flags<P: AsRef<Path>>(path: P) -> io::Result<Vec<String>> {
+    #[cfg(any(
+        target_os = "macos",
+        target_os = "linux",
+        target_os = "android",
+        target_os = "freebsd"
+    ))]
+    fn inner(path: &Path) -> io::Result<Vec<String>> {
+        crate::utils::os::unix::fs::get_flags(path)
+    }
+    #[cfg(not(any(
+        target_os = "macos",
+        target_os = "linux",
+        target_os = "android",
+        target_os = "freebsd"
+    )))]
+    fn inner(_path: &Path) -> io::Result<Vec<String>> {
+        Ok(Vec::new())
+    }
+    inner(path.as_ref())
+}
+
+pub(crate) fn set_flags<P: AsRef<Path>>(path: P, flags: &[String]) -> io::Result<()> {
+    #[cfg(any(
+        target_os = "macos",
+        target_os = "linux",
+        target_os = "android",
+        target_os = "freebsd"
+    ))]
+    fn inner(path: &Path, flags: &[String]) -> io::Result<()> {
+        crate::utils::os::unix::fs::set_flags(path, flags)
+    }
+    #[cfg(not(any(
+        target_os = "macos",
+        target_os = "linux",
+        target_os = "android",
+        target_os = "freebsd"
+    )))]
+    fn inner(_path: &Path, _flags: &[String]) -> io::Result<()> {
+        Ok(())
+    }
+    inner(path.as_ref(), flags)
+}
+
 #[inline]
 pub(crate) fn file_create(path: impl AsRef<Path>, overwrite: bool) -> io::Result<fs::File> {
     if overwrite {
diff --git a/cli/src/utils/fs/nodump.rs b/cli/src/utils/fs/nodump.rs
@@ -1,48 +1,9 @@
-#[cfg(any(target_os = "linux", target_os = "android"))]
-mod platform {
-    use nix::{
-        fcntl::{OFlag, open},
-        ioctl_read_bad,
-        sys::stat::Mode,
-    };
-    use std::os::fd::AsRawFd;
-    use std::{io, path::Path};
-
-    const FS_NODUMP_FL: libc::c_int = 0x00000040;
-
-    ioctl_read_bad!(fs_ioc_getflags, libc::FS_IOC_GETFLAGS, libc::c_int);
-
-    pub(crate) fn is_nodump(path: &Path) -> io::Result<bool> {
-        let fd = open(path, OFlag::O_RDONLY | OFlag::O_NOFOLLOW, Mode::empty())?;
-        let mut flags: libc::c_int = 0;
-        unsafe { fs_ioc_getflags(fd.as_raw_fd(), &mut flags) }?;
-        Ok((flags & FS_NODUMP_FL) != 0)
-    }
-}
-
-#[cfg(any(target_os = "macos", target_os = "freebsd"))]
-mod platform {
-    use nix::sys::stat::lstat;
-    use std::{io, path::Path};
-
-    pub(crate) fn is_nodump(path: &Path) -> io::Result<bool> {
-        let stat = lstat(path)?;
-        Ok((stat.st_flags & libc::UF_NODUMP as libc::c_uint) != 0)
-    }
+use crate::utils::fs::get_flags;
+use std::{io, path::Path};
+
+/// Check if the file has the nodump flag set.
+/// This is used to skip files during backup operations.
+pub(crate) fn is_nodump(path: &Path) -> io::Result<bool> {
+    let flags = get_flags(path)?;
+    Ok(flags.iter().any(|f| f == "nodump"))
 }
-
-#[cfg(not(any(
-    target_os = "linux",
-    target_os = "android",
-    target_os = "macos",
-    target_os = "freebsd"
-)))]
-mod platform {
-    use std::{io, path::Path};
-
-    pub(crate) fn is_nodump(_path: &Path) -> io::Result<bool> {
-        Ok(false)
-    }
-}
-
-pub(crate) use platform::is_nodump;
diff --git a/cli/src/utils/os/unix/fs.rs b/cli/src/utils/os/unix/fs.rs
diff --git a/verify_fflags.sh b/verify_fflags.sh
