Initial implementation of file/inode flags (Linux, BSD, darwin)

Basic support for BSD and Darwin style chflags (stat flags). Applies
these flags at the end of file restore.
Supports linux style ioctl_iflags(2) in a 2 step process. Flags that
need to be applied prior to writes such as compress and especially no-COW
are applied immediately upon file open.

The flags format is backwards compatible. An attribute starting with a
null byte is used to store flags in the entry attributes table. With
an old version of duplicacy the restore of this attribute should silently
fail (effectively be ignored).

Fixes xattr restore to use O_NOFOLLOW so attributes are applied to symlink.

TODO: Tests, possible option to switch off mutable/append prior to
restore of existing file similar to rsync. Does not apply attributes
or flags to the top most directory.

src/duplicacy_backupmanager.go

@@ -304,24 +304,7 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta
 			remoteEntry = nil
 		}
 
-		if localEntry.IsHardlinkedFrom() {
-			// FIXME: Sanity check?
-			// FIXME: perhaps we can make size = 0 an initial invariant of the link?
-			//
-			// Note that if the initial size was 0 then this original logic doesn't change!
-			localEntry.Size = 0
-			// targetEntry, ok := localEntryList.HardLinkTable[localEntry.Link]
-			// if !ok {
-			// 	LOG_ERROR("BACKUP_CREATE", "Hard link %s not found in entry cache for path %s", localEntry.Link, localEntry.Path)
-			// }
-			// localEntry.Size = targetEntry.Size
-			// localEntry.Hash = targetEntry.Hash
-			// localEntry.StartChunk = targetEntry.StartChunk
-			// localEntry.StartOffset = targetEntry.StartOffset
-			// localEntry.EndChunk = targetEntry.EndChunk
-			// localEntry.EndOffset = targetEntry.EndOffset
-			// LOG_DEBUG("BACKUP_CREATE", "Hard link %s to %s in initial listing", localEntry.Link, targetEntry.Path)
-		} else if compareResult == 0  {
+		if compareResult == 0  {
 			// No need to check if it is in hash mode -- in that case remote listing is nil
 			if localEntry.IsSameAs(remoteEntry) && localEntry.IsFile() {
 				if localEntry.Size > 0 {
@@ -639,11 +622,6 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta
 	return true
 }
 
-type hardLinkEntry struct {
-	entry *Entry
-	willDownload bool
-}
-
 // Restore downloads the specified snapshot, compares it with what's on the repository, and then downloads
 // files that are different. 'base' is a directory that contains files at a different revision which can
 // serve as a local cache to avoid download chunks available locally.  It is perfectly ok for 'base' to be
@@ -725,16 +703,8 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 	var localEntry *Entry
 	localListingOK := true
 
-	hardLinkTable := make(map[string]hardLinkEntry)
-	//hardLinks := make([]*Entry, 0)
-
 	for remoteEntry := range remoteListingChannel {
 
-		if remoteEntry.IsFile() && remoteEntry.Link == "/" {
-			LOG_INFO("RESTORE_LINK", "Noting hardlinked source file %s", remoteEntry.Path)
-			hardLinkTable[remoteEntry.Path] = hardLinkEntry{remoteEntry, false}
-		}
-
 		if len(patterns) > 0 && !MatchPath(remoteEntry.Path, patterns) {
 			continue
 		}
@@ -743,8 +713,6 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 		var compareResult int
 
 		for {
-			// TODO: We likely need to check if a local listing file exists in the hardLinkTable for the case where one is restoring a hardlink
-			// to an existing disk file. Right now, we'll just end up downloading the file new.
 			if localEntry == nil && localListingOK {
 				localEntry, localListingOK = <- localListingChannel
 			}
@@ -762,28 +730,12 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 		}
 
 		if compareResult == 0 {
-			// if quickMode && localEntry.IsFile() {
-				if quickMode && localEntry.IsFile() && localEntry.IsSameAs(remoteEntry) {
-					LOG_TRACE("RESTORE_SKIP", "File %s unchanged (by size and timestamp)", localEntry.Path)
-					skippedFileSize += localEntry.Size
-					skippedFileCount++
-					localEntry = nil
-					continue
-				// checkEntry := remoteEntry
-				// if len(remoteEntry.Link) > 0 && remoteEntry.Link != "/" {
-				// 	if e, ok := hardLinkTable[remoteEntry.Link]; !ok {
-				// 		LOG_ERROR("RESTORE_LINK", "Source file %s for hardlink %s missing", remoteEntry.Link, remoteEntry.Path)
-				// 	} else {
-				// 		checkEntry = e.entry
-				// 	}
-				// }
-				// if localEntry.IsSameAs(checkEntry) {
-				// 	LOG_TRACE("RESTORE_SKIP", "File %s unchanged (by size and timestamp)", localEntry.Path)
-				// 	skippedFileSize += localEntry.Size
-				// 	skippedFileCount++
-				// 	localEntry = nil
-				// 	continue
-				// }
+			if quickMode && localEntry.IsFile() && localEntry.IsSameAs(remoteEntry) {
+				LOG_TRACE("RESTORE_SKIP", "File %s unchanged (by size and timestamp)", localEntry.Path)
+				skippedFileSize += localEntry.Size
+				skippedFileCount++
+				localEntry = nil
+				continue
 			}
 			localEntry = nil
 		}
@@ -828,23 +780,9 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 					return 0
 				}
 			}
+			remoteEntry.RestoreEarlyDirFlags(fullPath)
 			directoryEntries = append(directoryEntries, remoteEntry)
 		} else {
-			// if remoteEntry.Link == "/" {
-			// 	hardLinkTable[remoteEntry.Path] = hardLinkEntry{remoteEntry, true}
-			// } else if len(remoteEntry.Link) > 0 {
-			// 	if e, ok := hardLinkTable[remoteEntry.Link]; !ok {
-			// 		LOG_ERROR("RESTORE_LINK", "Source file %s for hardlink %s missing", remoteEntry.Link, remoteEntry.Path)
-			// 	} else if !e.willDownload {
-			// 		origSourcePath := e.entry.Path
-			// 		e.entry.Path = remoteEntry.Path
-			// 		remoteEntry = e.entry
-			// 		hardLinkTable[origSourcePath] = hardLinkEntry{remoteEntry, true}
-			// 	} else {
-			// 		hardLinks = append(hardLinks, remoteEntry)
-			// 		continue
-			// 	}
-			// }
 			// We can't download files here since fileEntries needs to be sorted
 			fileEntries = append(fileEntries, remoteEntry)
 			totalFileSize += remoteEntry.Size
@@ -900,10 +838,6 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 		stat, _ := os.Stat(fullPath)
 		if stat != nil {
 			if quickMode {
-				// cmpFile := file
-				// if file.IsFile() && len(file.Link) > 0 && file.Link != "/" {
-				// 	cmpFile = hardLinkTable[file.Link].entry
-				// }
 				if file.IsSameAsFileInfo(stat) {
 					LOG_TRACE("RESTORE_SKIP", "File %s unchanged (by size and timestamp)", file.Path)
 					skippedFileSize += file.Size
@@ -941,6 +875,7 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 				downloadedFileSize += file.Size
 				downloadedFiles = append(downloadedFiles, file)
 			}
+
 			continue
 		}
 
@@ -967,15 +902,6 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 		file.RestoreMetadata(fullPath, nil, setOwner)
 	}
 
-	// for _, linkEntry := range hardLinks {
-	// 	sourcePath := joinPath(top, hardLinkTable[linkEntry.Link].entry.Path)
-	// 	fullPath := joinPath(top, linkEntry.Path)
-	// 	LOG_INFO("DOWNLOAD_LINK", "Hard linking %s -> %s", fullPath, sourcePath)
-	// 	if err := os.Link(sourcePath, fullPath); err != nil {
-	// 		LOG_ERROR("DOWNLOAD_LINK", "Failed to create hard link %s -> %s", fullPath, sourcePath)
-	// 	}
-	// }
-
 	if deleteMode && len(patterns) == 0 {
 		// Reverse the order to make sure directories are empty before being deleted
 		for i := range extraFiles {
@@ -1128,9 +1054,6 @@ func (manager *BackupManager) UploadSnapshot(chunkOperator *ChunkOperator, top s
 	lastEndChunk := 0
 
 	uploadEntryInfoFunc := func(entry *Entry) error {
-		if entry.IsHardlinkRoot() {
-			entryList.HardLinkTable[entry.Path] = entry
-		}
 
 		if entry.IsFile() && entry.Size > 0 {
 			delta := entry.StartChunk - len(chunkHashes) + 1
@@ -1153,14 +1076,6 @@ func (manager *BackupManager) UploadSnapshot(chunkOperator *ChunkOperator, top s
 			entry.StartChunk -= lastEndChunk
 			lastEndChunk = entry.EndChunk
 			entry.EndChunk = delta
-		} else if entry.IsHardlinkedFrom() {
-			targetEntry, ok := entryList.HardLinkTable[entry.Link]
-			if !ok {
-				LOG_ERROR("SNAPSHOT_UPLOAD", "Unable to find hardlink target for %s to %s", entry.Path, entry.Link)
-			}
-			// FIXME: We will use a copy, so it is probably sufficient to skip rereading xattrs and such in the initial code
-			entry = entry.LinkTo(targetEntry)
-			LOG_DEBUG("SNAPSHOT_UPLOAD", "Uploading cloned hardlink entry for %s to %s", entry.Path, entry.Link)
 		}
 
 		buffer.Reset()
@@ -1280,6 +1195,7 @@ func (manager *BackupManager) RestoreFile(chunkDownloader *ChunkDownloader, chun
 					LOG_ERROR("DOWNLOAD_CREATE", "Failed to create the file %s for in-place writing: %v", fullPath, err)
 					return false, nil
 				}
+				entry.RestoreEarlyFileFlags(existingFile)
 
 				n := int64(1)
 				// There is a go bug on Windows (https://github.com/golang/go/issues/21681) that causes Seek to fail
@@ -1463,6 +1379,7 @@ func (manager *BackupManager) RestoreFile(chunkDownloader *ChunkDownloader, chun
 				return false, nil
 			}
 		}
+		entry.RestoreEarlyFileFlags(existingFile)
 
 		existingFile.Seek(0, 0)
 
@@ -1545,6 +1462,7 @@ func (manager *BackupManager) RestoreFile(chunkDownloader *ChunkDownloader, chun
 			LOG_ERROR("DOWNLOAD_OPEN", "Failed to open file for writing: %v", err)
 			return false, nil
 		}
+		entry.RestoreEarlyFileFlags(newFile)
 
 		hasher := manager.config.NewFileHasher()
 

src/duplicacy_entry.go

@@ -4,8 +4,6 @@
 package duplicacy
 
 import (
-	"bytes"
-	"crypto/sha256"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
@@ -17,10 +15,12 @@ import (
 	"sort"
 	"strconv"
 	"strings"
-	"syscall"
 	"time"
+	"bytes"
+	"crypto/sha256"
+
+    "github.com/vmihailenco/msgpack"
 
-	"github.com/vmihailenco/msgpack"
 )
 
 // This is the hidden directory in the repository for storing various files.
@@ -110,36 +110,15 @@ func (entry *Entry) Copy() *Entry {
 		UID: entry.UID,
 		GID: entry.GID,
 
-		StartChunk:  entry.StartChunk,
+		StartChunk: entry.StartChunk,
 		StartOffset: entry.StartOffset,
-		EndChunk:    entry.EndChunk,
-		EndOffset:   entry.EndOffset,
+		EndChunk: entry.EndChunk,
+		EndOffset: entry.EndOffset,
 
 		Attributes: entry.Attributes,
 	}
 }
 
-func (entry *Entry) LinkTo(target *Entry) *Entry {
-	return &Entry{
-		Path: entry.Path,
-		Size: target.Size,
-		Time: target.Time,
-		Mode: target.Mode,
-		Link: entry.Link,
-		Hash: target.Hash,
-
-		UID: target.UID,
-		GID: target.GID,
-
-		StartChunk:  target.StartChunk,
-		StartOffset: target.StartOffset,
-		EndChunk:    target.EndChunk,
-		EndOffset:   target.EndOffset,
-
-		Attributes: target.Attributes,
-	}
-}
-
 // CreateEntryFromJSON creates an entry from a json description.
 func (entry *Entry) UnmarshalJSON(description []byte) (err error) {
 
@@ -383,12 +362,12 @@ func (entry *Entry) EncodeMsgpack(encoder *msgpack.Encoder) error {
 
 	if entry.Attributes != nil {
 		attributes := make([]string, numberOfAttributes)
-		i := 0
-		for attribute := range *entry.Attributes {
-			attributes[i] = attribute
-			i++
-		}
-		sort.Strings(attributes)
+        i := 0
+        for attribute := range *entry.Attributes {
+            attributes[i] = attribute
+            i++
+        }
+        sort.Strings(attributes)
 		for _, attribute := range attributes {
 			err = encoder.EncodeString(attribute)
 			if err != nil {
@@ -401,7 +380,7 @@ func (entry *Entry) EncodeMsgpack(encoder *msgpack.Encoder) error {
 		}
 	}
 
-	return nil
+    return nil
 }
 
 func (entry *Entry) DecodeMsgpack(decoder *msgpack.Decoder) error {
@@ -513,26 +492,14 @@ func (entry *Entry) IsComplete() bool {
 	return entry.Size >= 0
 }
 
-func (entry *Entry) IsFileNotHardlink() bool {
-	return entry.IsFile() && (len(entry.Link) == 0 || entry.Link == "/")
-}
-
-func (entry *Entry) IsHardlinkedFrom() bool {
-	return entry.IsFile() && len(entry.Link) > 0 && entry.Link != "/"
-}
-
-func (entry *Entry) IsHardlinkRoot() bool {
-	return entry.IsFile() && entry.Link == "/"
-}
-
 func (entry *Entry) GetPermissions() os.FileMode {
 	return os.FileMode(entry.Mode) & fileModeMask
 }
 
 func (entry *Entry) GetParent() string {
 	path := entry.Path
-	if path != "" && path[len(path)-1] == '/' {
-		path = path[:len(path)-1]
+	if path != "" && path[len(path) - 1] == '/' {
+		path = path[:len(path) - 1]
 	}
 	i := strings.LastIndex(path, "/")
 	if i == -1 {
@@ -629,7 +596,7 @@ func ComparePaths(left string, right string) int {
 	for i := p; i < len(left); i++ {
 		c3 = left[i]
 		if c3 == '/' {
-			last1 = i == len(left)-1
+			last1 = i == len(left) - 1
 			break
 		}
 	}
@@ -639,7 +606,7 @@ func ComparePaths(left string, right string) int {
 	for i := p; i < len(right); i++ {
 		c4 = right[i]
 		if c4 == '/' {
-			last2 = i == len(right)-1
+			last2 = i == len(right) - 1
 			break
 		}
 	}
@@ -727,26 +694,10 @@ func (files FileInfoCompare) Less(i, j int) bool {
 	}
 }
 
-type listEntryLinkKey struct {
-	dev uint64
-	ino uint64
-}
-
-type ListingState struct {
-	linkTable map[listEntryLinkKey]string // map unique inode details to initially found path
-}
-
-func NewListingState() *ListingState {
-	return &ListingState{
-		linkTable: make(map[listEntryLinkKey]string),
-	}
-}
-
 // ListEntries returns a list of entries representing file and subdirectories under the directory 'path'.  Entry paths
 // are normalized as relative to 'top'.  'patterns' are used to exclude or include certain files.
-func ListEntries(top string, path string, patterns []string, nobackupFile string, excludeByAttribute bool,
-	listingState *ListingState,
-	listingChannel chan *Entry) (directoryList []*Entry, skippedFiles []string, err error) {
+func ListEntries(top string, path string, patterns []string, nobackupFile string, excludeByAttribute bool, listingChannel chan *Entry) (directoryList []*Entry,
+	skippedFiles []string, err error) {
 
 	LOG_DEBUG("LIST_ENTRIES", "Listing %s", path)
 
@@ -833,20 +784,6 @@ func ListEntries(top string, path string, patterns []string, nobackupFile string
 			continue
 		}
 
-		if entry.IsFile() {
-			stat, ok := f.Sys().(*syscall.Stat_t)
-			if ok && stat != nil && stat.Nlink > 1 {
-				k := listEntryLinkKey{dev: uint64(stat.Dev), ino: uint64(stat.Ino)}
-				if path, ok := listingState.linkTable[k]; ok {
-					LOG_DEBUG("LIST_HARDLINK", "Detected hardlink %s to %s", entry.Path, path)
-					entry.Link = path
-				} else {
-					entry.Link = "/"
-					listingState.linkTable[k] = entry.Path
-				}
-			}
-		}
-
 		if entry.IsDir() {
 			directoryList = append(directoryList, entry)
 		} else {

src/duplicacy_entrylist.go

@@ -62,7 +62,6 @@ type EntryList struct {
 	uploadedChunkIndex int                  // counter for upload chunks
 	uploadedChunkOffset int                 // the start offset for the current modified entry
 
-	HardLinkTable map[string]*Entry
 }
 
 // Create a new entry list
@@ -79,7 +78,6 @@ func CreateEntryList(snapshotID string, cachePath string, maximumInMemoryEntries
 		maximumInMemoryEntries: maximumInMemoryEntries,
 		cachePath: cachePath,
 		Token: string(token),
-		HardLinkTable: make(map[string]*Entry),
 	}
 
 	return entryList, nil
@@ -120,7 +118,7 @@ func (entryList *EntryList)AddEntry(entry *Entry) error {
 	if !entry.IsComplete() {
 		if entry.IsDir() || entry.IsLink() {
 			entry.Size = 0
-		} else if !entry.IsHardlinkedFrom() {
+		} else {
 			modifiedEntry := ModifiedEntry {
 				Path: entry.Path,
 				Size: -1,

src/duplicacy_snapshot.go

@@ -68,7 +68,6 @@ func (snapshot *Snapshot) ListLocalFiles(top string, nobackupFile string,
 								         skippedDirectories *[]string, skippedFiles *[]string) {
 
 	var patterns []string
-	var listingState = NewListingState()
 
 	if filtersFile == "" {
 		filtersFile = joinPath(GetDuplicacyPreferencePath(), "filters")
@@ -82,7 +81,7 @@ func (snapshot *Snapshot) ListLocalFiles(top string, nobackupFile string,
 
 		directory := directories[len(directories)-1]
 		directories = directories[:len(directories)-1]
-		subdirectories, skipped, err := ListEntries(top, directory.Path, patterns, nobackupFile, excludeByAttribute, listingState, listingChannel)
+		subdirectories, skipped, err := ListEntries(top, directory.Path, patterns, nobackupFile, excludeByAttribute, listingChannel)
 		if err != nil {
 			if directory.Path == "" {
 				LOG_ERROR("LIST_FAILURE", "Failed to list the repository root: %v", err)

src/duplicacy_utils_bsd.go

@@ -0,0 +1,53 @@
+// Copyright (c) Acrosync LLC. All rights reserved.
+// Free for personal use and commercial trial
+// Commercial use requires per-user licenses available from https://duplicacy.com
+
+//go:build freebsd || netbsd || darwin
+// +build freebsd netbsd darwin
+
+package duplicacy
+
+import (
+	"encoding/binary"
+	"os"
+	"syscall"
+)
+
+const bsdFileFlagsKey = "\x00bf"
+
+func (entry *Entry) ReadFileFlags(f *os.File) error {
+	fileInfo, err := f.Stat()
+	if err != nil {
+		return err
+	}
+	stat, ok := fileInfo.Sys().(*syscall.Stat_t)
+	if ok && stat.Flags != 0 {
+		if entry.Attributes == nil {
+			entry.Attributes = &map[string][]byte{}
+		}
+		v := make([]byte, 4)
+		binary.LittleEndian.PutUint32(v, stat.Flags)
+		(*entry.Attributes)[bsdFileFlagsKey] = v
+		LOG_DEBUG("ATTR_READ", "Read flags 0x%x for %s", stat.Flags, entry.Path)
+	}
+	return nil
+}
+
+func (entry *Entry) RestoreEarlyDirFlags(path string) error {
+	return nil
+}
+
+func (entry *Entry) RestoreEarlyFileFlags(f *os.File) error {
+	return nil
+}
+
+func (entry *Entry) RestoreLateFileFlags(f *os.File) error {
+	if entry.Attributes == nil {
+		return nil
+	}
+	if v, have := (*entry.Attributes)[bsdFileFlagsKey]; have {
+		LOG_DEBUG("ATTR_RESTORE", "Restore flags 0x%x for %s", binary.LittleEndian.Uint32(v), entry.Path)
+		return syscall.Fchflags(int(f.Fd()), int(binary.LittleEndian.Uint32(v)))
+	}
+	return nil
+}

src/duplicacy_utils_linux.go

@@ -0,0 +1,112 @@
+// Copyright (c) Acrosync LLC. All rights reserved.
+// Free for personal use and commercial trial
+// Commercial use requires per-user licenses available from https://duplicacy.com
+
+package duplicacy
+
+import (
+	"encoding/binary"
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+const (
+	linux_FS_SECRM_FL        = 0x00000001 /* Secure deletion */
+	linux_FS_UNRM_FL         = 0x00000002 /* Undelete */
+	linux_FS_COMPR_FL        = 0x00000004 /* Compress file */
+	linux_FS_SYNC_FL         = 0x00000008 /* Synchronous updates */
+	linux_FS_IMMUTABLE_FL    = 0x00000010 /* Immutable file */
+	linux_FS_APPEND_FL       = 0x00000020 /* writes to file may only append */
+	linux_FS_NODUMP_FL       = 0x00000040 /* do not dump file */
+	linux_FS_NOATIME_FL      = 0x00000080 /* do not update atime */
+	linux_FS_NOCOMP_FL       = 0x00000400 /* Don't compress */
+	linux_FS_JOURNAL_DATA_FL = 0x00004000 /* Reserved for ext3 */
+	linux_FS_NOTAIL_FL       = 0x00008000 /* file tail should not be merged */
+	linux_FS_DIRSYNC_FL      = 0x00010000 /* dirsync behaviour (directories only) */
+	linux_FS_TOPDIR_FL       = 0x00020000 /* Top of directory hierarchies*/
+	linux_FS_NOCOW_FL        = 0x00800000 /* Do not cow file */
+	linux_FS_PROJINHERIT_FL  = 0x20000000 /* Create with parents projid */
+
+	linux_FS_IOC_GETFLAGS uintptr = 0x80086601
+	linux_FS_IOC_SETFLAGS uintptr = 0x40086602
+
+	linuxIocFlagsFileEarly = linux_FS_SECRM_FL | linux_FS_UNRM_FL | linux_FS_COMPR_FL | linux_FS_NODUMP_FL | linux_FS_NOATIME_FL | linux_FS_NOCOMP_FL | linux_FS_JOURNAL_DATA_FL | linux_FS_NOTAIL_FL | linux_FS_NOCOW_FL
+	linuxIocFlagsDirEarly  = linux_FS_TOPDIR_FL | linux_FS_PROJINHERIT_FL
+	linuxIocFlagsLate      = linux_FS_SYNC_FL | linux_FS_IMMUTABLE_FL | linux_FS_APPEND_FL | linux_FS_DIRSYNC_FL
+
+	linuxFileFlagsKey = "\x00lf"
+)
+
+func ioctl(f *os.File, request uintptr, attrp *uint32) error {
+	argp := uintptr(unsafe.Pointer(attrp))
+
+	if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, f.Fd(), request, argp); errno != 0 {
+		return os.NewSyscallError("ioctl", errno)
+	}
+	return nil
+}
+
+func (entry *Entry) ReadFileFlags(f *os.File) error {
+	var flags uint32
+	if err := ioctl(f, linux_FS_IOC_GETFLAGS, &flags); err != nil {
+		return err
+	}
+	if flags != 0 {
+		if entry.Attributes == nil {
+			entry.Attributes = &map[string][]byte{}
+		}
+		v := make([]byte, 4)
+		binary.LittleEndian.PutUint32(v, flags)
+		(*entry.Attributes)[linuxFileFlagsKey] = v
+		LOG_DEBUG("ATTR_READ", "Read flags 0x%x for %s", flags, entry.Path)
+	}
+	return nil
+}
+
+func (entry *Entry) RestoreEarlyDirFlags(path string) error {
+	if entry.Attributes == nil {
+		return nil
+	}
+	if v, have := (*entry.Attributes)[linuxFileFlagsKey]; have {
+		flags := binary.LittleEndian.Uint32(v) & linuxIocFlagsDirEarly
+		f, err := os.OpenFile(path, os.O_RDONLY|syscall.O_DIRECTORY, 0)
+		if err != nil {
+			return err
+		}
+		LOG_DEBUG("ATTR_RESTORE", "Restore dir flags (early) 0x%x for %s", flags, entry.Path)
+		err = ioctl(f, linux_FS_IOC_SETFLAGS, &flags)
+		f.Close()
+		return err
+	}
+	return nil
+}
+
+func (entry *Entry) RestoreEarlyFileFlags(f *os.File) error {
+	if entry.Attributes == nil {
+		return nil
+	}
+	if v, have := (*entry.Attributes)[linuxFileFlagsKey]; have {
+		flags := binary.LittleEndian.Uint32(v) & linuxIocFlagsFileEarly
+		LOG_DEBUG("ATTR_RESTORE", "Restore flags (early) 0x%x for %s", flags, entry.Path)
+		return ioctl(f, linux_FS_IOC_SETFLAGS, &flags)
+	}
+	return nil
+}
+
+func (entry *Entry) RestoreLateFileFlags(f *os.File) error {
+	if entry.Attributes == nil {
+		return nil
+	}
+	if v, have := (*entry.Attributes)[linuxFileFlagsKey]; have {
+		flags := binary.LittleEndian.Uint32(v) & (linuxIocFlagsFileEarly | linuxIocFlagsDirEarly | linuxIocFlagsLate)
+		LOG_DEBUG("ATTR_RESTORE", "Restore flags (late) 0x%x for %s", flags, entry.Path)
+		return ioctl(f, linux_FS_IOC_SETFLAGS, &flags)
+	}
+	return nil
+}
+
+func excludedByAttribute(attributes map[string][]byte) bool {
+	_, ok := attributes["user.duplicacy_exclude"]
+	return ok
+}

src/duplicacy_utils_others.go

@@ -48,9 +48,12 @@ func SetOwner(fullPath string, entry *Entry, fileInfo *os.FileInfo) bool {
 }
 
 func (entry *Entry) ReadAttributes(top string) {
-
 	fullPath := filepath.Join(top, entry.Path)
-	attributes, _ := xattr.List(fullPath)
+	f, err := os.OpenFile(fullPath, os.O_RDONLY|syscall.O_NOFOLLOW, 0)
+	if err != nil {
+		return
+	}
+	attributes, _ := xattr.FList(f)
 	if len(attributes) > 0 {
 		entry.Attributes = &map[string][]byte{}
 		for _, name := range attributes {
@@ -60,30 +63,42 @@ func (entry *Entry) ReadAttributes(top string) {
 			}
 		}
 	}
+	if err := entry.ReadFileFlags(f); err != nil {
+		LOG_INFO("ATTR_BACKUP", "Could not backup flags for file %s: %v", fullPath, err)
+	}
+	f.Close()
 }
 
 func (entry *Entry) SetAttributesToFile(fullPath string) {
-	names, _ := xattr.List(fullPath)
+	f, err := os.OpenFile(fullPath, os.O_RDONLY|syscall.O_NOFOLLOW, 0)
+	if err != nil {
+		return
+	}
 
+	names, _ := xattr.FList(f)
 	for _, name := range names {
-
-
 		newAttribute, found := (*entry.Attributes)[name]
 		if found {
-			oldAttribute, _ := xattr.Get(fullPath, name)
+			oldAttribute, _ := xattr.FGet(f, name)
 			if !bytes.Equal(oldAttribute, newAttribute) {
-				xattr.Set(fullPath, name, newAttribute)
+				xattr.FSet(f, name, newAttribute)
 			}
 			delete(*entry.Attributes, name)
 		} else {
-			xattr.Remove(fullPath, name)
+			xattr.FRemove(f, name)
 		}
 	}
 
 	for name, attribute := range *entry.Attributes {
-		xattr.Set(fullPath, name, attribute)
+		if len(name) > 0 && name[0] == '\x00' {
+			continue
+		}
+		xattr.FSet(f, name, attribute)
 	}
-
+	if err := entry.RestoreLateFileFlags(f); err != nil {
+		LOG_DEBUG("ATTR_RESTORE", "Could not restore flags for file %s: %v", fullPath, err)
+	}
+	f.Close()
 }
 
 func joinPath(components ...string) string {

src/duplicacy_utils_posix.go

@@ -2,8 +2,8 @@
 // Free for personal use and commercial trial
 // Commercial use requires per-user licenses available from https://duplicacy.com
 
-//go:build freebsd || netbsd || linux || solaris
-// +build freebsd netbsd linux solaris
+//go:build freebsd || netbsd || solaris
+// +build freebsd netbsd solaris
 
 package duplicacy
 

src/duplicacy_utils_windows.go

@@ -132,6 +132,18 @@ func SplitDir(fullPath string) (dir string, file string) {
 	return fullPath[:i+1], fullPath[i+1:]
 }
 
-func excludedByAttribute(attributes map[string][]byte) bool {
-	return false
+func (entry *Entry) ReadFileFlags(f *os.File) error {
+	return nil
+}
+
+func (entry *Entry) RestoreEarlyDirFlags(path string) error {
+	return nil
+}
+
+func (entry *Entry) RestoreEarlyFileFlags(f *os.File) error {
+	return nil
+}
+
+func (entry *Entry) RestoreLateFileFlags(f *os.File) error {
+	return nil
 }