Normalize and add options for backup, add more file flags options

- Move more function arguments to structs with some convenience functions. - Add a flag to enable backup/restore of file flags. It works a little bit differently depending on system. Since we don't need to do anything to get file flags on darwin/BSD, it's in the stat buffer so just save it. For linux we have to open the file and do a - Add the normalize flag to ReadAttributes. Implementation TBD. - stub out common xattr file for doc comments
Refactor the BackupManager options interface some more
2026-01-02 11:44:45 -06:00 · 2023-10-07 13:55:51 -05:00 · 2023-10-07 13:55:51 -05:00 · 2023-10-07 13:55:51 -05:00 · 2023-10-07 13:55:51 -05:00 · 2023-10-07 13:55:51 -05:00
28 changed files with 1804 additions and 613 deletions
--- a/README.md
+++ b/README.md
@@ -1,3 +1,45 @@
+# Dupluxe
+
+An experimental Duplicacy derivative with improved support for preserving state on UNIX like systems. Produces snapshots compatible with Duplicacy.
+
+NOTE: This project/repository is not affiliated with nor endorsed by Duplicacy, Acrosync or their associated rights holders. This project is open source but is not free/libre software. It is developed and distributed in accordance with the associated LICENSE. Commercial use may require purchase of a license from Acrosync, please contact them if you have any doubts.
+
+## Added Features
+* Support for hard links. Hard links are tracked during local file listing. All linked entries will reuse the same chunk data, so this can give a time and space saving benefit as hard-linked files only need to be packed once. Hard links are supported to everything (regular files, symlinks, special files) except directories.
+* Optional File flags, that is chflags(1) on BSD/Darwin, and ioctl_iflags(2) on Linux. The primary use case is to preserve iflags used by btrfs for no-COW and compression.
+* Optional Special files (character/block devices, FIFOs, and sockets) are preserved along with associated metadata.
+
+## Assorted Changes
+* The S3 backend uses the newer ListObjectsV2 interface originally because of a bug with some providers with the old, obsolete interface, but now because this API is considerably faster on a number of providers tested.
+* B2 client max listing per request increased to 10,000
+* A fix for the exclude_by_attribute feature on BSD/Unix which has been broken upstream for ages.
+
+## Snapshot Format
+The generated preserves snapshots are backward compatible with vanilla versions of duplicacy and also do not increase the encoding size of metadata significantly. Unfortunately duplicacy does not have a formal forward-compatible snapshot versioning system, but that's not too surprising. This does mean that the data encoding is somewhat abusive of the existing format.
+
+### Hard links
+The storage differs for regular files vs. every other target. Entry records contain a `Link` string field for the symlink target. When a likely hard linked file is encountered (`st_nlink > 1`) that entry is marked as a hard link root with the string "/" in the `Link` field and it is placed in an array, the index of this array will serve as a link address. Plain duplicacy only uses the `Link` field for symlinks. Files that hard link to this initial file have the index of the array of root files encoded as a base-16 integer into their `Link` field. These entries are placed in the snapshot with valid start/end chunk and offset values and all metadata is cloned so official Duplicacy will recover them as regular files with all metadata, it just will never make hard links.
+For hard links to symlinks and special files, the `Link` isn't used. Instead, since these files never have content the `EndChunk/EndOffset` fields are used. A magic number (-9) is encoded in `EndChunk` for root entries and (-10) for clone/child entries. The `EndOffset` contains the index into the root entry array.
+
+### Special Files
+Duplicacy simply skips special files. DuplicacyIX does not skip them. The `st_rdev` (device number) for character and block devices is stored with the lower 32-bits in `StartChunk` and the upper 32-bits in `StartOffset`, though no actual supported system uses anything bigger than 32-bits. The packing of this quantity is OS specific, but major, minor numbers are also OS specific.
+
+### File flags
+Files flags are stored in the extended attributes table with a short (2 character) OS specific key prefixed with a null-byte. Duplicacy will try to set these xattrs, however they will be ignored as the name appears to be empty with the initial null-byte.
+
+
+## Motivation
+Arguably system root directories are better preserved in a filesystem image format, however the line becomes blurred for home and data directories the former which tends to become a magnet for all kinds of data layout. This gives the option of a convenient random addressable cloud backup with easy partial restore while also being able to backup an nearly exact replica for use in disaster recovery. Nearly exact, the only metadata not preserved are times other than mtimes and ACLs on BSD-like systems.
+Hard links are a pain and might be better to not exist but in actual use, but things like git repos and SDKs have a tendency to use them. Often one has no choice but to deal with them, and forgoing preserving them is painful.
+File flags are primarily for the use case of btrfs snapshot backups, specifically with regards to compression and no-COW. The implementation applies certain flags immediately on open so that these flags apply to written blocks.
+Special files serve a couple purposes. Backup of FIFOs and sockets are primarily for preserving metadata since these files have no useful content and can always be created on the fly. The other is support for backup of overlay2 file systems. overlay2 uses character mode dev-nodes for whiteouts in addition to trusted namespace xattrs. DuplicacyIX should be able to faithfully reproduce overlay2 fs layers.
+
+## Caveats/TODO
+* Improve command line options around processing hard links and special files, especially for restore. Right now if you don't have `mknod` capabilities and the snapshot has special device files you're going to need to use filters.
+* File flags for immutability aren't handled smartly. Specifically immutable and append only files will break badly with hardlinks, since hardlink creation is deferred to after flags application. The solution is not complicated but this is not a pressing use case.
+* Some corner cases of replacing existing files with hard links might end up breaking links if not doing a full restore. Again not a pressing use case. For the primary use of disaster recovery of large portions or an entire volume it works fine.
+* Possibly encode ACLs on Mac OS/FreeBSD. On Linux the crappy POSIX 1e ACLs that no one should use are picked up in the xattrs.
+
 # Duplicacy: A lock-free deduplication cloud backup tool

 Duplicacy is a new generation cross-platform cloud backup tool based on the idea of [Lock-Free Deduplication](https://github.com/gilbertchen/duplicacy/wiki/Lock-Free-Deduplication).
--- a/duplicacy/duplicacy_main.go
+++ b/duplicacy/duplicacy_main.go
@@ -22,9 +22,7 @@ import (

 	"github.com/gilbertchen/cli"

-	"io/ioutil"
-
-	"github.com/gilbertchen/duplicacy/src"
+	duplicacy "github.com/gilbertchen/duplicacy/src"
 )

 const (
@@ -316,7 +314,7 @@ func configRepository(context *cli.Context, init bool) {
 			// write real path into .duplicacy file inside repository
 			duplicacyFileName := path.Join(repository, duplicacy.DUPLICACY_FILE)
 			d1 := []byte(preferencePath)
-			err = ioutil.WriteFile(duplicacyFileName, d1, 0644)
+			err = os.WriteFile(duplicacyFileName, d1, 0644)
 			if err != nil {
 				duplicacy.LOG_ERROR("REPOSITORY_PATH", "Failed to write %s file inside repository  %v", duplicacyFileName, err)
 				return
@@ -705,7 +703,7 @@ func changePassword(context *cli.Context) {
 	}

 	configPath := path.Join(duplicacy.GetDuplicacyPreferencePath(), "config")
-	err = ioutil.WriteFile(configPath, description, 0600)
+	err = os.WriteFile(configPath, description, 0600)
 	if err != nil {
 		duplicacy.LOG_ERROR("CONFIG_SAVE", "Failed to save the old config to %s: %v", configPath, err)
 		return
@@ -789,7 +787,17 @@ func backupRepository(context *cli.Context) {
 	uploadRateLimit := context.Int("limit-rate")
 	enumOnly := context.Bool("enum-only")
 	storage.SetRateLimits(0, uploadRateLimit)
-	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, preference.NobackupFile, preference.FiltersFile, preference.ExcludeByAttribute)
+	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password,
+		&duplicacy.BackupManagerOptions{
+			NobackupFile:       preference.NobackupFile,
+			FiltersFile:        preference.FiltersFile,
+			ExcludeByAttribute: preference.ExcludeByAttribute,
+			ExcludeXattrs:      preference.ExcludeXattrs,
+			NormalizeXattrs:    preference.NormalizeXattrs,
+			IncludeFileFlags:   preference.IncludeFileFlags,
+			IncludeSpecials:    preference.IncludeSpecials,
+			FileFlagsMask:      uint32(preference.FileFlagsMask),
+		})
 	duplicacy.SavePassword(*preference, "password", password)

 	backupManager.SetupSnapshotCache(preference.Name)
@@ -850,14 +858,6 @@ func restoreRepository(context *cli.Context) {
 		password = duplicacy.GetPassword(*preference, "password", "Enter storage password:", false, false)
 	}

-	quickMode := !context.Bool("hash")
-	overwrite := context.Bool("overwrite")
-	deleteMode := context.Bool("delete")
-	setOwner := !context.Bool("ignore-owner")
-
-	showStatistics := context.Bool("stats")
-	persist := context.Bool("persist")
-
 	var patterns []string
 	for _, pattern := range context.Args() {

@@ -881,13 +881,38 @@ func restoreRepository(context *cli.Context) {
 	duplicacy.LOG_INFO("SNAPSHOT_FILTER", "Loaded %d include/exclude pattern(s)", len(patterns))

 	storage.SetRateLimits(context.Int("limit-rate"), 0)
-	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, preference.NobackupFile, preference.FiltersFile, preference.ExcludeByAttribute)
+
+	excludeOwner := preference.ExcludeOwner
+	// TODO: for backward compat, eventually make them all overridable?
+	if context.IsSet("ignore-owner") {
+		excludeOwner = context.Bool("ignore-owner")
+	}
+
+	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password,
+		&duplicacy.BackupManagerOptions{
+			NobackupFile:       preference.NobackupFile,
+			FiltersFile:        preference.FiltersFile,
+			ExcludeByAttribute: preference.ExcludeByAttribute,
+			SetOwner:           excludeOwner,
+			ExcludeXattrs:      preference.ExcludeXattrs,
+			NormalizeXattrs:    preference.NormalizeXattrs,
+			IncludeSpecials:    preference.IncludeSpecials,
+			FileFlagsMask:      uint32(preference.FileFlagsMask),
+		})
+
 	duplicacy.SavePassword(*preference, "password", password)

 	loadRSAPrivateKey(context.String("key"), context.String("key-passphrase"), preference, backupManager, false)

 	backupManager.SetupSnapshotCache(preference.Name)
-	failed := backupManager.Restore(repository, revision, true, quickMode, threads, overwrite, deleteMode, setOwner, showStatistics, patterns, persist)
+	failed := backupManager.Restore(repository, revision, &duplicacy.RestoreOptions{
+		InPlace:        true,
+		QuickMode:      !context.Bool("hash"),
+		Overwrite:      context.Bool("overwrite"),
+		DeleteMode:     context.Bool("delete"),
+		ShowStatistics: context.Bool("stats"),
+		AllowFailures:  context.Bool("persist"),
+	})
 	if failed > 0 {
 		duplicacy.LOG_ERROR("RESTORE_FAIL", "%d file(s) were not restored correctly", failed)
 		return
@@ -927,7 +952,8 @@ func listSnapshots(context *cli.Context) {
 	tag := context.String("t")
 	revisions := getRevisions(context)

-	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, "", "", preference.ExcludeByAttribute)
+	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password,
+		&duplicacy.BackupManagerOptions{ExcludeByAttribute: preference.ExcludeByAttribute})
 	duplicacy.SavePassword(*preference, "password", password)

 	id := preference.SnapshotID
@@ -983,7 +1009,7 @@ func checkSnapshots(context *cli.Context) {
 	tag := context.String("t")
 	revisions := getRevisions(context)

-	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, "", "", false)
+	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, nil)
 	duplicacy.SavePassword(*preference, "password", password)

 	loadRSAPrivateKey(context.String("key"), context.String("key-passphrase"), preference, backupManager, false)
@@ -1043,8 +1069,7 @@ func printFile(context *cli.Context) {
 		snapshotID = context.String("id")
 	}

-
-	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, "", "", false)
+	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, nil)
 	duplicacy.SavePassword(*preference, "password", password)

 	loadRSAPrivateKey(context.String("key"), context.String("key-passphrase"), preference, backupManager, false)
@@ -1102,13 +1127,14 @@ func diff(context *cli.Context) {
 	}

 	compareByHash := context.Bool("hash")
-	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, "", "", false)
+	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, nil)
 	duplicacy.SavePassword(*preference, "password", password)

 	loadRSAPrivateKey(context.String("key"), context.String("key-passphrase"), preference, backupManager, false)

 	backupManager.SetupSnapshotCache(preference.Name)
-	backupManager.SnapshotManager.Diff(repository, snapshotID, revisions, path, compareByHash, preference.NobackupFile, preference.FiltersFile, preference.ExcludeByAttribute)
+	backupManager.SnapshotManager.Diff(repository, snapshotID, revisions, path, compareByHash,
+		duplicacy.NewListFilesOptions(preference))

 	runScript(context, preference.Name, "post")
 }
@@ -1147,7 +1173,7 @@ func showHistory(context *cli.Context) {

 	revisions := getRevisions(context)
 	showLocalHash := context.Bool("hash")
-	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, "", "", false)
+	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, nil)
 	duplicacy.SavePassword(*preference, "password", password)

 	backupManager.SetupSnapshotCache(preference.Name)
@@ -1210,7 +1236,7 @@ func pruneSnapshots(context *cli.Context) {
 		os.Exit(ArgumentExitCode)
 	}

-	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, "", "", false)
+	backupManager := duplicacy.CreateBackupManager(preference.SnapshotID, storage, repository, password, nil)
 	duplicacy.SavePassword(*preference, "password", password)

 	backupManager.SetupSnapshotCache(preference.Name)
@@ -1255,7 +1281,7 @@ func copySnapshots(context *cli.Context) {
 		sourcePassword = duplicacy.GetPassword(*source, "password", "Enter source storage password:", false, false)
 	}

-	sourceManager := duplicacy.CreateBackupManager(source.SnapshotID, sourceStorage, repository, sourcePassword, "", "", false)
+	sourceManager := duplicacy.CreateBackupManager(source.SnapshotID, sourceStorage, repository, sourcePassword, nil)
 	sourceManager.SetupSnapshotCache(source.Name)
 	duplicacy.SavePassword(*source, "password", sourcePassword)

@@ -1290,7 +1316,7 @@ func copySnapshots(context *cli.Context) {
 	destinationStorage.SetRateLimits(0, context.Int("upload-limit-rate"))

 	destinationManager := duplicacy.CreateBackupManager(destination.SnapshotID, destinationStorage, repository,
-		                                                  destinationPassword, "", "", false)
+		destinationPassword, nil)
 	duplicacy.SavePassword(*destination, "password", destinationPassword)
 	destinationManager.SetupSnapshotCache(destination.Name)

@@ -1415,7 +1441,7 @@ func benchmark(context *cli.Context) {
 	if storage == nil {
 		return
 	}
-	duplicacy.Benchmark(repository, storage, int64(fileSize) * 1024 * 1024, chunkSize * 1024 * 1024, chunkCount, uploadThreads, downloadThreads)
+	duplicacy.Benchmark(repository, storage, int64(fileSize)*1024*1024, chunkSize*1024*1024, chunkCount, uploadThreads, downloadThreads)
 }

 func main() {
@@ -1454,8 +1480,8 @@ func main() {
 					Argument: "<level>",
 				},
 				cli.BoolFlag{
-					Name:     "zstd",
-					Usage:    "short for -zstd default",
+					Name:  "zstd",
+					Usage: "short for -zstd default",
 				},
 				cli.IntFlag{
 					Name:     "iterations",
@@ -1530,8 +1556,8 @@ func main() {
 					Argument: "<level>",
 				},
 				cli.BoolFlag{
-					Name:     "zstd",
-					Usage:    "short for -zstd default",
+					Name:  "zstd",
+					Usage: "short for -zstd default",
 				},
 				cli.BoolFlag{
 					Name:  "vss",
@@ -1564,7 +1590,6 @@ func main() {
 					Usage:    "the maximum number of entries kept in memory (defaults to 1M)",
 					Argument: "<number>",
 				},
-
 			},
 			Usage:     "Save a snapshot of the repository to the storage",
 			ArgsUsage: " ",
@@ -1624,7 +1649,7 @@ func main() {
 				cli.BoolFlag{
 					Name:  "persist",
 					Usage: "continue processing despite chunk errors or existing files (without -overwrite), reporting any affected files",
-        },
+				},
 				cli.StringFlag{
 					Name:     "key-passphrase",
 					Usage:    "the passphrase to decrypt the RSA private key",
@@ -1982,8 +2007,8 @@ func main() {
 					Argument: "<level>",
 				},
 				cli.BoolFlag{
-					Name:     "zstd",
-					Usage:    "short for -zstd default",
+					Name:  "zstd",
+					Usage: "short for -zstd default",
 				},
 				cli.IntFlag{
 					Name:     "iterations",
@@ -2248,8 +2273,8 @@ func main() {
 			Usage: "add a comment to identify the process",
 		},
 		cli.StringSliceFlag{
-			Name:  "suppress, s",
-			Usage: "suppress logs with the specified id",
+			Name:     "suppress, s",
+			Usage:    "suppress logs with the specified id",
 			Argument: "<id>",
 		},
 		cli.BoolFlag{
@@ -2262,7 +2287,7 @@ func main() {
 	app.Name = "duplicacy"
 	app.HelpName = "duplicacy"
 	app.Usage = "A new generation cloud backup tool based on lock-free deduplication"
-	app.Version = "3.2.1" + " (" + GitCommit + ")"
+	app.Version = "3.2.3" + " (" + GitCommit + ")"

 	// Exit with code 2 if an invalid command is provided
 	app.CommandNotFound = func(context *cli.Context, command string) {
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
 module github.com/gilbertchen/duplicacy

-go 1.19
+go 1.20

 require (
 	cloud.google.com/go v0.38.0
@@ -22,13 +22,14 @@ require (
 	github.com/minio/highwayhash v1.0.2
 	github.com/ncw/swift/v2 v2.0.1
 	github.com/pkg/sftp v1.11.0
-	github.com/pkg/xattr v0.4.1
+	github.com/pkg/xattr v0.4.9
 	github.com/vmihailenco/msgpack v4.0.4+incompatible
 	golang.org/x/crypto v0.12.0
 	golang.org/x/net v0.10.0
 	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d
+	golang.org/x/sys v0.11.0
 	google.golang.org/api v0.21.0
-	storj.io/uplink v1.12.0
+	storj.io/uplink v1.12.1
 )

 require (
@@ -55,7 +56,7 @@ require (
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/satori/go.uuid v1.2.0 // indirect
 	github.com/segmentio/go-env v1.1.0 // indirect
-	github.com/spacemonkeygo/monkit/v3 v3.0.20-0.20230227152157-d00b379de191 // indirect
+	github.com/spacemonkeygo/monkit/v3 v3.0.22 // indirect
 	github.com/vaughan0/go-ini v0.0.0-20130923145212-a98ad7ee00ec // indirect
 	github.com/vivint/infectious v0.0.0-20200605153912-25a574ae18a3 // indirect
 	github.com/zeebo/blake3 v0.2.3 // indirect
@@ -63,7 +64,6 @@ require (
 	go.opencensus.io v0.22.3 // indirect
 	golang.org/x/mod v0.10.0 // indirect
 	golang.org/x/sync v0.3.0 // indirect
-	golang.org/x/sys v0.11.0 // indirect
 	golang.org/x/term v0.11.0 // indirect
 	golang.org/x/text v0.12.0 // indirect
 	golang.org/x/tools v0.9.1 // indirect
@@ -71,7 +71,7 @@ require (
 	google.golang.org/genproto v0.0.0-20200409111301-baae70f3302d // indirect
 	google.golang.org/grpc v1.28.1 // indirect
 	google.golang.org/protobuf v1.28.1 // indirect
-	storj.io/common v0.0.0-20230907123639-5fd0608fd947 // indirect
+	storj.io/common v0.0.0-20230920095429-0ce0a575e6f8 // indirect
 	storj.io/drpc v0.0.33 // indirect
 	storj.io/picobuf v0.0.2-0.20230906122608-c4ba17033c6c // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -128,6 +128,8 @@ github.com/pkg/sftp v1.11.0 h1:4Zv0OGbpkg4yNuUtH0s8rvoYxRCNyT29NVUo6pgPmxI=
 github.com/pkg/sftp v1.11.0/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI=
 github.com/pkg/xattr v0.4.1 h1:dhclzL6EqOXNaPDWqoeb9tIxATfBSmjqL0b4DpSjwRw=
 github.com/pkg/xattr v0.4.1/go.mod h1:W2cGD0TBEus7MkUgv0tNZ9JutLtVO3cXu+IBRuHqnFs=
+github.com/pkg/xattr v0.4.9 h1:5883YPCtkSd8LFbs13nXplj9g9tlrwoJRjgpgMu1/fE=
+github.com/pkg/xattr v0.4.9/go.mod h1:di8WF84zAKk8jzR1UBTEWh9AUlIZZ7M/JNt8e9B6ktU=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
@@ -138,8 +140,8 @@ github.com/satori/go.uuid v1.2.0 h1:0uYX9dsZ2yD7q2RtLRtPSdGDWzjeM3TbMJP9utgA0ww=
 github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
 github.com/segmentio/go-env v1.1.0 h1:AGJ7OnCx9M5NWpkYPGYELS6III/pFSnAs1GvKWStiEo=
 github.com/segmentio/go-env v1.1.0/go.mod h1:pEKO2ieHe8zF098OMaAHw21SajMuONlnI/vJNB3pB7I=
-github.com/spacemonkeygo/monkit/v3 v3.0.20-0.20230227152157-d00b379de191 h1:QVUfVxilbPp8fBJ7701LL/WEUjBSiSxbs9LUaCIe5qM=
-github.com/spacemonkeygo/monkit/v3 v3.0.20-0.20230227152157-d00b379de191/go.mod h1:kj1ViJhlyADa7DiA4xVnTuPA46lFKbM7mxQTrXCuJP4=
+github.com/spacemonkeygo/monkit/v3 v3.0.22 h1:4/g8IVItBDKLdVnqrdHZrCVPpIrwDBzl1jrV0IHQHDU=
+github.com/spacemonkeygo/monkit/v3 v3.0.22/go.mod h1:XkZYGzknZwkD0AKUnZaSXhRiVTLCkq7CWVa3IsE72gA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
@@ -193,7 +195,6 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
@@ -226,6 +227,7 @@ golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220408201424-a24fb2fb8a0f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
@@ -291,11 +293,11 @@ honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWh
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
-storj.io/common v0.0.0-20230907123639-5fd0608fd947 h1:X75A5hX1nFjQH8GIvei4T1LNQTLa++bsDKMxXxfPHE8=
-storj.io/common v0.0.0-20230907123639-5fd0608fd947/go.mod h1:FMVOxf2+SgsmfjxwFCM1MZCKwXis4U7l22M/6nIhIas=
+storj.io/common v0.0.0-20230920095429-0ce0a575e6f8 h1:i+bWPhVnNL6z/TLW3vDZytB6/0bsvJM0a1GhLCxrlxQ=
+storj.io/common v0.0.0-20230920095429-0ce0a575e6f8/go.mod h1:ZmeGPzRb2sm705Nwt/WwuH3e6mliShfvvoUNy1bb9v4=
 storj.io/drpc v0.0.33 h1:yCGZ26r66ZdMP0IcTYsj7WDAUIIjzXk6DJhbhvt9FHI=
 storj.io/drpc v0.0.33/go.mod h1:vR804UNzhBa49NOJ6HeLjd2H3MakC1j5Gv8bsOQT6N4=
 storj.io/picobuf v0.0.2-0.20230906122608-c4ba17033c6c h1:or/DtG5uaZpzimL61ahlgAA+MTYn/U3txz4fe+XBFUg=
 storj.io/picobuf v0.0.2-0.20230906122608-c4ba17033c6c/go.mod h1:JCuc3C0gzCJHQ4J6SOx/Yjg+QTpX0D+Fvs5H46FETCk=
-storj.io/uplink v1.12.0 h1:rTODjbKRo/lzz5Hp0isjoRfqDcH7kJg6aujD2M9v9Ro=
-storj.io/uplink v1.12.0/go.mod h1:nMAuoWi5AHio+8NQa33VRzCiRg0B0UhYKuT0a0CdXOg=
+storj.io/uplink v1.12.1 h1:bDc2dI6Q7EXcvPJLZuH9jIOTIf2oKxvW3xKEA+Y5EI0=
+storj.io/uplink v1.12.1/go.mod h1:1+czctHG25pMzcUp4Mds6QnoJ7LvbgYA5d1qlpFFexg=
--- a/src/duplicacy_backupmanager.go
+++ b/src/duplicacy_backupmanager.go
@@ -7,9 +7,9 @@ package duplicacy
 import (
 	"bytes"
 	"encoding/hex"
-	"encoding/json"
 	"fmt"
 	"io"
+	"math"
 	"os"
 	"path"
 	"path/filepath"
@@ -21,12 +21,11 @@ import (
 	"sync/atomic"
 	"time"

-    "github.com/vmihailenco/msgpack"
+	"github.com/vmihailenco/msgpack"
 )

 // BackupManager performs the two major operations, backup and restore, and passes other operations, mostly related to
 // snapshot management, to the snapshot manager.
-
 type BackupManager struct {
 	snapshotID string  // Unique id for each repository
 	storage    Storage // the storage for storing backups
@@ -34,15 +33,35 @@ type BackupManager struct {
 	SnapshotManager *SnapshotManager // the snapshot manager
 	snapshotCache   *FileStorage     // for copies of chunks needed by snapshots

-	config *Config // contains a number of options
-
-	nobackupFile string // don't backup directory when this file name is found
-	filtersFile string  // the path to the filters file
-	excludeByAttribute bool // don't backup file based on file attribute
+	config  *Config // contains a number of options
+	options BackupManagerOptions

 	cachePath string
 }

+type BackupManagerOptions struct {
+	NobackupFile       string // don't backup directory when this file name is found
+	FiltersFile        string // the path to the filters file
+	ExcludeByAttribute bool   // don't backup file based on file attribute
+	SetOwner           bool
+	ExcludeXattrs      bool
+	NormalizeXattrs    bool
+	IncludeFileFlags   bool
+	IncludeSpecials    bool
+	FileFlagsMask      uint32
+}
+
+type RestoreOptions struct {
+	Threads        int
+	Patterns       []string
+	InPlace        bool
+	QuickMode      bool
+	Overwrite      bool
+	DeleteMode     bool
+	ShowStatistics bool
+	AllowFailures  bool
+}
+
 func (manager *BackupManager) SetDryRun(dryRun bool) {
 	manager.config.dryRun = dryRun
 }
@@ -51,10 +70,19 @@ func (manager *BackupManager) SetCompressionLevel(level int) {
 	manager.config.CompressionLevel = level
 }

+func (manager *BackupManager) Config() *Config {
+	return manager.config
+}
+
+func (manager *BackupManager) SnapshotCache() *FileStorage {
+	return manager.snapshotCache
+}
+
 // CreateBackupManager creates a backup manager using the specified 'storage'.  'snapshotID' is a unique id to
 // identify snapshots created for this repository.  'top' is the top directory of the repository.  'password' is the
 // master key which can be nil if encryption is not enabled.
-func CreateBackupManager(snapshotID string, storage Storage, top string, password string, nobackupFile string, filtersFile string, excludeByAttribute bool) *BackupManager {
+func CreateBackupManager(snapshotID string, storage Storage, top string, password string,
+	options *BackupManagerOptions) *BackupManager {

 	config, _, err := DownloadConfig(storage, password)
 	if err != nil {
@@ -74,13 +102,10 @@ func CreateBackupManager(snapshotID string, storage Storage, top string, passwor

 		SnapshotManager: snapshotManager,

-		config: config,
-
-		nobackupFile: nobackupFile,
-
-		filtersFile: filtersFile,
-
-		excludeByAttribute: excludeByAttribute,
+		config:  config,
+	}
+	if options != nil {
+		backupManager.options = *options
 	}

 	if IsDebugging() {
@@ -131,8 +156,7 @@ func (manager *BackupManager) SetupSnapshotCache(storageName string) bool {
 func (manager *BackupManager) Backup(top string, quickMode bool, threads int, tag string,
 	showStatistics bool, shadowCopy bool, shadowCopyTimeout int, enumOnly bool, metadataChunkSize int, maximumInMemoryEntries int) bool {

-	var err error
-	top, err = filepath.Abs(top)
+	top, err := filepath.Abs(top)
 	if err != nil {
 		LOG_ERROR("REPOSITORY_ERR", "Failed to obtain the absolute path of the repository: %v", err)
 		return false
@@ -146,14 +170,14 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta

 	if manager.config.DataShards != 0 && manager.config.ParityShards != 0 {
 		LOG_INFO("BACKUP_ERASURECODING", "Erasure coding is enabled with %d data shards and %d parity shards",
-		         manager.config.DataShards, manager.config.ParityShards)
+			manager.config.DataShards, manager.config.ParityShards)
 	}

 	if manager.config.rsaPublicKey != nil && len(manager.config.FileKey) > 0 {
 		LOG_INFO("BACKUP_KEY", "RSA encryption is enabled")
 	}

-	if manager.excludeByAttribute {
+	if manager.options.ExcludeByAttribute {
 		LOG_INFO("BACKUP_EXCLUDE", "Exclude files with no-backup attributes")
 	}

@@ -187,7 +211,7 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta

 	// If the listing operation is fast and this is an initial backup, list all chunks and
 	// put them in the cache.
-	if (manager.storage.IsFastListing() && remoteSnapshot.Revision == 0) {
+	if manager.storage.IsFastListing() && remoteSnapshot.Revision == 0 {
 		LOG_INFO("BACKUP_LIST", "Listing all chunks")
 		allChunks, _ := manager.SnapshotManager.ListAllFiles(manager.storage, "chunks/")

@@ -222,7 +246,7 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta

 	var totalModifiedFileSize int64    // total size of modified files
 	var uploadedModifiedFileSize int64 // portions that have been uploaded (including cache hits)
-	var preservedFileSize int64 // total size of unmodified files
+	var preservedFileSize int64        // total size of unmodified files

 	localSnapshot := CreateEmptySnapshot(manager.snapshotID)
 	localSnapshot.Revision = remoteSnapshot.Revision + 1
@@ -238,8 +262,17 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta
 	go func() {
 		// List local files
 		defer CatchLogException()
-		localSnapshot.ListLocalFiles(shadowTop, manager.nobackupFile, manager.filtersFile, manager.excludeByAttribute, localListingChannel, &skippedDirectories, &skippedFiles)
-	} ()
+		localSnapshot.ListLocalFiles(shadowTop, localListingChannel, &skippedDirectories, &skippedFiles,
+			&ListFilesOptions{
+				NoBackupFile:       manager.options.NobackupFile,
+				FiltersFile:        manager.options.FiltersFile,
+				ExcludeByAttribute: manager.options.ExcludeByAttribute,
+				ExcludeXattrs:      manager.options.ExcludeXattrs,
+				NormalizeXattr:     manager.options.NormalizeXattrs,
+				IncludeFileFlags:   manager.options.IncludeFileFlags,
+				IncludeSpecials:    manager.options.IncludeSpecials,
+			})
+	}()

 	go func() {
 		// List remote files
@@ -261,7 +294,7 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta
 			})
 		}
 		close(remoteListingChannel)
-	} ()
+	}()

 	// Create the local file list
 	localEntryList, err := CreateEntryList(manager.snapshotID, manager.cachePath, maximumInMemoryEntries)
@@ -275,7 +308,7 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta
 	var remoteEntry *Entry
 	remoteListingOK := true
 	for {
-		localEntry := <- localListingChannel
+		localEntry := <-localListingChannel
 		if localEntry == nil {
 			break
 		}
@@ -289,7 +322,7 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta
 				compareResult = localEntry.Compare(remoteEntry)
 			} else {
 				if remoteListingOK {
-					remoteEntry, remoteListingOK = <- remoteListingChannel
+					remoteEntry, remoteListingOK = <-remoteListingChannel
 				}
 				if !remoteListingOK {
 					compareResult = -1
@@ -304,24 +337,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 {
@@ -356,8 +372,8 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta
 			// compareResult must be < 0; the local file is new
 			totalModifiedFileSize += localEntry.Size
 			if localEntry.Size > 0 {
-					// A size of -1 indicates this is a modified file that will be uploaded
-					localEntry.Size = -1
+				// A size of -1 indicates this is a modified file that will be uploaded
+				localEntry.Size = -1
 			}
 		}

@@ -465,7 +481,7 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta

 		_, found := chunkCache[chunkID]
 		if found {
-			if time.Now().Unix() - lastUploadingTime > keepUploadAlive {
+			if time.Now().Unix()-lastUploadingTime > keepUploadAlive {
 				LOG_INFO("UPLOAD_KEEPALIVE", "Skip chunk cache to keep connection alive")
 				found = false
 			}
@@ -575,7 +591,7 @@ func (manager *BackupManager) Backup(top string, quickMode bool, threads int, ta
 	if showStatistics {

 		LOG_INFO("BACKUP_STATS", "Files: %d total, %s bytes; %d new, %s bytes",
-			localEntryList.NumberOfEntries - int64(len(skippedFiles)),
+			localEntryList.NumberOfEntries-int64(len(skippedFiles)),
 			PrettyNumber(preservedFileSize+uploadedFileSize),
 			len(localEntryList.ModifiedEntries), PrettyNumber(uploadedFileSize))

@@ -639,27 +655,35 @@ 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
-// the same as 'top'.  'quickMode' will bypass files with unchanged sizes and timestamps.  'deleteMode' will
-// remove local files that don't exist in the snapshot. 'patterns' is used to include/exclude certain files.
-func (manager *BackupManager) Restore(top string, revision int, inPlace bool, quickMode bool, threads int, overwrite bool,
-	deleteMode bool, setOwner bool, showStatistics bool, patterns []string, allowFailures bool) int {
+// files that are different.'QuickMode' will bypass files with unchanged sizes and timestamps. 'DeleteMode' will
+// remove local files that don't exist in the snapshot. 'Patterns' is used to include/exclude certain files.
+func (manager *BackupManager) Restore(top string, revision int, options *RestoreOptions) int {
+	if options.Threads < 1 {
+		options.Threads = 1
+	}
+
+	patterns := options.Patterns
+
+	overwrite := options.Overwrite
+	allowFailures := options.AllowFailures
+
+	metadataOptions := RestoreMetadataOptions{
+		SetOwner:         manager.options.SetOwner,
+		ExcludeXattrs:    manager.options.ExcludeXattrs,
+		NormalizeXattrs:  manager.options.NormalizeXattrs,
+		IncludeFileFlags: manager.options.IncludeFileFlags,
+		FileFlagsMask:    manager.options.FileFlagsMask,
+	}

 	startTime := time.Now().Unix()

 	LOG_DEBUG("RESTORE_PARAMETERS", "top: %s, revision: %d, in-place: %t, quick: %t, delete: %t",
-		top, revision, inPlace, quickMode, deleteMode)
+		top, revision, options.InPlace, options.QuickMode, options.DeleteMode)

 	if !strings.HasPrefix(GetDuplicacyPreferencePath(), top) {
 		LOG_INFO("RESTORE_INPLACE", "Forcing in-place mode with a non-default preference path")
-		inPlace = true
+		options.InPlace = true
 	}

 	if len(patterns) > 0 {
@@ -701,14 +725,24 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu

 	localListingChannel := make(chan *Entry)
 	remoteListingChannel := make(chan *Entry)
-	chunkOperator := CreateChunkOperator(manager.config, manager.storage, manager.snapshotCache, showStatistics, false, threads, allowFailures)
+	chunkOperator := CreateChunkOperator(manager.config, manager.storage, manager.snapshotCache, options.ShowStatistics,
+		false, options.Threads, allowFailures)

 	LOG_INFO("RESTORE_INDEXING", "Indexing %s", top)
 	go func() {
 		// List local files
 		defer CatchLogException()
-		localSnapshot.ListLocalFiles(top, manager.nobackupFile, manager.filtersFile, manager.excludeByAttribute, localListingChannel, nil, nil)
-	} ()
+		localSnapshot.ListLocalFiles(top, localListingChannel, nil, nil,
+			&ListFilesOptions{
+				NoBackupFile:       manager.options.NobackupFile,
+				FiltersFile:        manager.options.FiltersFile,
+				ExcludeByAttribute: manager.options.ExcludeByAttribute,
+				ExcludeXattrs:      manager.options.ExcludeXattrs,
+				NormalizeXattr:     manager.options.NormalizeXattrs,
+				IncludeFileFlags:   manager.options.IncludeFileFlags,
+				IncludeSpecials:    manager.options.IncludeSpecials,
+			})
+	}()

 	remoteSnapshot := manager.SnapshotManager.DownloadSnapshot(manager.snapshotID, revision)
 	manager.SnapshotManager.DownloadSnapshotSequences(remoteSnapshot)
@@ -720,19 +754,45 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 			return true
 		})
 		close(remoteListingChannel)
-	} ()
+	}()

 	var localEntry *Entry
 	localListingOK := true

-	hardLinkTable := make(map[string]hardLinkEntry)
-	//hardLinks := make([]*Entry, 0)
+	type hardLinkEntry struct {
+		entry     *Entry
+		willExist bool
+	}
+	var hardLinkTable []hardLinkEntry
+	var hardLinks []*Entry
+
+	restoreHardLink := func(entry *Entry, fullPath string) bool {
+		if entry.IsHardLinkRoot() {
+			hardLinkTable[len(hardLinkTable)-1].willExist = true
+		} else if entry.IsHardLinkChild() {
+			i, err := entry.GetHardLinkId()
+			if err != nil {
+				LOG_ERROR("RESTORE_HARDLINK", "Decode error for hard link entry %s: %v", entry.Path, err)
+				return false
+			}
+			if !hardLinkTable[i].willExist {
+				hardLinkTable[i] = hardLinkEntry{entry, true}
+			} else {
+				sourcePath := joinPath(top, hardLinkTable[i].entry.Path)
+				if err := MakeHardlink(sourcePath, fullPath); err != nil {
+					LOG_ERROR("RESTORE_HARDLINK", "Failed to create hard link %s to %s: %v", fullPath, sourcePath, err)
+				}
+				LOG_TRACE("DOWNLOAD_DONE", "Hard linked %s to %s", entry.Path, hardLinkTable[i].entry.Path)
+				return true
+			}
+		}
+		return false
+	}

 	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 remoteEntry.IsHardLinkRoot() {
+			hardLinkTable = append(hardLinkTable, hardLinkEntry{remoteEntry, false})
 		}

 		if len(patterns) > 0 && !MatchPath(remoteEntry.Path, patterns) {
@@ -743,10 +803,8 @@ 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
+				localEntry, localListingOK = <-localListingChannel
 			}
 			if localEntry == nil {
 				compareResult = 1
@@ -762,54 +820,51 @@ 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 options.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
 		}

 		fullPath := joinPath(top, remoteEntry.Path)
+
 		if remoteEntry.IsLink() {
-			stat, err := os.Lstat(fullPath)
-			if stat != nil {
+			if stat, _ := os.Lstat(fullPath); stat != nil {
 				if stat.Mode()&os.ModeSymlink != 0 {
 					isRegular, link, err := Readlink(fullPath)
 					if err == nil && link == remoteEntry.Link && !isRegular {
-						remoteEntry.RestoreMetadata(fullPath, nil, setOwner)
+						remoteEntry.RestoreMetadata(fullPath, stat, metadataOptions)
+						if remoteEntry.IsHardLinkRoot() {
+							hardLinkTable[len(hardLinkTable)-1].willExist = true
+						}
 						continue
 					}
 				}

+				if !overwrite {
+					LOG_WERROR(allowFailures, "DOWNLOAD_OVERWRITE",
+						"File %s already exists.  Please specify the -overwrite option to overwrite", remoteEntry.Path)
+					continue
+				}
+
 				os.Remove(fullPath)
 			}

-			err = os.Symlink(remoteEntry.Link, fullPath)
-			if err != nil {
+			if restoreHardLink(remoteEntry, fullPath) {
+				continue
+			}
+
+			if err := os.Symlink(remoteEntry.Link, fullPath); err != nil {
 				LOG_ERROR("RESTORE_SYMLINK", "Can't create symlink %s: %v", remoteEntry.Path, err)
 				return 0
 			}
-			remoteEntry.RestoreMetadata(fullPath, nil, setOwner)
+			remoteEntry.RestoreMetadata(fullPath, nil, metadataOptions)
 			LOG_TRACE("DOWNLOAD_DONE", "Symlink %s updated", remoteEntry.Path)
+
 		} else if remoteEntry.IsDir() {

 			stat, err := os.Stat(fullPath)
@@ -828,23 +883,58 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 					return 0
 				}
 			}
+			if metadataOptions.IncludeFileFlags {
+				err = remoteEntry.RestoreEarlyDirFlags(fullPath, manager.options.FileFlagsMask)
+				if err != nil {
+					LOG_WARN("DOWNLOAD_FLAGS", "Failed to set early file flags on %s: %v", fullPath, err)
+				}
+			}
 			directoryEntries = append(directoryEntries, remoteEntry)
+		} else if remoteEntry.IsSpecial() && manager.options.IncludeSpecials {
+			if stat, _ := os.Lstat(fullPath); stat != nil {
+				if remoteEntry.IsSameSpecial(stat) {
+					remoteEntry.RestoreMetadata(fullPath, nil, metadataOptions)
+					if remoteEntry.IsHardLinkRoot() {
+						hardLinkTable[len(hardLinkTable)-1].willExist = true
+					}
+					continue
+				}
+				if !overwrite {
+					LOG_WERROR(allowFailures, "DOWNLOAD_OVERWRITE",
+						"File %s already exists.  Please specify the -overwrite option to overwrite", remoteEntry.Path)
+					continue
+				}
+				os.Remove(fullPath)
+			}
+
+			if restoreHardLink(remoteEntry, fullPath) {
+				continue
+			}
+
+			if err := remoteEntry.RestoreSpecial(fullPath); err != nil {
+				LOG_ERROR("RESTORE_SPECIAL", "Failed to restore special file %s: %v", fullPath, err)
+				return 0
+			}
+			remoteEntry.RestoreMetadata(fullPath, nil, metadataOptions)
+			LOG_TRACE("DOWNLOAD_DONE", "Special %s %s restored", remoteEntry.Path, remoteEntry.FmtSpecial())
+
 		} 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
-			// 	}
-			// }
+			if remoteEntry.IsHardLinkRoot() {
+				hardLinkTable[len(hardLinkTable)-1].willExist = true
+			} else if remoteEntry.IsHardLinkChild() {
+				i, err := remoteEntry.GetHardLinkId()
+				if err != nil {
+					LOG_ERROR("RESTORE_HARDLINK", "Decode error for hard link entry %s: %v", remoteEntry.Path, err)
+					return 0
+				}
+				if !hardLinkTable[i].willExist {
+					hardLinkTable[i] = 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
@@ -856,7 +946,7 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 	}

 	for localListingOK {
-		localEntry, localListingOK = <- localListingChannel
+		localEntry, localListingOK = <-localListingChannel
 		if localEntry != nil {
 			extraFiles = append(extraFiles, localEntry.Path)
 		}
@@ -899,11 +989,7 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 		fullPath := joinPath(top, file.Path)
 		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 options.QuickMode {
 				if file.IsSameAsFileInfo(stat) {
 					LOG_TRACE("RESTORE_SKIP", "File %s unchanged (by size and timestamp)", file.Path)
 					skippedFileSize += file.Size
@@ -935,17 +1021,23 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 			}
 			newFile.Close()

-			file.RestoreMetadata(fullPath, nil, setOwner)
-			if !showStatistics {
+			file.RestoreMetadata(fullPath, nil, metadataOptions)
+			if !options.ShowStatistics {
 				LOG_INFO("DOWNLOAD_DONE", "Downloaded %s (0)", file.Path)
 				downloadedFileSize += file.Size
 				downloadedFiles = append(downloadedFiles, file)
 			}
+
 			continue
 		}

-		downloaded, err := manager.RestoreFile(chunkDownloader, chunkMaker, file, top, inPlace, overwrite, showStatistics,
-			totalFileSize, downloadedFileSize, startDownloadingTime, allowFailures)
+		fileFlagsMask := metadataOptions.FileFlagsMask
+		if !metadataOptions.IncludeFileFlags {
+			fileFlagsMask = math.MaxUint32
+		}
+		downloaded, err := manager.RestoreFile(chunkDownloader, chunkMaker, file, top, options.InPlace, overwrite,
+			options.ShowStatistics, totalFileSize, downloadedFileSize, startDownloadingTime, allowFailures,
+			fileFlagsMask)
 		if err != nil {
 			// RestoreFile returned an error; if allowFailures is false RestoerFile would error out and not return so here
 			// we just need to show a warning
@@ -964,19 +1056,42 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 			skippedFileSize += file.Size
 			skippedFileCount++
 		}
-		file.RestoreMetadata(fullPath, nil, setOwner)
+		file.RestoreMetadata(fullPath, nil, metadataOptions)
 	}

-	// 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)
-	// 	}
-	// }
+	for _, linkEntry := range hardLinks {

-	if deleteMode && len(patterns) == 0 {
+		i, _ := linkEntry.GetHardLinkId()
+		sourcePath := joinPath(top, hardLinkTable[i].entry.Path)
+		fullPath := joinPath(top, linkEntry.Path)
+
+		if stat, _ := os.Lstat(fullPath); stat != nil {
+			sourceStat, _ := os.Lstat(sourcePath)
+			if os.SameFile(stat, sourceStat) {
+				continue
+			}
+
+			if sourceStat == nil {
+				LOG_WERROR(allowFailures, "RESTORE_HARDLINK",
+					"Target %s for hard link %s is missing", sourcePath, linkEntry.Path)
+				continue
+			}
+			if !overwrite {
+				LOG_WERROR(allowFailures, "DOWNLOAD_OVERWRITE",
+					"File %s already exists.  Please specify the -overwrite option to overwrite", linkEntry.Path)
+				continue
+			}
+			os.Remove(fullPath)
+		}
+
+		if err := MakeHardlink(sourcePath, fullPath); err != nil {
+			LOG_ERROR("RESTORE_HARDLINK", "Failed to create hard link %s to %s: %v", fullPath, sourcePath, err)
+			return 0
+		}
+		LOG_TRACE("RESTORE_HARDLINK", "Hard linked %s to %s", linkEntry.Path, hardLinkTable[i].entry.Path)
+	}
+
+	if options.DeleteMode && len(patterns) == 0 {
 		// Reverse the order to make sure directories are empty before being deleted
 		for i := range extraFiles {
 			file := extraFiles[len(extraFiles)-1-i]
@@ -988,10 +1103,10 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu

 	for _, entry := range directoryEntries {
 		dir := joinPath(top, entry.Path)
-		entry.RestoreMetadata(dir, nil, setOwner)
+		entry.RestoreMetadata(dir, nil, metadataOptions)
 	}

-	if showStatistics {
+	if options.ShowStatistics {
 		for _, file := range downloadedFiles {
 			LOG_INFO("DOWNLOAD_DONE", "Downloaded %s (%d)", file.Path, file.Size)
 		}
@@ -1002,7 +1117,7 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 	}

 	LOG_INFO("RESTORE_END", "Restored %s to revision %d", top, revision)
-	if showStatistics {
+	if options.ShowStatistics {
 		LOG_INFO("RESTORE_STATS", "Files: %d total, %s bytes", len(fileEntries), PrettySize(totalFileSize))
 		LOG_INFO("RESTORE_STATS", "Downloaded %d file, %s bytes, %d chunks",
 			len(downloadedFiles), PrettySize(downloadedFileSize), chunkDownloader.numberOfDownloadedChunks)
@@ -1021,55 +1136,6 @@ func (manager *BackupManager) Restore(top string, revision int, inPlace bool, qu
 	return 0
 }

-// fileEncoder encodes one file at a time to avoid loading the full json description of the entire file tree
-// in the memory
-type fileEncoder struct {
-	top            string
-	readAttributes bool
-	files          []*Entry
-	currentIndex   int
-	buffer         *bytes.Buffer
-}
-
-// Read reads data from the embedded buffer
-func (encoder fileEncoder) Read(data []byte) (n int, err error) {
-	return encoder.buffer.Read(data)
-}
-
-// NextFile switches to the next file and generates its json description in the buffer.  It also takes care of
-// the ending ']' and the commas between files.
-func (encoder *fileEncoder) NextFile() (io.Reader, bool) {
-	if encoder.currentIndex == len(encoder.files) {
-		return nil, false
-	}
-	if encoder.currentIndex == len(encoder.files)-1 {
-		encoder.buffer.Write([]byte("]"))
-		encoder.currentIndex++
-		return encoder, true
-	}
-
-	encoder.currentIndex++
-	entry := encoder.files[encoder.currentIndex]
-	if encoder.readAttributes {
-		entry.ReadAttributes(encoder.top)
-	}
-	description, err := json.Marshal(entry)
-	if err != nil {
-		LOG_FATAL("SNAPSHOT_ENCODE", "Failed to encode file %s: %v", encoder.files[encoder.currentIndex].Path, err)
-		return nil, false
-	}
-
-	if encoder.readAttributes {
-		entry.Attributes = nil
-	}
-
-	if encoder.currentIndex != 0 {
-		encoder.buffer.Write([]byte(","))
-	}
-	encoder.buffer.Write(description)
-	return encoder, true
-}
-
 // UploadSnapshot uploads the specified snapshot to the storage. It turns Files, ChunkHashes, and ChunkLengths into
 // sequences of chunks, and uploads these chunks, and finally the snapshot file.
 func (manager *BackupManager) UploadSnapshot(chunkOperator *ChunkOperator, top string, snapshot *Snapshot,
@@ -1121,17 +1187,19 @@ func (manager *BackupManager) UploadSnapshot(chunkOperator *ChunkOperator, top s
 	encoder := msgpack.NewEncoder(buffer)
 	metadataChunkMaker := CreateMetaDataChunkMaker(manager.config, metadataChunkSize)

-    var chunkHashes  []string
+	var chunkHashes []string
 	var chunkLengths []int
 	lastChunk := -1

 	lastEndChunk := 0

-	uploadEntryInfoFunc := func(entry *Entry) error {
-		if entry.IsHardlinkRoot() {
-			entryList.HardLinkTable[entry.Path] = entry
-		}
+	type hardLinkEntry struct {
+		entry      *Entry
+		startChunk int
+	}
+	var hardLinkTable []hardLinkEntry

+	uploadEntryInfoFunc := func(entry *Entry) error {
 		if entry.IsFile() && entry.Size > 0 {
 			delta := entry.StartChunk - len(chunkHashes) + 1
 			if entry.StartChunk != lastChunk {
@@ -1149,18 +1217,33 @@ func (manager *BackupManager) UploadSnapshot(chunkOperator *ChunkOperator, top s
 			entry.StartChunk -= delta
 			entry.EndChunk -= delta

+			if entry.IsHardLinkRoot() {
+				hardLinkTable = append(hardLinkTable, hardLinkEntry{entry, entry.StartChunk})
+			}
+
 			delta = entry.EndChunk - entry.StartChunk
 			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)
+		} else if entry.IsHardLinkChild() {
+			i, err := entry.GetHardLinkId()
+			if err != nil {
+				LOG_ERROR("SNAPSHOT_UPLOAD", "Decode error for hard link entry %s: %v", entry.Link, err)
+				return err
 			}
-			// 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)
+
+			targetEntry := hardLinkTable[i].entry
+			var startChunk, endChunk int
+
+			if targetEntry.IsFile() && targetEntry.Size > 0 {
+				startChunk = hardLinkTable[i].startChunk - lastEndChunk
+				endChunk = targetEntry.EndChunk
+				lastEndChunk = hardLinkTable[i].startChunk + endChunk
+			}
+			entry = entry.HardLinkTo(targetEntry, startChunk, endChunk)
+
+		} else if entry.IsHardLinkRoot() {
+			hardLinkTable = append(hardLinkTable, hardLinkEntry{entry, 0})
 		}

 		buffer.Reset()
@@ -1229,11 +1312,13 @@ func (manager *BackupManager) UploadSnapshot(chunkOperator *ChunkOperator, top s
 // Restore downloads a file from the storage.  If 'inPlace' is false, the download file is saved first to a temporary
 // file under the .duplicacy directory and then replaces the existing one.  Otherwise, the existing file will be
 // overwritten directly.
-// Return: true, nil:    Restored file; 
-//         false, nil:   Skipped file; 
-//         false, error: Failure to restore file (only if allowFailures == true)
+// Return: true, nil:    Restored file;
+//
+//	false, nil:   Skipped file;
+//	false, error: Failure to restore file (only if allowFailures == true)
 func (manager *BackupManager) RestoreFile(chunkDownloader *ChunkDownloader, chunkMaker *ChunkMaker, entry *Entry, top string, inPlace bool, overwrite bool,
-	showStatistics bool, totalFileSize int64, downloadedFileSize int64, startTime int64, allowFailures bool) (bool, error) {
+	showStatistics bool, totalFileSize int64, downloadedFileSize int64, startTime int64, allowFailures bool,
+	fileFlagsMask uint32) (bool, error) {

 	LOG_TRACE("DOWNLOAD_START", "Downloading %s", entry.Path)

@@ -1280,6 +1365,10 @@ 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
 				}
+				err = entry.RestoreEarlyFileFlags(existingFile, fileFlagsMask)
+				if err != nil {
+					LOG_WARN("DOWNLOAD_FLAGS", "Failed to set early file flags on %s: %v", fullPath, err)
+				}

 				n := int64(1)
 				// There is a go bug on Windows (https://github.com/golang/go/issues/21681) that causes Seek to fail
@@ -1406,7 +1495,7 @@ func (manager *BackupManager) RestoreFile(chunkDownloader *ChunkDownloader, chun
 			// fileHash != entry.Hash, warn/error depending on -overwrite option
 			if !overwrite && !isNewFile {
 				LOG_WERROR(allowFailures, "DOWNLOAD_OVERWRITE",
-							"File %s already exists.  Please specify the -overwrite option to overwrite", entry.Path)
+					"File %s already exists.  Please specify the -overwrite option to overwrite", entry.Path)
 				return false, fmt.Errorf("file exists")
 			}

@@ -1463,6 +1552,10 @@ func (manager *BackupManager) RestoreFile(chunkDownloader *ChunkDownloader, chun
 				return false, nil
 			}
 		}
+		err = entry.RestoreEarlyFileFlags(existingFile, fileFlagsMask)
+		if err != nil {
+			LOG_WARN("DOWNLOAD_FLAGS", "Failed to set early file flags on %s: %v", fullPath, err)
+		}

 		existingFile.Seek(0, 0)

@@ -1545,6 +1638,10 @@ func (manager *BackupManager) RestoreFile(chunkDownloader *ChunkDownloader, chun
 			LOG_ERROR("DOWNLOAD_OPEN", "Failed to open file for writing: %v", err)
 			return false, nil
 		}
+		err = entry.RestoreEarlyFileFlags(newFile, fileFlagsMask)
+		if err != nil {
+			LOG_WARN("DOWNLOAD_FLAGS", "Failed to set early file flags on %s: %v", fullPath, err)
+		}

 		hasher := manager.config.NewFileHasher()

@@ -1651,7 +1748,7 @@ func (manager *BackupManager) CopySnapshots(otherManager *BackupManager, snapsho

 	if otherManager.config.DataShards != 0 && otherManager.config.ParityShards != 0 {
 		LOG_INFO("BACKUP_ERASURECODING", "Erasure coding is enabled for the destination storage with %d data shards and %d parity shards",
-		         otherManager.config.DataShards, otherManager.config.ParityShards)
+			otherManager.config.DataShards, otherManager.config.ParityShards)
 	}

 	if otherManager.config.rsaPublicKey != nil && len(otherManager.config.FileKey) > 0 {
@@ -1752,15 +1849,15 @@ func (manager *BackupManager) CopySnapshots(otherManager *BackupManager, snapsho
 		LOG_TRACE("SNAPSHOT_COPY", "Copying snapshot %s at revision %d", snapshot.ID, snapshot.Revision)

 		for _, chunkHash := range snapshot.FileSequence {
-			chunks[chunkHash] = true  // The chunk is a snapshot chunk
+			chunks[chunkHash] = true // The chunk is a snapshot chunk
 		}

 		for _, chunkHash := range snapshot.ChunkSequence {
-			chunks[chunkHash] = true  // The chunk is a snapshot chunk
+			chunks[chunkHash] = true // The chunk is a snapshot chunk
 		}

 		for _, chunkHash := range snapshot.LengthSequence {
-			chunks[chunkHash] = true  // The chunk is a snapshot chunk
+			chunks[chunkHash] = true // The chunk is a snapshot chunk
 		}

 		description := manager.SnapshotManager.DownloadSequence(snapshot.ChunkSequence)
@@ -1773,7 +1870,7 @@ func (manager *BackupManager) CopySnapshots(otherManager *BackupManager, snapsho

 		for _, chunkHash := range snapshot.ChunkHashes {
 			if _, found := chunks[chunkHash]; !found {
-				chunks[chunkHash] = false  // The chunk is a file chunk
+				chunks[chunkHash] = false // The chunk is a file chunk
 			}
 		}

@@ -1805,7 +1902,7 @@ func (manager *BackupManager) CopySnapshots(otherManager *BackupManager, snapsho
 		}
 	}

-	LOG_INFO("SNAPSHOT_COPY", "Chunks to copy: %d, to skip: %d, total: %d", len(chunksToCopy), len(chunks) - len(chunksToCopy), len(chunks))
+	LOG_INFO("SNAPSHOT_COPY", "Chunks to copy: %d, to skip: %d, total: %d", len(chunksToCopy), len(chunks)-len(chunksToCopy), len(chunks))

 	chunkDownloader := CreateChunkOperator(manager.config, manager.storage, nil, false, false, downloadingThreads, false)

@@ -1814,7 +1911,7 @@ func (manager *BackupManager) CopySnapshots(otherManager *BackupManager, snapsho

 	copiedChunks := 0
 	chunkUploader := CreateChunkOperator(otherManager.config, otherManager.storage, nil, false, false, uploadingThreads, false)
-	chunkUploader.UploadCompletionFunc =  func(chunk *Chunk, chunkIndex int, skipped bool, chunkSize int, uploadSize int) {
+	chunkUploader.UploadCompletionFunc = func(chunk *Chunk, chunkIndex int, skipped bool, chunkSize int, uploadSize int) {
 		action := "Skipped"
 		if !skipped {
 			copiedChunks++
@@ -1825,11 +1922,11 @@ func (manager *BackupManager) CopySnapshots(otherManager *BackupManager, snapsho

 		elapsedTime := time.Now().Sub(startTime).Seconds()
 		speed := int64(float64(atomic.LoadInt64(&uploadedBytes)) / elapsedTime)
-		remainingTime := int64(float64(len(chunksToCopy) - chunkIndex - 1) / float64(chunkIndex + 1) * elapsedTime)
-		percentage := float64(chunkIndex + 1) / float64(len(chunksToCopy)) * 100.0
+		remainingTime := int64(float64(len(chunksToCopy)-chunkIndex-1) / float64(chunkIndex+1) * elapsedTime)
+		percentage := float64(chunkIndex+1) / float64(len(chunksToCopy)) * 100.0
 		LOG_INFO("COPY_PROGRESS", "%s chunk %s (%d/%d) %sB/s %s %.1f%%",
-				action, chunk.GetID(), chunkIndex + 1, len(chunksToCopy),
-				PrettySize(speed), PrettyTime(remainingTime), percentage)
+			action, chunk.GetID(), chunkIndex+1, len(chunksToCopy),
+			PrettySize(speed), PrettyTime(remainingTime), percentage)
 		otherManager.config.PutChunk(chunk)
 	}

@@ -1852,7 +1949,7 @@ func (manager *BackupManager) CopySnapshots(otherManager *BackupManager, snapsho
 	chunkDownloader.Stop()
 	chunkUploader.Stop()

-	LOG_INFO("SNAPSHOT_COPY", "Copied %d new chunks and skipped %d existing chunks", copiedChunks, len(chunks) - copiedChunks)
+	LOG_INFO("SNAPSHOT_COPY", "Copied %d new chunks and skipped %d existing chunks", copiedChunks, len(chunks)-copiedChunks)

 	for _, snapshot := range snapshots {
 		if revisionMap[snapshot.ID][snapshot.Revision] == false {
--- a/src/duplicacy_backupmanager_test.go
+++ b/src/duplicacy_backupmanager_test.go
@@ -176,8 +176,6 @@ func assertRestoreFailures(t *testing.T, failedFiles int, expectedFailedFiles in
 }

 func TestBackupManager(t *testing.T) {
-
-	rand.Seed(time.Now().UnixNano())
 	setTestingT(t)
 	SetLoggingLevel(INFO)

@@ -253,15 +251,23 @@ func TestBackupManager(t *testing.T) {
 	time.Sleep(time.Duration(delay) * time.Second)

 	SetDuplicacyPreferencePath(testDir + "/repository1/.duplicacy")
-	backupManager := CreateBackupManager("host1", storage, testDir, password, "", "", false)
+	backupManager := CreateBackupManager("host1", storage, testDir, password, nil)
 	backupManager.SetupSnapshotCache("default")

 	SetDuplicacyPreferencePath(testDir + "/repository1/.duplicacy")
 	backupManager.Backup(testDir+"/repository1" /*quickMode=*/, true, threads, "first", false, false, 0, false, 1024, 1024)
 	time.Sleep(time.Duration(delay) * time.Second)
 	SetDuplicacyPreferencePath(testDir + "/repository2/.duplicacy")
-	failedFiles := backupManager.Restore(testDir+"/repository2", threads /*inPlace=*/, false /*quickMode=*/, false, threads /*overwrite=*/, true,
-		/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, false)
+	failedFiles := backupManager.Restore(testDir+"/repository2", 1, &RestoreOptions{
+		Threads:        threads,
+		Patterns:       nil,
+		InPlace:        false,
+		QuickMode:      false,
+		Overwrite:      true,
+		DeleteMode:     false,
+		ShowStatistics: false,
+		AllowFailures:  false,
+	})
 	assertRestoreFailures(t, failedFiles, 0)

 	for _, f := range []string{"file1", "file2", "dir1/file3"} {
@@ -285,8 +291,16 @@ func TestBackupManager(t *testing.T) {
 	backupManager.Backup(testDir+"/repository1" /*quickMode=*/, true, threads, "second", false, false, 0, false, 1024, 1024)
 	time.Sleep(time.Duration(delay) * time.Second)
 	SetDuplicacyPreferencePath(testDir + "/repository2/.duplicacy")
-	failedFiles = backupManager.Restore(testDir+"/repository2", 2 /*inPlace=*/, true /*quickMode=*/, true, threads /*overwrite=*/, true,
-		/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, false)
+	failedFiles = backupManager.Restore(testDir+"/repository2", 2, &RestoreOptions{
+		Threads:        threads,
+		Patterns:       nil,
+		InPlace:        true,
+		QuickMode:      true,
+		Overwrite:      true,
+		DeleteMode:     false,
+		ShowStatistics: false,
+		AllowFailures:  false,
+	})
 	assertRestoreFailures(t, failedFiles, 0)

 	for _, f := range []string{"file1", "file2", "dir1/file3"} {
@@ -314,8 +328,16 @@ func TestBackupManager(t *testing.T) {
 	createRandomFile(testDir+"/repository2/dir5/file5", 100)

 	SetDuplicacyPreferencePath(testDir + "/repository2/.duplicacy")
-	failedFiles = backupManager.Restore(testDir+"/repository2", 3 /*inPlace=*/, true /*quickMode=*/, false, threads /*overwrite=*/, true,
-		/*deleteMode=*/ true /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, false)
+	failedFiles = backupManager.Restore(testDir+"/repository2", 3, &RestoreOptions{
+		Threads:        threads,
+		Patterns:       nil,
+		InPlace:        true,
+		QuickMode:      false,
+		Overwrite:      true,
+		DeleteMode:     true,
+		ShowStatistics: false,
+		AllowFailures:  false,
+	})
 	assertRestoreFailures(t, failedFiles, 0)

 	for _, f := range []string{"file1", "file2", "dir1/file3"} {
@@ -342,8 +364,16 @@ func TestBackupManager(t *testing.T) {
 	os.Remove(testDir + "/repository1/file2")
 	os.Remove(testDir + "/repository1/dir1/file3")
 	SetDuplicacyPreferencePath(testDir + "/repository1/.duplicacy")
-	failedFiles = backupManager.Restore(testDir+"/repository1", 3 /*inPlace=*/, true /*quickMode=*/, false, threads /*overwrite=*/, true,
-		/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, []string{"+file2", "+dir1/file3", "-*"} /*allowFailures=*/, false)
+	failedFiles = backupManager.Restore(testDir+"/repository1", 3, &RestoreOptions{
+		Threads:        threads,
+		Patterns:       []string{"+file2", "+dir1/file3", "-*"},
+		InPlace:        true,
+		QuickMode:      false,
+		Overwrite:      true,
+		DeleteMode:     false,
+		ShowStatistics: false,
+		AllowFailures:  false,
+	})
 	assertRestoreFailures(t, failedFiles, 0)

 	for _, f := range []string{"file1", "file2", "dir1/file3"} {
@@ -358,17 +388,17 @@ func TestBackupManager(t *testing.T) {
 	if numberOfSnapshots != 3 {
 		t.Errorf("Expected 3 snapshots but got %d", numberOfSnapshots)
 	}
-			
-	backupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1", /*revisions*/ []int{1, 2, 3}, /*tag*/ "", /*showStatistics*/ false,
-	    /*showTabular*/ false, /*checkFiles*/ false, /*checkChunks*/ false, /*searchFossils*/ false, /*resurrect*/ false, /*rewiret*/ false, 1,  /*allowFailures*/false)
+
+	backupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1" /*revisions*/, []int{1, 2, 3} /*tag*/, "" /*showStatistics*/, false,
+		/*showTabular*/ false /*checkFiles*/, false /*checkChunks*/, false /*searchFossils*/, false /*resurrect*/, false /*rewiret*/, false, 1 /*allowFailures*/, false)
 	backupManager.SnapshotManager.PruneSnapshots("host1", "host1" /*revisions*/, []int{1} /*tags*/, nil /*retentions*/, nil,
 		/*exhaustive*/ false /*exclusive=*/, false /*ignoredIDs*/, nil /*dryRun*/, false /*deleteOnly*/, false /*collectOnly*/, false, 1)
 	numberOfSnapshots = backupManager.SnapshotManager.ListSnapshots( /*snapshotID*/ "host1" /*revisionsToList*/, nil /*tag*/, "" /*showFiles*/, false /*showChunks*/, false)
 	if numberOfSnapshots != 2 {
 		t.Errorf("Expected 2 snapshots but got %d", numberOfSnapshots)
 	}
-	backupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1", /*revisions*/ []int{2, 3}, /*tag*/ "", /*showStatistics*/ false,
-	     /*showTabular*/ false, /*checkFiles*/ false, /*checkChunks*/ false, /*searchFossils*/ false, /*resurrect*/ false, /*rewiret*/ false, 1, /*allowFailures*/ false)
+	backupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1" /*revisions*/, []int{2, 3} /*tag*/, "" /*showStatistics*/, false,
+		/*showTabular*/ false /*checkFiles*/, false /*checkChunks*/, false /*searchFossils*/, false /*resurrect*/, false /*rewiret*/, false, 1 /*allowFailures*/, false)
 	backupManager.Backup(testDir+"/repository1" /*quickMode=*/, false, threads, "fourth", false, false, 0, false, 1024, 1024)
 	backupManager.SnapshotManager.PruneSnapshots("host1", "host1" /*revisions*/, nil /*tags*/, nil /*retentions*/, nil,
 		/*exhaustive*/ false /*exclusive=*/, true /*ignoredIDs*/, nil /*dryRun*/, false /*deleteOnly*/, false /*collectOnly*/, false, 1)
@@ -376,8 +406,8 @@ func TestBackupManager(t *testing.T) {
 	if numberOfSnapshots != 3 {
 		t.Errorf("Expected 3 snapshots but got %d", numberOfSnapshots)
 	}
-	backupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1", /*revisions*/ []int{2, 3, 4}, /*tag*/ "", /*showStatistics*/ false,
-	    /*showTabular*/ false, /*checkFiles*/ false, /*checkChunks*/ false, /*searchFossils*/ false, /*resurrect*/ false, /*rewiret*/ false, 1, /*allowFailures*/ false)
+	backupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1" /*revisions*/, []int{2, 3, 4} /*tag*/, "" /*showStatistics*/, false,
+		/*showTabular*/ false /*checkFiles*/, false /*checkChunks*/, false /*searchFossils*/, false /*resurrect*/, false /*rewiret*/, false, 1 /*allowFailures*/, false)

 	/*buf := make([]byte, 1<<16)
 	  runtime.Stack(buf, true)
@@ -386,7 +416,7 @@ func TestBackupManager(t *testing.T) {

 // Create file with random file with certain seed
 func createRandomFileSeeded(path string, maxSize int, seed int64) {
-	rand.Seed(seed)
+	r := rand.New(rand.NewSource(seed))
 	file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
 	if err != nil {
 		LOG_ERROR("RANDOM_FILE", "Can't open %s for writing: %v", path, err)
@@ -403,7 +433,7 @@ func createRandomFileSeeded(path string, maxSize int, seed int64) {
 		if bytes > cap(buffer) {
 			bytes = cap(buffer)
 		}
-		rand.Read(buffer[:bytes])
+		r.Read(buffer[:bytes])
 		bytes, err = file.Write(buffer[:bytes])
 		if err != nil {
 			LOG_ERROR("RANDOM_FILE", "Failed to write to %s: %v", path, err)
@@ -414,7 +444,7 @@ func createRandomFileSeeded(path string, maxSize int, seed int64) {
 }

 func corruptFile(path string, start int, length int, seed int64) {
-	rand.Seed(seed)
+	r := rand.New(rand.NewSource(seed))

 	file, err := os.OpenFile(path, os.O_WRONLY, 0644)
 	if err != nil {
@@ -435,7 +465,7 @@ func corruptFile(path string, start int, length int, seed int64) {
 	}

 	buffer := make([]byte, length)
-	rand.Read(buffer)
+	r.Read(buffer)

 	_, err = file.Write(buffer)
 	if err != nil {
@@ -478,9 +508,9 @@ func TestPersistRestore(t *testing.T) {
 	maxFileSize := 1000000
 	//maxFileSize := 200000

-	createRandomFileSeeded(testDir+"/repository1/file1", maxFileSize,1)
-	createRandomFileSeeded(testDir+"/repository1/file2", maxFileSize,2)
-	createRandomFileSeeded(testDir+"/repository1/dir1/file3", maxFileSize,3)
+	createRandomFileSeeded(testDir+"/repository1/file1", maxFileSize, 1)
+	createRandomFileSeeded(testDir+"/repository1/file2", maxFileSize, 2)
+	createRandomFileSeeded(testDir+"/repository1/dir1/file3", maxFileSize, 3)

 	threads := 1

@@ -530,85 +560,83 @@ func TestPersistRestore(t *testing.T) {

 	// do unencrypted backup
 	SetDuplicacyPreferencePath(testDir + "/repository1/.duplicacy")
-	unencBackupManager := CreateBackupManager("host1", unencStorage, testDir, "", "", "", false)
+	unencBackupManager := CreateBackupManager("host1", unencStorage, testDir, "", nil)
 	unencBackupManager.SetupSnapshotCache("default")

 	SetDuplicacyPreferencePath(testDir + "/repository1/.duplicacy")
 	unencBackupManager.Backup(testDir+"/repository1" /*quickMode=*/, true, threads, "first", false, false, 0, false, 1024, 1024)
 	time.Sleep(time.Duration(delay) * time.Second)

-
 	// do encrypted backup
 	SetDuplicacyPreferencePath(testDir + "/repository1/.duplicacy")
-	encBackupManager := CreateBackupManager("host1", storage, testDir, password, "", "", false)
+	encBackupManager := CreateBackupManager("host1", storage, testDir, password, nil)
 	encBackupManager.SetupSnapshotCache("default")

 	SetDuplicacyPreferencePath(testDir + "/repository1/.duplicacy")
 	encBackupManager.Backup(testDir+"/repository1" /*quickMode=*/, true, threads, "first", false, false, 0, false, 1024, 1024)
 	time.Sleep(time.Duration(delay) * time.Second)

-
 	// check snapshots
-	unencBackupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1", /*revisions*/ []int{1}, /*tag*/ "",
-		/*showStatistics*/ true, /*showTabular*/ false, /*checkFiles*/ true, /*checkChunks*/ false,
-		/*searchFossils*/ false, /*resurrect*/ false, /*rewiret*/ false, 1, /*allowFailures*/ false)
+	unencBackupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1" /*revisions*/, []int{1} /*tag*/, "",
+		/*showStatistics*/ true /*showTabular*/, false /*checkFiles*/, true /*checkChunks*/, false,
+		/*searchFossils*/ false /*resurrect*/, false /*rewiret*/, false, 1 /*allowFailures*/, false)
+
+	encBackupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1" /*revisions*/, []int{1} /*tag*/, "",
+		/*showStatistics*/ true /*showTabular*/, false /*checkFiles*/, true /*checkChunks*/, false,
+		/*searchFossils*/ false /*resurrect*/, false /*rewiret*/, false, 1 /*allowFailures*/, false)

-	encBackupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1", /*revisions*/ []int{1}, /*tag*/ "",
-		/*showStatistics*/ true, /*showTabular*/ false, /*checkFiles*/ true, /*checkChunks*/ false,
-		 /*searchFossils*/ false, /*resurrect*/ false, /*rewiret*/ false, 1, /*allowFailures*/ false)
-		
 	// check functions
 	checkAllUncorrupted := func(cmpRepository string) {
-			for _, f := range []string{"file1", "file2", "dir1/file3"} {
-				if _, err := os.Stat(testDir + cmpRepository + "/" + f); os.IsNotExist(err) {
-					t.Errorf("File %s does not exist", f)
-					continue
-				}
-
-				hash1 := getFileHash(testDir + "/repository1/" + f)
-				hash2 := getFileHash(testDir + cmpRepository + "/" + f)
-				if hash1 != hash2 {
-					t.Errorf("File %s has different hashes: %s vs %s", f, hash1, hash2)
-				}
-		}
-	}
-	checkMissingFile := func(cmpRepository string, expectMissing string) {
-			for _, f := range []string{"file1", "file2", "dir1/file3"} {
-				_, err := os.Stat(testDir + cmpRepository + "/" + f)
-				if err==nil {
-					if f==expectMissing {
-						t.Errorf("File %s exists, expected to be missing", f)
-					}
-					continue
-				}
-				if os.IsNotExist(err) {
-					if f!=expectMissing {
-						t.Errorf("File %s does not exist", f)
-					}
-					continue
-				}
-
-				hash1 := getFileHash(testDir + "/repository1/" + f)
-				hash2 := getFileHash(testDir + cmpRepository + "/" + f)
-				if hash1 != hash2 {
-					t.Errorf("File %s has different hashes: %s vs %s", f, hash1, hash2)
-				}
-		}
-	}
-	checkCorruptedFile  := func(cmpRepository string, expectCorrupted string) {
 		for _, f := range []string{"file1", "file2", "dir1/file3"} {
 			if _, err := os.Stat(testDir + cmpRepository + "/" + f); os.IsNotExist(err) {
 				t.Errorf("File %s does not exist", f)
 				continue
 			}
-	
+
 			hash1 := getFileHash(testDir + "/repository1/" + f)
 			hash2 := getFileHash(testDir + cmpRepository + "/" + f)
-			if (f==expectCorrupted) {
+			if hash1 != hash2 {
+				t.Errorf("File %s has different hashes: %s vs %s", f, hash1, hash2)
+			}
+		}
+	}
+	checkMissingFile := func(cmpRepository string, expectMissing string) {
+		for _, f := range []string{"file1", "file2", "dir1/file3"} {
+			_, err := os.Stat(testDir + cmpRepository + "/" + f)
+			if err == nil {
+				if f == expectMissing {
+					t.Errorf("File %s exists, expected to be missing", f)
+				}
+				continue
+			}
+			if os.IsNotExist(err) {
+				if f != expectMissing {
+					t.Errorf("File %s does not exist", f)
+				}
+				continue
+			}
+
+			hash1 := getFileHash(testDir + "/repository1/" + f)
+			hash2 := getFileHash(testDir + cmpRepository + "/" + f)
+			if hash1 != hash2 {
+				t.Errorf("File %s has different hashes: %s vs %s", f, hash1, hash2)
+			}
+		}
+	}
+	checkCorruptedFile := func(cmpRepository string, expectCorrupted string) {
+		for _, f := range []string{"file1", "file2", "dir1/file3"} {
+			if _, err := os.Stat(testDir + cmpRepository + "/" + f); os.IsNotExist(err) {
+				t.Errorf("File %s does not exist", f)
+				continue
+			}
+
+			hash1 := getFileHash(testDir + "/repository1/" + f)
+			hash2 := getFileHash(testDir + cmpRepository + "/" + f)
+			if f == expectCorrupted {
 				if hash1 == hash2 {
 					t.Errorf("File %s has same hashes, expected to be corrupted: %s vs %s", f, hash1, hash2)
 				}
-	
+
 			} else {
 				if hash1 != hash2 {
 					t.Errorf("File %s has different hashes: %s vs %s", f, hash1, hash2)
@@ -619,27 +647,35 @@ func TestPersistRestore(t *testing.T) {

 	// test restore all uncorrupted to repository3
 	SetDuplicacyPreferencePath(testDir + "/repository3/.duplicacy")
-	failedFiles := unencBackupManager.Restore(testDir+"/repository3", threads /*inPlace=*/, true /*quickMode=*/, false, threads /*overwrite=*/, false,
-		 /*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, false)
+	failedFiles := unencBackupManager.Restore(testDir+"/repository3", 1, &RestoreOptions{
+		Threads:        threads,
+		Patterns:       nil,
+		InPlace:        true,
+		QuickMode:      false,
+		Overwrite:      false,
+		DeleteMode:     false,
+		ShowStatistics: false,
+		AllowFailures:  false,
+	})
 	assertRestoreFailures(t, failedFiles, 0)
 	checkAllUncorrupted("/repository3")

 	// test for corrupt files and -persist
-	// corrupt a chunk 
+	// corrupt a chunk
 	chunkToCorrupt1 := "/4d/538e5dfd2b08e782bfeb56d1360fb5d7eb9d8c4b2531cc2fca79efbaec910c"
-		// this should affect file1
+	// this should affect file1
 	chunkToCorrupt2 := "/2b/f953a766d0196ce026ae259e76e3c186a0e4bcd3ce10f1571d17f86f0a5497"
-		// this should affect dir1/file3
-	
+	// this should affect dir1/file3
+
 	for i := 0; i < 2; i++ {
-		if i==0 {
+		if i == 0 {
 			// test corrupt chunks
 			corruptFile(testDir+"/unenc_storage"+"/chunks"+chunkToCorrupt1, 128, 128, 4)
 			corruptFile(testDir+"/enc_storage"+"/chunks"+chunkToCorrupt2, 128, 128, 4)
 		} else {
 			// test missing chunks
-			os.Remove(testDir+"/unenc_storage"+"/chunks"+chunkToCorrupt1)
-			os.Remove(testDir+"/enc_storage"+"/chunks"+chunkToCorrupt2)
+			os.Remove(testDir + "/unenc_storage" + "/chunks" + chunkToCorrupt1)
+			os.Remove(testDir + "/enc_storage" + "/chunks" + chunkToCorrupt2)
 		}

 		// This is to make sure that allowFailures is set to true.  Note that this is not needed
@@ -654,30 +690,44 @@ func TestPersistRestore(t *testing.T) {

 		// check snapshots with --persist (allowFailures == true)
 		// this would cause a panic and os.Exit from duplicacy_log if allowFailures == false
-		unencBackupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1", /*revisions*/ []int{1}, /*tag*/ "",
-			/*showStatistics*/ true, /*showTabular*/ false, /*checkFiles*/ true, /*checkChunks*/ false,
-			/*searchFossils*/ false, /*resurrect*/ false, /*rewrite*/ false, 1, /*allowFailures*/ true)
+		unencBackupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1" /*revisions*/, []int{1} /*tag*/, "",
+			/*showStatistics*/ true /*showTabular*/, false /*checkFiles*/, true /*checkChunks*/, false,
+			/*searchFossils*/ false /*resurrect*/, false /*rewrite*/, false, 1 /*allowFailures*/, true)

-		encBackupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1", /*revisions*/ []int{1}, /*tag*/ "",
-			/*showStatistics*/ true, /*showTabular*/ false, /*checkFiles*/ true, /*checkChunks*/ false,
-			/*searchFossils*/ false, /*resurrect*/ false, /*rewrite*/ false, 1, /*allowFailures*/ true)
+		encBackupManager.SnapshotManager.CheckSnapshots( /*snapshotID*/ "host1" /*revisions*/, []int{1} /*tag*/, "",
+			/*showStatistics*/ true /*showTabular*/, false /*checkFiles*/, true /*checkChunks*/, false,
+			/*searchFossils*/ false /*resurrect*/, false /*rewrite*/, false, 1 /*allowFailures*/, true)

-	
 		// test restore corrupted, inPlace = true, corrupted files will have hash failures
-		os.RemoveAll(testDir+"/repository2")
+		os.RemoveAll(testDir + "/repository2")
 		SetDuplicacyPreferencePath(testDir + "/repository2/.duplicacy")
-		failedFiles = unencBackupManager.Restore(testDir+"/repository2", threads /*inPlace=*/, true /*quickMode=*/, false, threads /*overwrite=*/, false,
-			/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, true)
+		failedFiles = unencBackupManager.Restore(testDir+"/repository2", 1, &RestoreOptions{
+			Threads:        threads,
+			Patterns:       nil,
+			InPlace:        true,
+			QuickMode:      false,
+			Overwrite:      false,
+			DeleteMode:     false,
+			ShowStatistics: false,
+			AllowFailures:  true,
+		})
 		assertRestoreFailures(t, failedFiles, 1)

 		// check restore, expect file1 to be corrupted
 		checkCorruptedFile("/repository2", "file1")

-		
-		os.RemoveAll(testDir+"/repository2")
+		os.RemoveAll(testDir + "/repository2")
 		SetDuplicacyPreferencePath(testDir + "/repository2/.duplicacy")
-		failedFiles = encBackupManager.Restore(testDir+"/repository2", threads /*inPlace=*/, true /*quickMode=*/, false, threads /*overwrite=*/, false,
-			/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, true)
+		failedFiles = encBackupManager.Restore(testDir+"/repository2", 1, &RestoreOptions{
+			Threads:        threads,
+			Patterns:       nil,
+			InPlace:        true,
+			QuickMode:      false,
+			Overwrite:      false,
+			DeleteMode:     false,
+			ShowStatistics: false,
+			AllowFailures:  true,
+		})
 		assertRestoreFailures(t, failedFiles, 1)

 		// check restore, expect file3 to be corrupted
@@ -685,20 +735,35 @@ func TestPersistRestore(t *testing.T) {

 		//SetLoggingLevel(DEBUG)
 		// test restore corrupted, inPlace = false, corrupted files will be missing
-		os.RemoveAll(testDir+"/repository2")
+		os.RemoveAll(testDir + "/repository2")
 		SetDuplicacyPreferencePath(testDir + "/repository2/.duplicacy")
-		failedFiles = unencBackupManager.Restore(testDir+"/repository2", threads /*inPlace=*/, false /*quickMode=*/, false, threads /*overwrite=*/, false,
-			/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, true)
+		failedFiles = unencBackupManager.Restore(testDir+"/repository2", 1, &RestoreOptions{
+			Threads:        threads,
+			Patterns:       nil,
+			InPlace:        false,
+			QuickMode:      false,
+			Overwrite:      false,
+			DeleteMode:     false,
+			ShowStatistics: false,
+			AllowFailures:  true,
+		})
 		assertRestoreFailures(t, failedFiles, 1)

 		// check restore, expect file1 to be corrupted
 		checkMissingFile("/repository2", "file1")

-		
-		os.RemoveAll(testDir+"/repository2")
+		os.RemoveAll(testDir + "/repository2")
 		SetDuplicacyPreferencePath(testDir + "/repository2/.duplicacy")
-		failedFiles = encBackupManager.Restore(testDir+"/repository2", threads /*inPlace=*/, false /*quickMode=*/, false, threads /*overwrite=*/, false,
-			/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, true)
+		failedFiles = encBackupManager.Restore(testDir+"/repository2", 1, &RestoreOptions{
+			Threads:        threads,
+			Patterns:       nil,
+			InPlace:        false,
+			QuickMode:      false,
+			Overwrite:      false,
+			DeleteMode:     false,
+			ShowStatistics: false,
+			AllowFailures:  true,
+		})
 		assertRestoreFailures(t, failedFiles, 1)

 		// check restore, expect file3 to be corrupted
@@ -707,28 +772,60 @@ func TestPersistRestore(t *testing.T) {
 		// test restore corrupted files from different backups, inPlace = true
 		// with overwrite=true, corrupted file1 from unenc will be restored correctly from enc
 		// the latter will not touch the existing file3 with correct hash
-		os.RemoveAll(testDir+"/repository2")
-		failedFiles = unencBackupManager.Restore(testDir+"/repository2", threads /*inPlace=*/, true /*quickMode=*/, false, threads /*overwrite=*/, false,
-			/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, true)
+		os.RemoveAll(testDir + "/repository2")
+		failedFiles = unencBackupManager.Restore(testDir+"/repository2", 1, &RestoreOptions{
+			Threads:        threads,
+			Patterns:       nil,
+			InPlace:        true,
+			QuickMode:      false,
+			Overwrite:      false,
+			DeleteMode:     false,
+			ShowStatistics: false,
+			AllowFailures:  true,
+		})
 		assertRestoreFailures(t, failedFiles, 1)

-		failedFiles = encBackupManager.Restore(testDir+"/repository2", threads /*inPlace=*/, true /*quickMode=*/, false, threads /*overwrite=*/, true,
-			/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, true)
+		failedFiles = encBackupManager.Restore(testDir+"/repository2", 1, &RestoreOptions{
+			Threads:        threads,
+			Patterns:       nil,
+			InPlace:        true,
+			QuickMode:      false,
+			Overwrite:      true,
+			DeleteMode:     false,
+			ShowStatistics: false,
+			AllowFailures:  true,
+		})
 		assertRestoreFailures(t, failedFiles, 0)
 		checkAllUncorrupted("/repository2")

 		// restore to repository3, with overwrite and allowFailures (true/false), quickMode = false (use hashes)
 		// should always succeed as uncorrupted files already exist with correct hash, so these will be ignored
 		SetDuplicacyPreferencePath(testDir + "/repository3/.duplicacy")
-		failedFiles = unencBackupManager.Restore(testDir+"/repository3", threads /*inPlace=*/, true /*quickMode=*/, false, threads /*overwrite=*/, true,
-			/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, false)
+		failedFiles = unencBackupManager.Restore(testDir+"/repository3", 1, &RestoreOptions{
+			Threads:        threads,
+			Patterns:       nil,
+			InPlace:        true,
+			QuickMode:      false,
+			Overwrite:      true,
+			DeleteMode:     false,
+			ShowStatistics: false,
+			AllowFailures:  false,
+		})
 		assertRestoreFailures(t, failedFiles, 0)
 		checkAllUncorrupted("/repository3")

-		failedFiles = unencBackupManager.Restore(testDir+"/repository3", threads /*inPlace=*/, true /*quickMode=*/, false, threads /*overwrite=*/, true,
-			/*deleteMode=*/ false /*setowner=*/, false /*showStatistics=*/, false /*patterns=*/, nil /*allowFailures=*/, true)
+		failedFiles = unencBackupManager.Restore(testDir+"/repository3", 1, &RestoreOptions{
+			Threads:        threads,
+			Patterns:       nil,
+			InPlace:        true,
+			QuickMode:      false,
+			Overwrite:      true,
+			DeleteMode:     false,
+			ShowStatistics: false,
+			AllowFailures:  true,
+		})
 		assertRestoreFailures(t, failedFiles, 0)
 		checkAllUncorrupted("/repository3")
 	}

-}
+}
--- a/src/duplicacy_config.go
+++ b/src/duplicacy_config.go
@@ -85,8 +85,8 @@ type Config struct {
 	FileKey []byte `json:"-"`

 	// for erasure coding
-	DataShards int `json:'data-shards'`
-	ParityShards int `json:'parity-shards'`
+	DataShards int `json:"data-shards"`
+	ParityShards int `json:"parity-shards"`

 	// for RSA encryption
 	rsaPrivateKey *rsa.PrivateKey
--- a/src/duplicacy_entry.go
+++ b/src/duplicacy_entry.go
@@ -8,6 +8,7 @@ import (
 	"crypto/sha256"
 	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -17,12 +18,16 @@ import (
 	"sort"
 	"strconv"
 	"strings"
-	"syscall"
 	"time"

 	"github.com/vmihailenco/msgpack"
 )

+const (
+	entryHardLinkRootChunkMarker   = -9
+	entryHardLinkTargetChunkMarker = -10
+)
+
 // This is the hidden directory in the repository for storing various files.
 var DUPLICACY_DIRECTORY = ".duplicacy"
 var DUPLICACY_FILE = ".duplicacy"
@@ -93,7 +98,7 @@ func CreateEntryFromFileInfo(fileInfo os.FileInfo, directory string) *Entry {
 		Mode: uint32(mode),
 	}

-	GetOwner(entry, &fileInfo)
+	GetOwner(entry, fileInfo)

 	return entry
 }
@@ -119,22 +124,31 @@ func (entry *Entry) Copy() *Entry {
 	}
 }

-func (entry *Entry) LinkTo(target *Entry) *Entry {
+func (entry *Entry) HardLinkTo(target *Entry, startChunk int, endChunk int) *Entry {
+	endOffset := target.EndOffset
+	link := entry.Link
+
+	if !target.IsFile() {
+		startChunk = target.StartChunk
+		endChunk = entry.EndChunk
+		endOffset = entry.EndOffset
+		link = target.Link
+	}
 	return &Entry{
 		Path: entry.Path,
 		Size: target.Size,
 		Time: target.Time,
 		Mode: target.Mode,
-		Link: entry.Link,
+		Link: link,
 		Hash: target.Hash,

 		UID: target.UID,
 		GID: target.GID,

-		StartChunk:  target.StartChunk,
+		StartChunk:  startChunk,
 		StartOffset: target.StartOffset,
-		EndChunk:    target.EndChunk,
-		EndOffset:   target.EndOffset,
+		EndChunk:    endChunk,
+		EndOffset:   endOffset,

 		Attributes: target.Attributes,
 	}
@@ -509,20 +523,32 @@ func (entry *Entry) IsLink() bool {
 	return entry.Mode&uint32(os.ModeSymlink) != 0
 }

+func (entry *Entry) IsSpecial() bool {
+	return entry.Mode&uint32(os.ModeNamedPipe|os.ModeDevice|os.ModeCharDevice|os.ModeSocket) != 0
+}
+
 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) IsHardLinkChild() bool {
+	return (entry.IsFile() && len(entry.Link) > 0 && entry.Link != "/") || (!entry.IsDir() && entry.EndChunk == entryHardLinkTargetChunkMarker)
 }

-func (entry *Entry) IsHardlinkedFrom() bool {
-	return entry.IsFile() && len(entry.Link) > 0 && entry.Link != "/"
+func (entry *Entry) IsHardLinkRoot() bool {
+	return (entry.IsFile() && entry.Link == "/") || (!entry.IsDir() && entry.EndChunk == entryHardLinkRootChunkMarker)
 }

-func (entry *Entry) IsHardlinkRoot() bool {
-	return entry.IsFile() && entry.Link == "/"
+func (entry *Entry) GetHardLinkId() (int, error) {
+	if entry.IsFile() {
+		i, err := strconv.ParseUint(entry.Link, 16, 64)
+		return int(i), err
+	} else {
+		if entry.EndChunk != entryHardLinkTargetChunkMarker {
+			return 0, errors.New("Entry not marked as hard link child")
+		}
+		return entry.EndOffset, nil
+	}
 }

 func (entry *Entry) GetPermissions() os.FileMode {
@@ -556,45 +582,64 @@ func (entry *Entry) String(maxSizeDigits int) string {
 	return fmt.Sprintf("%*d %s %64s %s", maxSizeDigits, entry.Size, modifiedTime, entry.Hash, entry.Path)
 }

-func (entry *Entry) RestoreMetadata(fullPath string, fileInfo *os.FileInfo, setOwner bool) bool {
+type RestoreMetadataOptions struct {
+	SetOwner         bool
+	ExcludeXattrs    bool
+	NormalizeXattrs  bool
+	IncludeFileFlags bool
+	FileFlagsMask    uint32
+}
+
+func (entry *Entry) RestoreMetadata(fullPath string, fileInfo os.FileInfo,
+	options RestoreMetadataOptions) bool {

 	if fileInfo == nil {
-		stat, err := os.Lstat(fullPath)
-		fileInfo = &stat
+		var err error
+		fileInfo, err = os.Lstat(fullPath)
 		if err != nil {
-			LOG_ERROR("RESTORE_STAT", "Failed to retrieve the file info: %v", err)
+			LOG_ERROR("RESTORE_STAT", "Failed to retrieve the file info on %s: %v", entry.Path, err)
 			return false
 		}
 	}

+	if !options.ExcludeXattrs {
+		err := entry.SetAttributesToFile(fullPath, options.NormalizeXattrs)
+		if err != nil {
+			LOG_WARN("RESTORE_ATTR", "Failed to set extended attributes on %s: %v", entry.Path, err)
+		}
+	}
+
 	// Note that chown can remove setuid/setgid bits so should be called before chmod
-	if setOwner {
+	if options.SetOwner {
 		if !SetOwner(fullPath, entry, fileInfo) {
 			return false
 		}
 	}

 	// Only set the permission if the file is not a symlink
-	if !entry.IsLink() && (*fileInfo).Mode()&fileModeMask != entry.GetPermissions() {
+	if !entry.IsLink() && fileInfo.Mode()&fileModeMask != entry.GetPermissions() {
 		err := os.Chmod(fullPath, entry.GetPermissions())
 		if err != nil {
-			LOG_ERROR("RESTORE_CHMOD", "Failed to set the file permissions: %v", err)
+			LOG_ERROR("RESTORE_CHMOD", "Failed to set the file permissions on %s: %v", entry.Path, err)
 			return false
 		}
 	}

 	// Only set the time if the file is not a symlink
-	if !entry.IsLink() && (*fileInfo).ModTime().Unix() != entry.Time {
+	if !entry.IsLink() && fileInfo.ModTime().Unix() != entry.Time {
 		modifiedTime := time.Unix(entry.Time, 0)
 		err := os.Chtimes(fullPath, modifiedTime, modifiedTime)
 		if err != nil {
-			LOG_ERROR("RESTORE_CHTIME", "Failed to set the modification time: %v", err)
+			LOG_ERROR("RESTORE_CHTIME", "Failed to set the modification time on %s: %v", entry.Path, err)
 			return false
 		}
 	}

-	if entry.Attributes != nil && len(*entry.Attributes) > 0 {
-		entry.SetAttributesToFile(fullPath)
+	if options.IncludeFileFlags {
+		err := entry.RestoreLateFileFlags(fullPath, fileInfo, options.FileFlagsMask)
+		if err != nil {
+			LOG_WARN("RESTORE_FLAGS", "Failed to set file flags on %s: %v", entry.Path, err)
+		}
 	}

 	return true
@@ -727,26 +772,39 @@ func (files FileInfoCompare) Less(i, j int) bool {
 	}
 }

-type listEntryLinkKey struct {
-	dev uint64
-	ino uint64
+type EntryListerOptions struct {
+	Patterns           []string
+	NoBackupFile       string
+	ExcludeByAttribute bool
+	ExcludeXattrs      bool
+	NormalizeXattr     bool
+	IncludeFileFlags   bool
+	IncludeSpecials    bool
 }

-type ListingState struct {
-	linkTable map[listEntryLinkKey]string // map unique inode details to initially found path
+type EntryLister interface {
+	ListDir(top string, path string, listingChannel chan *Entry, options *EntryListerOptions) (directoryList []*Entry, skippedFiles []string, err error)
 }

-func NewListingState() *ListingState {
-	return &ListingState{
-		linkTable: make(map[listEntryLinkKey]string),
+type LocalDirectoryLister struct {
+	linkIndex int
+	linkTable map[listEntryLinkKey]int // map unique inode details to initially found path
+}
+
+func NewLocalDirectoryLister() *LocalDirectoryLister {
+	return &LocalDirectoryLister{
+		linkTable: make(map[listEntryLinkKey]int),
 	}
 }

-// 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) {
+// ListDir returns a list of entries representing file and subdirectories under the directory 'path'.
+// Entry paths are normalized as relative to 'top'.
+func (dl *LocalDirectoryLister) ListDir(top string, path string, listingChannel chan *Entry,
+	options *EntryListerOptions) (directoryList []*Entry, skippedFiles []string, err error) {
+
+	if options == nil {
+		options = &EntryListerOptions{}
+	}

 	LOG_DEBUG("LIST_ENTRIES", "Listing %s", path)

@@ -759,10 +817,12 @@ func ListEntries(top string, path string, patterns []string, nobackupFile string
 		return directoryList, nil, err
 	}

+	patterns := options.Patterns
+
 	// This binary search works because ioutil.ReadDir returns files sorted by Name() by default
-	if nobackupFile != "" {
-		ii := sort.Search(len(files), func(ii int) bool { return strings.Compare(files[ii].Name(), nobackupFile) >= 0 })
-		if ii < len(files) && files[ii].Name() == nobackupFile {
+	if options.NoBackupFile != "" {
+		ii := sort.Search(len(files), func(ii int) bool { return strings.Compare(files[ii].Name(), options.NoBackupFile) >= 0 })
+		if ii < len(files) && files[ii].Name() == options.NoBackupFile {
 			LOG_DEBUG("LIST_NOBACKUP", "%s is excluded due to nobackup file", path)
 			return directoryList, skippedFiles, nil
 		}
@@ -784,13 +844,44 @@ func ListEntries(top string, path string, patterns []string, nobackupFile string
 		if f.Name() == DUPLICACY_DIRECTORY {
 			continue
 		}
+
 		entry := CreateEntryFromFileInfo(f, normalizedPath)
 		if len(patterns) > 0 && !MatchPath(entry.Path, patterns) {
 			continue
 		}
+
+		linkKey, isHardLinked := entry.getHardLinkKey(f)
+		if isHardLinked {
+			if linkIndex, seen := dl.linkTable[linkKey]; seen {
+				if linkIndex == -1 {
+					LOG_DEBUG("LIST_EXCLUDE", "%s was excluded or skipped (hard link)", entry.Path)
+					continue
+				}
+
+				entry.Size = 0
+				if entry.IsFile() {
+					entry.Link = strconv.FormatInt(int64(linkIndex), 16)
+				} else {
+					entry.EndChunk = entryHardLinkTargetChunkMarker
+					entry.EndOffset = linkIndex
+				}
+				listingChannel <- entry
+				continue
+			} else {
+				if entry.IsFile() {
+					entry.Link = "/"
+				} else {
+					entry.EndChunk = entryHardLinkRootChunkMarker
+				}
+				dl.linkTable[linkKey] = -1
+			}
+		}
+
+		fullPath := joinPath(top, entry.Path)
+
 		if entry.IsLink() {
 			isRegular := false
-			isRegular, entry.Link, err = Readlink(joinPath(top, entry.Path))
+			isRegular, entry.Link, err = Readlink(fullPath)
 			if err != nil {
 				LOG_WARN("LIST_LINK", "Failed to read the symlink %s: %v", entry.Path, err)
 				skippedFiles = append(skippedFiles, entry.Path)
@@ -800,7 +891,7 @@ func ListEntries(top string, path string, patterns []string, nobackupFile string
 			if isRegular {
 				entry.Mode ^= uint32(os.ModeSymlink)
 			} else if path == "" && (filepath.IsAbs(entry.Link) || filepath.HasPrefix(entry.Link, `\\`)) && !strings.HasPrefix(entry.Link, normalizedTop) {
-				stat, err := os.Stat(joinPath(top, entry.Path))
+				stat, err := os.Stat(fullPath)
 				if err != nil {
 					LOG_WARN("LIST_LINK", "Failed to read the symlink: %v", err)
 					skippedFiles = append(skippedFiles, entry.Path)
@@ -818,33 +909,35 @@ func ListEntries(top string, path string, patterns []string, nobackupFile string
 				}
 				entry = newEntry
 			}
+		} else if options.IncludeSpecials && entry.IsSpecial() {
+			if err := entry.ReadSpecial(fullPath, f); err != nil {
+				LOG_WARN("LIST_DEV", "Failed to save device node %s: %v", entry.Path, err)
+				skippedFiles = append(skippedFiles, entry.Path)
+				continue
+			}
 		}

-		entry.ReadAttributes(top)
+		if !options.ExcludeXattrs {
+			if err := entry.ReadAttributes(f, fullPath, false); err != nil {
+				LOG_WARN("LIST_ATTR", "Failed to read xattrs on %s: %v", entry.Path, err)
+			}
+		}

-		if excludeByAttribute && entry.Attributes != nil && excludedByAttribute(*entry.Attributes) {
+		// if the flags are already in the FileInfo we can keep them
+		if !entry.GetFileFlags(f) && options.IncludeFileFlags {
+			if err := entry.ReadFileFlags(f, fullPath); err != nil {
+				LOG_WARN("LIST_ATTR", "Failed to read file flags on %s: %v", entry.Path, err)
+			}
+		}
+
+		if options.ExcludeByAttribute && entry.Attributes != nil && excludedByAttribute(*entry.Attributes) {
 			LOG_DEBUG("LIST_EXCLUDE", "%s is excluded by attribute", entry.Path)
 			continue
 		}

-		if f.Mode()&(os.ModeNamedPipe|os.ModeSocket|os.ModeDevice) != 0 {
-			LOG_WARN("LIST_SKIP", "Skipped non-regular file %s", entry.Path)
-			skippedFiles = append(skippedFiles, entry.Path)
-			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 isHardLinked {
+			dl.linkTable[linkKey] = dl.linkIndex
+			dl.linkIndex++
 		}

 		if entry.IsDir() {
--- a/src/duplicacy_entry_test.go
+++ b/src/duplicacy_entry_test.go
@@ -7,7 +7,6 @@ package duplicacy
 import (
 	"bytes"
 	"encoding/json"
-	"io/ioutil"
 	"math/rand"
 	"os"
 	"path/filepath"
@@ -166,12 +165,14 @@ func TestEntryOrder(t *testing.T) {
 			continue
 		}

-		err := ioutil.WriteFile(fullPath, []byte(file), 0700)
+		err := os.WriteFile(fullPath, []byte(file), 0700)
 		if err != nil {
 			t.Errorf("WriteFile(%s) returned an error: %s", fullPath, err)
 		}
 	}

+	lister := NewLocalDirectoryLister()
+
 	directories := make([]*Entry, 0, 4)
 	directories = append(directories, CreateEntry("", 0, 0, 0))

@@ -182,7 +183,7 @@ func TestEntryOrder(t *testing.T) {
 	for len(directories) > 0 {
 		directory := directories[len(directories)-1]
 		directories = directories[:len(directories)-1]
-		subdirectories, _, err := ListEntries(testDir, directory.Path, nil, "", false, entryChannel)
+		subdirectories, _, err := lister.ListDir(testDir, directory.Path, entryChannel, nil)
 		if err != nil {
 			t.Errorf("ListEntries(%s, %s) returned an error: %s", testDir, directory.Path, err)
 		}
@@ -240,10 +241,12 @@ func TestEntryExcludeByAttribute(t *testing.T) {
 	if runtime.GOOS == "darwin" {
 		excludeAttrName = "com.apple.metadata:com_apple_backup_excludeItem"
 		excludeAttrValue = []byte("com.apple.backupd")
-	} else if runtime.GOOS == "linux" || runtime.GOOS == "freebsd" || runtime.GOOS == "netbsd" || runtime.GOOS == "solaris" {
+	} else if runtime.GOOS == "linux" {
 		excludeAttrName = "user.duplicacy_exclude"
+	} else if runtime.GOOS == "freebsd" || runtime.GOOS == "netbsd" {
+		excludeAttrName = "duplicacy_exclude"
 	} else {
-		t.Skip("skipping test, not darwin, linux, freebsd, netbsd, or solaris")
+		t.Skip("skipping test, not darwin, linux, freebsd, or netbsd")
 	}

 	testDir := filepath.Join(os.TempDir(), "duplicacy_test")
@@ -273,7 +276,7 @@ func TestEntryExcludeByAttribute(t *testing.T) {
 			continue
 		}

-		err := ioutil.WriteFile(fullPath, []byte(file), 0700)
+		err := os.WriteFile(fullPath, []byte(file), 0700)
 		if err != nil {
 			t.Errorf("WriteFile(%s) returned an error: %s", fullPath, err)
 		}
@@ -288,6 +291,8 @@ func TestEntryExcludeByAttribute(t *testing.T) {

 	for _, excludeByAttribute := range [2]bool{true, false} {
 		t.Logf("testing excludeByAttribute: %t", excludeByAttribute)
+
+		lister := NewLocalDirectoryLister()
 		directories := make([]*Entry, 0, 4)
 		directories = append(directories, CreateEntry("", 0, 0, 0))

@@ -298,7 +303,11 @@ func TestEntryExcludeByAttribute(t *testing.T) {
 		for len(directories) > 0 {
 			directory := directories[len(directories)-1]
 			directories = directories[:len(directories)-1]
-			subdirectories, _, err := ListEntries(testDir, directory.Path, nil, "", excludeByAttribute, entryChannel)
+			subdirectories, _, err := lister.ListDir(testDir, directory.Path, entryChannel,
+				&EntryListerOptions{
+					ExcludeByAttribute: excludeByAttribute,
+				})
+
 			if err != nil {
 				t.Errorf("ListEntries(%s, %s) returned an error: %s", testDir, directory.Path, err)
 			}
--- a/src/duplicacy_entrylist.go
+++ b/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
@@ -113,14 +111,14 @@ func (entryList *EntryList)createOnDiskFile() error {
 // Add an entry to the entry list
 func (entryList *EntryList)AddEntry(entry *Entry) error {

-	if !entry.IsDir() && !entry.IsLink() {
+	if entry.IsFile() {
 		entryList.NumberOfEntries++
 	}

 	if !entry.IsComplete() {
-		if entry.IsDir() || entry.IsLink() {
+		if !entry.IsFile() {
 			entry.Size = 0
-		} else if !entry.IsHardlinkedFrom() {
+		} else {
 			modifiedEntry := ModifiedEntry {
 				Path: entry.Path,
 				Size: -1,
--- a/src/duplicacy_keyring_windows.go
+++ b/src/duplicacy_keyring_windows.go
@@ -6,7 +6,7 @@ package duplicacy

 import (
 	"encoding/json"
-	"io/ioutil"
+	"os"
 	"syscall"
 	"unsafe"
 )
@@ -86,7 +86,7 @@ func keyringGet(key string) (value string) {
 		return ""
 	}

-	description, err := ioutil.ReadFile(keyringFile)
+	description, err := os.ReadFile(keyringFile)
 	if err != nil {
 		LOG_DEBUG("KEYRING_READ", "Keyring file not read: %v", err)
 		return ""
@@ -125,7 +125,7 @@ func keyringSet(key string, value string) bool {

 	keyring := make(map[string][]byte)

-	description, err := ioutil.ReadFile(keyringFile)
+	description, err := os.ReadFile(keyringFile)
 	if err == nil {
 		err = json.Unmarshal(description, &keyring)
 		if err != nil {
@@ -160,7 +160,7 @@ func keyringSet(key string, value string) bool {
 		return false
 	}

-	err = ioutil.WriteFile(keyringFile, description, 0600)
+	err = os.WriteFile(keyringFile, description, 0600)
 	if err != nil {
 		LOG_DEBUG("KEYRING_WRITE", "Failed to save the keyring storage to file %s: %v", keyringFile, err)
 		return false
--- a/src/duplicacy_preference.go
+++ b/src/duplicacy_preference.go
@@ -6,27 +6,57 @@ package duplicacy

 import (
 	"encoding/json"
-	"io/ioutil"
+	"fmt"
 	"os"
 	"path"
 	"reflect"
+	"strconv"
 	"strings"
 )

+type flagsMask uint32
+
+func (f flagsMask) MarshalJSON() ([]byte, error) {
+	return json.Marshal(fmt.Sprintf("0x%.8x", f))
+}
+
+func (f *flagsMask) UnmarshalJSON(data []byte) error {
+	var str string
+	if err := json.Unmarshal(data, &str); err != nil {
+		return err
+	}
+	if str[0] == '0' && (str[1] == 'x' || str[1] == 'X') {
+		str = str[2:]
+	}
+
+	v, err := strconv.ParseUint(string(str), 16, 32)
+	if err != nil {
+		return err
+	}
+	*f = flagsMask(v)
+	return nil
+}
+
 // Preference stores options for each storage.
 type Preference struct {
-	Name              string            `json:"name"`
-	SnapshotID        string            `json:"id"`
-	RepositoryPath    string            `json:"repository"`
-	StorageURL        string            `json:"storage"`
-	Encrypted         bool              `json:"encrypted"`
-	BackupProhibited  bool              `json:"no_backup"`
-	RestoreProhibited bool              `json:"no_restore"`
-	DoNotSavePassword bool              `json:"no_save_password"`
-	NobackupFile      string            `json:"nobackup_file"`
-	Keys              map[string]string `json:"keys"`
-	FiltersFile       string            `json:"filters"`
-	ExcludeByAttribute bool             `json:"exclude_by_attribute"`
+	Name               string            `json:"name"`
+	SnapshotID         string            `json:"id"`
+	RepositoryPath     string            `json:"repository"`
+	StorageURL         string            `json:"storage"`
+	Encrypted          bool              `json:"encrypted"`
+	BackupProhibited   bool              `json:"no_backup"`
+	RestoreProhibited  bool              `json:"no_restore"`
+	DoNotSavePassword  bool              `json:"no_save_password"`
+	NobackupFile       string            `json:"nobackup_file"`
+	Keys               map[string]string `json:"keys"`
+	FiltersFile        string            `json:"filters"`
+	ExcludeOwner       bool              `json:"exclude_owner"`
+	ExcludeByAttribute bool              `json:"exclude_by_attribute"`
+	ExcludeXattrs      bool              `json:"exclude_xattrs"`
+	NormalizeXattrs    bool              `json:"normalize_xattrs"`
+	IncludeFileFlags   bool              `json:"include_file_flags"`
+	IncludeSpecials    bool              `json:"include_specials"`
+	FileFlagsMask      flagsMask         `json:"file_flags_mask"`
 }

 var preferencePath string
@@ -43,7 +73,7 @@ func LoadPreferences(repository string) bool {
 	}

 	if !stat.IsDir() {
-		content, err := ioutil.ReadFile(preferencePath)
+		content, err := os.ReadFile(preferencePath)
 		if err != nil {
 			LOG_ERROR("DOT_DUPLICACY_PATH", "Failed to locate the preference path: %v", err)
 			return false
@@ -61,7 +91,7 @@ func LoadPreferences(repository string) bool {
 		preferencePath = realPreferencePath
 	}

-	description, err := ioutil.ReadFile(path.Join(preferencePath, "preferences"))
+	description, err := os.ReadFile(path.Join(preferencePath, "preferences"))
 	if err != nil {
 		LOG_ERROR("PREFERENCE_OPEN", "Failed to read the preference file from repository %s: %v", repository, err)
 		return false
@@ -110,7 +140,7 @@ func SavePreferences() bool {
 	}
 	preferenceFile := path.Join(GetDuplicacyPreferencePath(), "preferences")

-	err = ioutil.WriteFile(preferenceFile, description, 0600)
+	err = os.WriteFile(preferenceFile, description, 0600)
 	if err != nil {
 		LOG_ERROR("PREFERENCE_WRITE", "Failed to save the preference file %s: %v", preferenceFile, err)
 		return false
--- a/src/duplicacy_shadowcopy_darwin.go
+++ b/src/duplicacy_shadowcopy_darwin.go
@@ -10,7 +10,6 @@ package duplicacy
 import (
 	"context"
 	"errors"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"regexp"
@@ -136,7 +135,7 @@ func CreateShadowCopy(top string, shadowCopy bool, timeoutInSeconds int) (shadow
 	}

 	// Create mount point
-	snapshotPath, err = ioutil.TempDir("/tmp/", "snp_")
+	snapshotPath, err = os.MkdirTemp("/tmp/", "snp_")
 	if err != nil {
 		LOG_ERROR("VSS_CREATE", "Failed to create temporary mount directory")
 		return top
--- a/src/duplicacy_snapshot.go
+++ b/src/duplicacy_snapshot.go
@@ -9,15 +9,13 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 	"time"
-	"sort"
-
-    "github.com/vmihailenco/msgpack"

+	"github.com/vmihailenco/msgpack"
 )

 // Snapshot represents a backup of the repository.
@@ -60,20 +58,41 @@ func CreateEmptySnapshot(id string) (snapshto *Snapshot) {

 type DirectoryListing struct {
 	directory string
-	files *[]Entry
+	files     *[]Entry
 }

-func (snapshot *Snapshot) ListLocalFiles(top string, nobackupFile string,
-								         filtersFile string, excludeByAttribute bool, listingChannel chan *Entry,
-								         skippedDirectories *[]string, skippedFiles *[]string) {
+type ListFilesOptions struct {
+	NoBackupFile       string
+	FiltersFile        string
+	ExcludeByAttribute bool
+	ExcludeXattrs      bool
+	NormalizeXattr     bool
+	IncludeFileFlags   bool
+	IncludeSpecials    bool
+}

-	var patterns []string
-	var listingState = NewListingState()
-
-	if filtersFile == "" {
-		filtersFile = joinPath(GetDuplicacyPreferencePath(), "filters")
+func NewListFilesOptions(p *Preference) *ListFilesOptions {
+	return &ListFilesOptions{
+		NoBackupFile:       p.NobackupFile,
+		FiltersFile:        p.FiltersFile,
+		ExcludeByAttribute: p.ExcludeByAttribute,
+		ExcludeXattrs:      p.ExcludeXattrs,
+		NormalizeXattr:     p.NormalizeXattrs,
+		IncludeFileFlags:   p.IncludeFileFlags,
+		IncludeSpecials:    p.IncludeSpecials,
 	}
-	patterns = ProcessFilters(filtersFile)
+}
+
+func (snapshot *Snapshot) ListLocalFiles(top string,
+	listingChannel chan *Entry, skippedDirectories *[]string, skippedFiles *[]string,
+	options *ListFilesOptions) {
+
+	if options.FiltersFile == "" {
+		options.FiltersFile = joinPath(GetDuplicacyPreferencePath(), "filters")
+	}
+
+	patterns := ProcessFilters(options.FiltersFile)
+	lister := NewLocalDirectoryLister()

 	directories := make([]*Entry, 0, 256)
 	directories = append(directories, CreateEntry("", 0, 0, 0))
@@ -82,7 +101,16 @@ 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 := lister.ListDir(top, directory.Path, listingChannel,
+			&EntryListerOptions{
+				Patterns:           patterns,
+				NoBackupFile:       options.NoBackupFile,
+				ExcludeByAttribute: options.ExcludeByAttribute,
+				ExcludeXattrs:      options.ExcludeXattrs,
+				NormalizeXattr:     options.NormalizeXattr,
+				IncludeFileFlags:   options.IncludeFileFlags,
+				IncludeSpecials:    options.IncludeSpecials,
+			})
 		if err != nil {
 			if directory.Path == "" {
 				LOG_ERROR("LIST_FAILURE", "Failed to list the repository root: %v", err)
@@ -105,7 +133,7 @@ func (snapshot *Snapshot) ListLocalFiles(top string, nobackupFile string,
 	close(listingChannel)
 }

-func (snapshot *Snapshot)ListRemoteFiles(config *Config, chunkOperator *ChunkOperator, entryOut func(*Entry) bool) {
+func (snapshot *Snapshot) ListRemoteFiles(config *Config, chunkOperator *ChunkOperator, entryOut func(*Entry) bool) {

 	var chunks []string
 	for _, chunkHash := range snapshot.FileSequence {
@@ -125,12 +153,12 @@ func (snapshot *Snapshot)ListRemoteFiles(config *Config, chunkOperator *ChunkOpe
 		if chunk != nil {
 			config.PutChunk(chunk)
 		}
-	} ()
+	}()

 	// Normally if Version is 0 then the snapshot is created by CLI v2 but unfortunately CLI 3.0.1 does not set the
 	// version bit correctly when copying old backups.  So we need to check the first byte -- if it is '[' then it is
 	// the old format.  The new format starts with a string encoded in msgpack and the first byte can't be '['.
-	if snapshot.Version == 0 || reader.GetFirstByte() == '['{
+	if snapshot.Version == 0 || reader.GetFirstByte() == '[' {
 		LOG_INFO("SNAPSHOT_VERSION", "snapshot %s at revision %d is encoded in an old version format", snapshot.ID, snapshot.Revision)
 		files := make([]*Entry, 0)
 		decoder := json.NewDecoder(reader)
@@ -201,7 +229,7 @@ func (snapshot *Snapshot)ListRemoteFiles(config *Config, chunkOperator *ChunkOpe

 	} else {
 		LOG_ERROR("SNAPSHOT_VERSION", "snapshot %s at revision %d is encoded in unsupported version %d format",
-				  snapshot.ID, snapshot.Revision, snapshot.Version)
+			snapshot.ID, snapshot.Revision, snapshot.Version)
 		return
 	}

@@ -244,7 +272,7 @@ func ProcessFilterFile(patternFile string, includedFiles []string) (patterns []s
 	}
 	includedFiles = append(includedFiles, patternFile)
 	LOG_INFO("SNAPSHOT_FILTER", "Parsing filter file %s", patternFile)
-	patternFileContent, err := ioutil.ReadFile(patternFile)
+	patternFileContent, err := os.ReadFile(patternFile)
 	if err == nil {
 		patternFileLines := strings.Split(string(patternFileContent), "\n")
 		patterns = ProcessFilterLines(patternFileLines, includedFiles)
@@ -264,7 +292,7 @@ func ProcessFilterLines(patternFileLines []string, includedFiles []string) (patt
 			if patternIncludeFile == "" {
 				continue
 			}
-			if ! filepath.IsAbs(patternIncludeFile) {
+			if !filepath.IsAbs(patternIncludeFile) {
 				basePath := ""
 				if len(includedFiles) == 0 {
 					basePath, _ = os.Getwd()
@@ -491,4 +519,3 @@ func encodeSequence(sequence []string) []string {

 	return sequenceInHex
 }
-
--- a/src/duplicacy_snapshotmanager.go
+++ b/src/duplicacy_snapshotmanager.go
@@ -18,10 +18,10 @@ import (
 	"sort"
 	"strconv"
 	"strings"
-	"text/tabwriter"
-	"time"
 	"sync"
 	"sync/atomic"
+	"text/tabwriter"
+	"time"

 	"github.com/aryann/difflib"
 )
@@ -191,7 +191,7 @@ type SnapshotManager struct {
 	fileChunk     *Chunk
 	snapshotCache *FileStorage

-	chunkOperator   *ChunkOperator
+	chunkOperator *ChunkOperator
 }

 // CreateSnapshotManager creates a snapshot manager
@@ -738,7 +738,7 @@ func (manager *SnapshotManager) ListSnapshots(snapshotID string, revisionsToList
 				totalFileSize := int64(0)
 				lastChunk := 0

-				snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func(file *Entry)bool {
+				snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func(file *Entry) bool {
 					if file.IsFile() {
 						totalFiles++
 						totalFileSize += file.Size
@@ -753,7 +753,7 @@ func (manager *SnapshotManager) ListSnapshots(snapshotID string, revisionsToList
 					return true
 				})

-				snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func(file *Entry)bool {
+				snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func(file *Entry) bool {
 					if file.IsFile() {
 						LOG_INFO("SNAPSHOT_FILE", "%s", file.String(maxSizeDigits))
 					}
@@ -908,7 +908,7 @@ func (manager *SnapshotManager) CheckSnapshots(snapshotID string, revisionsToChe
 						_, exist, _, err := manager.storage.FindChunk(0, chunkID, false)
 						if err != nil {
 							LOG_WARN("SNAPSHOT_VALIDATE", "Failed to check the existence of chunk %s: %v",
-							         chunkID, err)
+								chunkID, err)
 						} else if exist {
 							LOG_INFO("SNAPSHOT_VALIDATE", "Chunk %s is confirmed to exist", chunkID)
 							continue
@@ -1031,7 +1031,7 @@ func (manager *SnapshotManager) CheckSnapshots(snapshotID string, revisionsToChe
 				if err != nil {
 					LOG_WARN("SNAPSHOT_VERIFY", "Failed to save the verified chunks file: %v", err)
 				} else {
-					LOG_INFO("SNAPSHOT_VERIFY", "Added %d chunks to the list of verified chunks", len(verifiedChunks) - numberOfVerifiedChunks)
+					LOG_INFO("SNAPSHOT_VERIFY", "Added %d chunks to the list of verified chunks", len(verifiedChunks)-numberOfVerifiedChunks)
 				}
 			}
 		}
@@ -1073,7 +1073,7 @@ func (manager *SnapshotManager) CheckSnapshots(snapshotID string, revisionsToChe
 			defer CatchLogException()

 			for {
-				chunkIndex, ok := <- chunkChannel
+				chunkIndex, ok := <-chunkChannel
 				if !ok {
 					wg.Done()
 					return
@@ -1093,14 +1093,14 @@ func (manager *SnapshotManager) CheckSnapshots(snapshotID string, revisionsToChe

 				elapsedTime := time.Now().Sub(startTime).Seconds()
 				speed := int64(float64(downloadedChunkSize) / elapsedTime)
-				remainingTime := int64(float64(totalChunks - downloadedChunks) / float64(downloadedChunks) * elapsedTime)
+				remainingTime := int64(float64(totalChunks-downloadedChunks) / float64(downloadedChunks) * elapsedTime)
 				percentage := float64(downloadedChunks) / float64(totalChunks) * 100.0
 				LOG_INFO("VERIFY_PROGRESS", "Verified chunk %s (%d/%d), %sB/s %s %.1f%%",
-						chunkID, downloadedChunks, totalChunks, PrettySize(speed), PrettyTime(remainingTime), percentage)
+					chunkID, downloadedChunks, totalChunks, PrettySize(speed), PrettyTime(remainingTime), percentage)

 				manager.config.PutChunk(chunk)
 			}
-		} ()
+		}()
 	}

 	for chunkIndex := range chunkHashes {
@@ -1289,10 +1289,10 @@ func (manager *SnapshotManager) PrintSnapshot(snapshot *Snapshot) bool {
 	}

 	// Don't print the ending bracket
-	fmt.Printf("%s", string(description[:len(description) - 2]))
+	fmt.Printf("%s", string(description[:len(description)-2]))
 	fmt.Printf(",\n  \"files\": [\n")
 	isFirstFile := true
-	snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func (file *Entry) bool {
+	snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func(file *Entry) bool {

 		fileDescription, _ := json.MarshalIndent(file.convertToObject(false), "", "    ")

@@ -1322,7 +1322,7 @@ func (manager *SnapshotManager) VerifySnapshot(snapshot *Snapshot) bool {
 	}

 	files := make([]*Entry, 0)
-	snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func (file *Entry) bool {
+	snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func(file *Entry) bool {
 		if file.IsFile() && file.Size != 0 {
 			file.Attributes = nil
 			files = append(files, file)
@@ -1426,7 +1426,7 @@ func (manager *SnapshotManager) RetrieveFile(snapshot *Snapshot, file *Entry, la
 func (manager *SnapshotManager) FindFile(snapshot *Snapshot, filePath string, suppressError bool) *Entry {

 	var found *Entry
-	snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func (entry *Entry) bool {
+	snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func(entry *Entry) bool {
 		if entry.Path == filePath {
 			found = entry
 			return false
@@ -1479,8 +1479,8 @@ func (manager *SnapshotManager) PrintFile(snapshotID string, revision int, path

 	file := manager.FindFile(snapshot, path, false)
 	if !manager.RetrieveFile(snapshot, file, nil, func(chunk []byte) {
-			fmt.Printf("%s", chunk)
-		}) {
+		fmt.Printf("%s", chunk)
+	}) {
 		LOG_ERROR("SNAPSHOT_RETRIEVE", "File %s is corrupted in snapshot %s at revision %d",
 			path, snapshot.ID, snapshot.Revision)
 		return false
@@ -1491,7 +1491,8 @@ func (manager *SnapshotManager) PrintFile(snapshotID string, revision int, path

 // Diff compares two snapshots, or two revision of a file if the file argument is given.
 func (manager *SnapshotManager) Diff(top string, snapshotID string, revisions []int,
-	filePath string, compareByHash bool, nobackupFile string, filtersFile string, excludeByAttribute bool) bool {
+	filePath string, compareByHash bool,
+	options *ListFilesOptions) bool {

 	LOG_DEBUG("DIFF_PARAMETERS", "top: %s, id: %s, revision: %v, path: %s, compareByHash: %t",
 		top, snapshotID, revisions, filePath, compareByHash)
@@ -1500,7 +1501,7 @@ func (manager *SnapshotManager) Diff(top string, snapshotID string, revisions []
 	defer func() {
 		manager.chunkOperator.Stop()
 		manager.chunkOperator = nil
-	} ()
+	}()

 	var leftSnapshot *Snapshot
 	var rightSnapshot *Snapshot
@@ -1516,11 +1517,11 @@ func (manager *SnapshotManager) Diff(top string, snapshotID string, revisions []
 			localListingChannel := make(chan *Entry)
 			go func() {
 				defer CatchLogException()
-				rightSnapshot.ListLocalFiles(top, nobackupFile, filtersFile, excludeByAttribute, localListingChannel, nil, nil)
-			} ()
+				rightSnapshot.ListLocalFiles(top, localListingChannel, nil, nil, options)
+			}()

 			for entry := range localListingChannel {
-				entry.Attributes = nil  // attributes are not compared
+				entry.Attributes = nil // attributes are not compared
 				rightSnapshotFiles = append(rightSnapshotFiles, entry)
 			}

@@ -1725,7 +1726,7 @@ func (manager *SnapshotManager) ShowHistory(top string, snapshotID string, revis
 	defer func() {
 		manager.chunkOperator.Stop()
 		manager.chunkOperator = nil
-	} ()
+	}()

 	var err error

@@ -1821,15 +1822,16 @@ func (manager *SnapshotManager) resurrectChunk(fossilPath string, chunkID string

 // PruneSnapshots deletes snapshots by revisions, tags, or a retention policy.  The main idea is two-step
 // fossil collection.
-// 1. Delete snapshots specified by revision, retention policy, with a tag.  Find any resulting unreferenced
-//    chunks, and mark them as fossils (by renaming).  After that, create a fossil collection file containing
-//    fossils collected during current run, and temporary files encountered.  Also in the file is the latest
-//    revision for each snapshot id.  Save this file to a local directory.
 //
-// 2. On next run, check if there is any new revision for each snapshot.  Or if the lastest revision is too
-//    old, for instance, more than 7 days.  This step is to identify snapshots that were being created while
-//    step 1 is in progress.  For each fossil reference by any of these snapshots, move them back to the
-//    normal chunk directory.
+//  1. Delete snapshots specified by revision, retention policy, with a tag.  Find any resulting unreferenced
+//     chunks, and mark them as fossils (by renaming).  After that, create a fossil collection file containing
+//     fossils collected during current run, and temporary files encountered.  Also in the file is the latest
+//     revision for each snapshot id.  Save this file to a local directory.
+//
+//  2. On next run, check if there is any new revision for each snapshot.  Or if the lastest revision is too
+//     old, for instance, more than 7 days.  This step is to identify snapshots that were being created while
+//     step 1 is in progress.  For each fossil reference by any of these snapshots, move them back to the
+//     normal chunk directory.
 //
 // Note that a snapshot being created when step 2 is in progress may reference a fossil.  To avoid this
 // problem, never remove the lastest revision (unless exclusive is true), and only cache chunks referenced
@@ -1853,7 +1855,7 @@ func (manager *SnapshotManager) PruneSnapshots(selfID string, snapshotID string,
 	defer func() {
 		manager.chunkOperator.Stop()
 		manager.chunkOperator = nil
-	} ()
+	}()

 	prefPath := GetDuplicacyPreferencePath()
 	logDir := path.Join(prefPath, "logs")
@@ -2544,7 +2546,7 @@ func (manager *SnapshotManager) CheckSnapshot(snapshot *Snapshot) (err error) {
 			numberOfChunks, len(snapshot.ChunkLengths))
 	}

-	snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func (entry *Entry) bool {
+	snapshot.ListRemoteFiles(manager.config, manager.chunkOperator, func(entry *Entry) bool {

 		if lastEntry != nil && lastEntry.Compare(entry) >= 0 && !strings.Contains(lastEntry.Path, "\ufffd") {
 			err = fmt.Errorf("The entry %s appears before the entry %s", lastEntry.Path, entry.Path)
@@ -2568,7 +2570,7 @@ func (manager *SnapshotManager) CheckSnapshot(snapshot *Snapshot) (err error) {
 		}

 		if entry.EndChunk < entry.StartChunk {
-			fmt.Errorf("The file %s starts at chunk %d and ends at chunk %d",
+			err = fmt.Errorf("The file %s starts at chunk %d and ends at chunk %d",
 				entry.Path, entry.StartChunk, entry.EndChunk)
 			return false
 		}
@@ -2598,7 +2600,7 @@ func (manager *SnapshotManager) CheckSnapshot(snapshot *Snapshot) (err error) {
 		if entry.Size != fileSize {
 			err = fmt.Errorf("The file %s has a size of %d but the total size of chunks is %d",
 				entry.Path, entry.Size, fileSize)
-		    return false
+			return false
 		}

 		return true
@@ -2647,7 +2649,7 @@ func (manager *SnapshotManager) DownloadFile(path string, derivationKey string)
 			err = manager.storage.UploadFile(0, path, newChunk.GetBytes())
 			if err != nil {
 				LOG_WARN("DOWNLOAD_REWRITE", "Failed to re-uploaded the file %s: %v", path, err)
-			} else{
+			} else {
 				LOG_INFO("DOWNLOAD_REWRITE", "The file %s has been re-uploaded", path)
 			}
 		}
--- a/src/duplicacy_storage.go
+++ b/src/duplicacy_storage.go
@@ -756,6 +756,8 @@ func CreateStorage(preference Preference, resetPassword bool, threads int) (stor
 			LOG_ERROR("STORAGE_CREATE", "Failed to load the Storj storage at %s: %v", storageURL, err)
 			return nil
 		}
+		SavePassword(preference, "storj_key", apiKey)
+		SavePassword(preference, "storj_passphrase", passphrase)
 		return storjStorage
 	} else if matched[1] == "smb" {
 		server := matched[3]
--- a/src/duplicacy_utils.go
+++ b/src/duplicacy_utils.go
@@ -7,14 +7,15 @@ package duplicacy
 import (
 	"bufio"
 	"crypto/sha256"
+	"encoding/json"
 	"fmt"
 	"io"
 	"os"
 	"regexp"
+	"runtime"
 	"strconv"
 	"strings"
 	"time"
-	"runtime"

 	"github.com/gilbertchen/gopass"
 	"golang.org/x/crypto/pbkdf2"
@@ -56,7 +57,7 @@ func IsEmptyFilter(pattern string) bool {
 }

 func IsUnspecifiedFilter(pattern string) bool {
-	if pattern[0] != '+' && pattern[0] != '-' && !strings.HasPrefix(pattern, "i:") && !strings.HasPrefix(pattern, "e:")  {
+	if pattern[0] != '+' && pattern[0] != '-' && !strings.HasPrefix(pattern, "i:") && !strings.HasPrefix(pattern, "e:") {
 		return true
 	} else {
 		return false
@@ -275,7 +276,6 @@ func SavePassword(preference Preference, passwordType string, password string) {
 // The following code was modified from the online article  'Matching Wildcards: An Algorithm', by Kirk J. Krauss,
 // Dr. Dobb's, August 26, 2008. However, the version in the article doesn't handle cases like matching 'abcccd'
 // against '*ccd', and the version here fixed that issue.
-//
 func matchPattern(text string, pattern string) bool {

 	textLength := len(text)
@@ -469,8 +469,39 @@ func PrintMemoryUsage() {
 		runtime.ReadMemStats(&m)

 		LOG_INFO("MEMORY_STATS", "Currently allocated: %s, total allocated: %s, system memory: %s, number of GCs: %d",
-		         PrettySize(int64(m.Alloc)), PrettySize(int64(m.TotalAlloc)), PrettySize(int64(m.Sys)), m.NumGC)
+			PrettySize(int64(m.Alloc)), PrettySize(int64(m.TotalAlloc)), PrettySize(int64(m.Sys)), m.NumGC)

 		time.Sleep(time.Second)
 	}
-}
+}
+
+func (entry *Entry) dump() map[string]interface{} {
+
+	object := make(map[string]interface{})
+
+	object["path"] = entry.Path
+	object["size"] = entry.Size
+	object["time"] = entry.Time
+	object["mode"] = entry.Mode
+	object["hash"] = entry.Hash
+	object["link"] = entry.Link
+
+	object["content"] = fmt.Sprintf("%d:%d:%d:%d",
+		entry.StartChunk, entry.StartOffset, entry.EndChunk, entry.EndOffset)
+
+	if entry.UID != -1 && entry.GID != -1 {
+		object["uid"] = entry.UID
+		object["gid"] = entry.GID
+	}
+
+	if entry.Attributes != nil && len(*entry.Attributes) > 0 {
+		object["attributes"] = entry.Attributes
+	}
+
+	return object
+}
+
+func (entry *Entry) dumpString() string {
+	data, _ := json.Marshal(entry.dump())
+	return string(data)
+}
--- a/src/duplicacy_utils_darwin.go
+++ b/src/duplicacy_utils_darwin.go
@@ -5,10 +5,34 @@
 package duplicacy

 import (
+	"encoding/binary"
+	"os"
 	"strings"
+
+	"golang.org/x/sys/unix"
 )

 func excludedByAttribute(attributes map[string][]byte) bool {
 	value, ok := attributes["com.apple.metadata:com_apple_backup_excludeItem"]
-	return ok && strings.Contains(string(value), "com.apple.backupd")
+	excluded := ok && strings.Contains(string(value), "com.apple.backupd")
+	if !excluded {
+		flags, ok := attributes[darwinFileFlagsKey]
+		excluded = ok && (binary.LittleEndian.Uint32(flags)&unix.UF_NODUMP) != 0
+	}
+	return excluded
+}
+
+func (entry *Entry) RestoreSpecial(fullPath string) error {
+	mode := entry.Mode & uint32(fileModeMask)
+
+	if entry.Mode&uint32(os.ModeNamedPipe) != 0 {
+		mode |= unix.S_IFIFO
+	} else if entry.Mode&uint32(os.ModeCharDevice) != 0 {
+		mode |= unix.S_IFCHR
+	} else if entry.Mode&uint32(os.ModeDevice) != 0 {
+		mode |= unix.S_IFBLK
+	} else {
+		return nil
+	}
+	return unix.Mknod(fullPath, mode, int(entry.GetRdev()))
 }
--- a/src/duplicacy_utils_linux.go
+++ b/src/duplicacy_utils_linux.go
@@ -0,0 +1,38 @@
+// 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"
+
+	"golang.org/x/sys/unix"
+)
+
+func excludedByAttribute(attributes map[string][]byte) bool {
+	_, excluded := attributes["user.duplicacy_exclude"]
+	if !excluded {
+		flags, ok := attributes[linuxFileFlagsKey]
+		excluded = ok && (binary.LittleEndian.Uint32(flags)&linux_FS_NODUMP_FL) != 0
+	}
+	return excluded
+}
+
+func (entry *Entry) RestoreSpecial(fullPath string) error {
+	mode := entry.Mode & uint32(fileModeMask)
+
+	if entry.Mode&uint32(os.ModeNamedPipe) != 0 {
+		mode |= unix.S_IFIFO
+	} else if entry.Mode&uint32(os.ModeCharDevice) != 0 {
+		mode |= unix.S_IFCHR
+	} else if entry.Mode&uint32(os.ModeDevice) != 0 {
+		mode |= unix.S_IFBLK
+	} else if entry.Mode&uint32(os.ModeSocket) != 0 {
+		mode |= unix.S_IFSOCK
+	} else {
+		return nil
+	}
+	return unix.Mknod(fullPath, mode, int(entry.GetRdev()))
+}
--- a/src/duplicacy_utils_others.go
+++ b/src/duplicacy_utils_others.go
@@ -2,18 +2,18 @@
 // Free for personal use and commercial trial
 // Commercial use requires per-user licenses available from https://duplicacy.com

+//go:build !windows
 // +build !windows

 package duplicacy

 import (
-	"bytes"
+	"fmt"
 	"os"
 	"path"
-	"path/filepath"
 	"syscall"

-	"github.com/pkg/xattr"
+	"golang.org/x/sys/unix"
 )

 func Readlink(path string) (isRegular bool, s string, err error) {
@@ -21,24 +21,19 @@ func Readlink(path string) (isRegular bool, s string, err error) {
 	return false, s, err
 }

-func GetOwner(entry *Entry, fileInfo *os.FileInfo) {
-	stat, ok := (*fileInfo).Sys().(*syscall.Stat_t)
-	if ok && stat != nil {
-		entry.UID = int(stat.Uid)
-		entry.GID = int(stat.Gid)
-	} else {
-		entry.UID = -1
-		entry.GID = -1
-	}
+func GetOwner(entry *Entry, fileInfo os.FileInfo) {
+	stat := fileInfo.Sys().(*syscall.Stat_t)
+	entry.UID = int(stat.Uid)
+	entry.GID = int(stat.Gid)
 }

-func SetOwner(fullPath string, entry *Entry, fileInfo *os.FileInfo) bool {
-	stat, ok := (*fileInfo).Sys().(*syscall.Stat_t)
-	if ok && stat != nil && (int(stat.Uid) != entry.UID || int(stat.Gid) != entry.GID) {
+func SetOwner(fullPath string, entry *Entry, fileInfo os.FileInfo) bool {
+	stat := fileInfo.Sys().(*syscall.Stat_t)
+	if (int(stat.Uid) != entry.UID || int(stat.Gid) != entry.GID) {
 		if entry.UID != -1 && entry.GID != -1 {
 			err := os.Lchown(fullPath, entry.UID, entry.GID)
 			if err != nil {
-				LOG_ERROR("RESTORE_CHOWN", "Failed to change uid or gid: %v", err)
+				LOG_ERROR("RESTORE_CHOWN", "Failed to change uid or gid on %s: %v", entry.Path, err)
 				return false
 			}
 		}
@@ -47,43 +42,67 @@ func SetOwner(fullPath string, entry *Entry, fileInfo *os.FileInfo) bool {
 	return true
 }

-func (entry *Entry) ReadAttributes(top string) {
-
-	fullPath := filepath.Join(top, entry.Path)
-	attributes, _ := xattr.List(fullPath)
-	if len(attributes) > 0 {
-		entry.Attributes = &map[string][]byte{}
-		for _, name := range attributes {
-			attribute, err := xattr.Get(fullPath, name)
-			if err == nil {
-				(*entry.Attributes)[name] = attribute
-			}
-		}
-	}
+type listEntryLinkKey struct {
+	dev uint64
+	ino uint64
 }

-func (entry *Entry) SetAttributesToFile(fullPath string) {
-	names, _ := xattr.List(fullPath)
+func (entry *Entry) getHardLinkKey(f os.FileInfo) (key listEntryLinkKey, linked bool) {
+	if entry.IsDir() {
+		return
+	}
+	stat := f.Sys().(*syscall.Stat_t)
+	if stat.Nlink <= 1 {
+		return
+	}
+	key.dev = uint64(stat.Dev)
+	key.ino = uint64(stat.Ino)
+	linked = true
+	return
+}

-	for _, name := range names {
+func (entry *Entry) ReadSpecial(fullPath string, fileInfo os.FileInfo) error {
+	if fileInfo.Mode()&(os.ModeDevice|os.ModeCharDevice) == 0 {
+		return nil
+	}
+	rdev := uint64(fileInfo.Sys().(*syscall.Stat_t).Rdev)
+	entry.Size = 0
+	entry.StartChunk = int(rdev & 0xFFFFFFFF)
+	entry.StartOffset = int(rdev >> 32)
+	return nil
+}

+func (entry *Entry) GetRdev() uint64 {
+	return uint64(entry.StartChunk) | uint64(entry.StartOffset)<<32
+}

-		newAttribute, found := (*entry.Attributes)[name]
-		if found {
-			oldAttribute, _ := xattr.Get(fullPath, name)
-			if !bytes.Equal(oldAttribute, newAttribute) {
-				xattr.Set(fullPath, name, newAttribute)
-			}
-			delete(*entry.Attributes, name)
-		} else {
-			xattr.Remove(fullPath, name)
-		}
+func (entry *Entry) IsSameSpecial(fileInfo os.FileInfo) bool {
+	stat := fileInfo.Sys().(*syscall.Stat_t)
+	return (uint32(fileInfo.Mode()) == entry.Mode) && (uint64(stat.Rdev) == entry.GetRdev())
+}
+
+func (entry *Entry) FmtSpecial() string {
+	var c string
+	mode := entry.Mode & uint32(os.ModeType)
+
+	if mode&uint32(os.ModeNamedPipe) != 0 {
+		c = "p"
+	} else if mode&uint32(os.ModeCharDevice) != 0 {
+		c = "c"
+	} else if mode&uint32(os.ModeDevice) != 0 {
+		c = "b"
+	} else if mode&uint32(os.ModeSocket) != 0 {
+		c = "s"
+	} else {
+		return ""
 	}

-	for name, attribute := range *entry.Attributes {
-		xattr.Set(fullPath, name, attribute)
-	}
+	rdev := entry.GetRdev()
+	return fmt.Sprintf("%s (%d, %d)", c, unix.Major(rdev), unix.Minor(rdev))
+}

+func MakeHardlink(source string, target string) error {
+	return unix.Linkat(unix.AT_FDCWD, source, unix.AT_FDCWD, target, 0)
 }

 func joinPath(components ...string) string {
--- a/src/duplicacy_utils_posix.go
+++ b/src/duplicacy_utils_posix.go
@@ -1,13 +0,0 @@
-// 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 || linux || solaris
-// +build freebsd netbsd linux solaris
-
-package duplicacy
-
-func excludedByAttribute(attributes map[string][]byte) bool {
-	_, ok := attributes["user.duplicacy_exclude"]
-	return ok
-}
--- a/src/duplicacy_utils_windows.go
+++ b/src/duplicacy_utils_windows.go
@@ -56,7 +56,11 @@ const (

 // Readlink returns the destination of the named symbolic link.
 func Readlink(path string) (isRegular bool, s string, err error) {
-	fd, err := syscall.CreateFile(syscall.StringToUTF16Ptr(path), FILE_READ_ATTRIBUTES,
+	pPath, err := syscall.UTF16PtrFromString(path)
+	if err != nil {
+		return false, "", err
+	}
+	fd, err := syscall.CreateFile(pPath, FILE_READ_ATTRIBUTES,
 		syscall.FILE_SHARE_READ, nil, syscall.OPEN_EXISTING,
 		syscall.FILE_FLAG_OPEN_REPARSE_POINT|syscall.FILE_FLAG_BACKUP_SEMANTICS, 0)
 	if err != nil {
@@ -101,20 +105,17 @@ func Readlink(path string) (isRegular bool, s string, err error) {
 	return false, s, nil
 }

-func GetOwner(entry *Entry, fileInfo *os.FileInfo) {
+func GetOwner(entry *Entry, fileInfo os.FileInfo) {
 	entry.UID = -1
 	entry.GID = -1
 }

-func SetOwner(fullPath string, entry *Entry, fileInfo *os.FileInfo) bool {
+func SetOwner(fullPath string, entry *Entry, fileInfo os.FileInfo) bool {
 	return true
 }

-func (entry *Entry) ReadAttributes(top string) {
-}
-
-func (entry *Entry) SetAttributesToFile(fullPath string) {
-
+func MakeHardlink(source string, target string) error {
+	return os.Link(source, target)
 }

 func joinPath(components ...string) string {
@@ -135,3 +136,25 @@ func SplitDir(fullPath string) (dir string, file string) {
 func excludedByAttribute(attributes map[string][]byte) bool {
 	return false
 }
+
+type listEntryLinkKey struct{}
+
+func (entry *Entry) getHardLinkKey(f os.FileInfo) (key listEntryLinkKey, linked bool) {
+	return
+}
+
+func (entry *Entry) ReadSpecial(fullPath string, fileInfo os.FileInfo) error {
+	return nil
+}
+
+func (entry *Entry) IsSameSpecial(fileInfo os.FileInfo) bool {
+	return false
+}
+
+func (entry *Entry) RestoreSpecial(fullPath string) error {
+	return nil
+}
+
+func (entry *Entry) FmtSpecial() string {
+	return ""
+}
--- a/src/duplicacy_utils_xbsd.go
+++ b/src/duplicacy_utils_xbsd.go
@@ -0,0 +1,38 @@
+// 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
+// +build freebsd
+
+package duplicacy
+
+import (
+	"encoding/binary"
+	"os"
+	"syscall"
+)
+
+func excludedByAttribute(attributes map[string][]byte) bool {
+	_, excluded := attributes["duplicacy_exclude"]
+	if !excluded {
+		flags, ok := attributes[bsdFileFlagsKey]
+		excluded = ok && (binary.LittleEndian.Uint32(flags)&bsd_UF_NODUMP) != 0
+	}
+	return excluded
+}
+
+func (entry *Entry) RestoreSpecial(fullPath string) error {
+	mode := entry.Mode & uint32(fileModeMask)
+
+	if entry.Mode&uint32(os.ModeNamedPipe) != 0 {
+		mode |= syscall.S_IFIFO
+	} else if entry.Mode&uint32(os.ModeCharDevice) != 0 {
+		mode |= syscall.S_IFCHR
+	} else if entry.Mode&uint32(os.ModeDevice) != 0 {
+		mode |= syscall.S_IFBLK
+	} else {
+		return nil
+	}
+	return syscall.Mknod(fullPath, mode, entry.GetRdev())
+}
--- a/src/duplicacy_xattr.go
+++ b/src/duplicacy_xattr.go
@@ -0,0 +1,35 @@
+// 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 "os"
+
+func (entry *Entry) ReadAttributes(fi os.FileInfo, fullPath string, normalize bool) error {
+	return entry.readAttributes(fi, fullPath, normalize)
+}
+
+func (entry *Entry) GetFileFlags(fileInfo os.FileInfo) bool {
+	return entry.getFileFlags(fileInfo)
+}
+
+func (entry *Entry) ReadFileFlags(fileInfo os.FileInfo, fullPath string) error {
+	return entry.readFileFlags(fileInfo, fullPath)
+}
+
+func (entry *Entry) RestoreEarlyDirFlags(fullPath string, mask uint32) error {
+	return entry.restoreEarlyDirFlags(fullPath, mask)
+}
+
+func (entry *Entry) RestoreEarlyFileFlags(f *os.File, mask uint32) error {
+	return entry.restoreEarlyFileFlags(f, mask)
+}
+
+func (entry *Entry) RestoreLateFileFlags(fullPath string, fileInfo os.FileInfo, mask uint32) error {
+	return entry.restoreLateFileFlags(fullPath, fileInfo, mask)
+}
+
+func (entry *Entry) SetAttributesToFile(fullPath string, normalize bool) error {
+	return entry.setAttributesToFile(fullPath, normalize)
+}
--- a/src/duplicacy_xattr_darwin.go
+++ b/src/duplicacy_xattr_darwin.go
@@ -0,0 +1,149 @@
+// 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 (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"math"
+	"os"
+	"syscall"
+
+	"github.com/pkg/xattr"
+	"golang.org/x/sys/unix"
+)
+
+const (
+	darwinFileFlagsKey = "\x00bf"
+)
+
+var darwinIsSuperUser bool
+
+func init() {
+	darwinIsSuperUser = unix.Geteuid() == 0
+}
+
+func (entry *Entry) readAttributes(fi os.FileInfo, fullPath string, normalize bool) error {
+	if entry.IsSpecial() {
+		return nil
+	}
+
+	attributes, err := xattr.LList(fullPath)
+	if err != nil {
+		return err
+	}
+
+	if len(attributes) > 0 {
+		entry.Attributes = &map[string][]byte{}
+	}
+	var allErrors error
+	for _, name := range attributes {
+		value, err := xattr.LGet(fullPath, name)
+		if err != nil {
+			allErrors = errors.Join(allErrors, err)
+		} else {
+			(*entry.Attributes)[name] = value
+		}
+	}
+
+	return allErrors
+}
+
+func (entry *Entry) getFileFlags(fileInfo os.FileInfo) bool {
+	stat := fileInfo.Sys().(*syscall.Stat_t)
+	if stat.Flags != 0 {
+		if entry.Attributes == nil {
+			entry.Attributes = &map[string][]byte{}
+		}
+		v := make([]byte, 4)
+		binary.LittleEndian.PutUint32(v, stat.Flags)
+		(*entry.Attributes)[darwinFileFlagsKey] = v
+	}
+	return true
+}
+
+func (entry *Entry) readFileFlags(fileInfo os.FileInfo, fullPath string) error {
+	return nil
+}
+
+func (entry *Entry) setAttributesToFile(fullPath string, normalize bool) error {
+	if entry.Attributes == nil || len(*entry.Attributes) == 0 || entry.IsSpecial() {
+		return nil
+	}
+	attributes := *entry.Attributes
+
+	if _, haveFlags := attributes[darwinFileFlagsKey]; haveFlags && len(attributes) <= 1 {
+		return nil
+	}
+
+	names, err := xattr.LList(fullPath)
+	if err != nil {
+		return err
+	}
+	for _, name := range names {
+		newAttribute, found := attributes[name]
+		if found {
+			oldAttribute, _ := xattr.LGet(fullPath, name)
+			if !bytes.Equal(oldAttribute, newAttribute) {
+				err = errors.Join(err, xattr.LSet(fullPath, name, newAttribute))
+			}
+			delete(attributes, name)
+		} else {
+			err = errors.Join(err, xattr.LRemove(fullPath, name))
+		}
+	}
+
+	for name, attribute := range attributes {
+		if len(name) > 0 && name[0] == '\x00' {
+			continue
+		}
+		err = errors.Join(err, xattr.LSet(fullPath, name, attribute))
+	}
+	return err
+}
+
+func (entry *Entry) restoreEarlyDirFlags(fullPath string, mask uint32) error {
+	return nil
+}
+
+func (entry *Entry) restoreEarlyFileFlags(f *os.File, mask uint32) error {
+	return nil
+}
+
+func (entry *Entry) restoreLateFileFlags(fullPath string, fileInfo os.FileInfo, mask uint32) error {
+	if mask == math.MaxUint32 {
+		return nil
+	}
+
+	if darwinIsSuperUser {
+		mask |= ^uint32(unix.UF_SETTABLE | unix.SF_SETTABLE)
+	} else {
+		mask |= ^uint32(unix.UF_SETTABLE)
+	}
+
+	var flags uint32
+
+	if entry.Attributes != nil {
+		if v, have := (*entry.Attributes)[darwinFileFlagsKey]; have {
+			flags = binary.LittleEndian.Uint32(v)
+		}
+	}
+
+	stat := fileInfo.Sys().(*syscall.Stat_t)
+
+	flags = (flags & ^mask) | (stat.Flags & mask)
+
+	if flags != stat.Flags {
+		f, err := os.OpenFile(fullPath, os.O_RDONLY|unix.O_SYMLINK, 0)
+		if err != nil {
+			return err
+		}
+		err = unix.Fchflags(int(f.Fd()), int(flags))
+		f.Close()
+		return err
+	}
+	return nil
+}
--- a/src/duplicacy_xattr_linux.go
+++ b/src/duplicacy_xattr_linux.go
@@ -0,0 +1,234 @@
+// 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 (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"math"
+	"os"
+	"unsafe"
+
+	"github.com/pkg/xattr"
+	"golang.org/x/sys/unix"
+)
+
+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 */
+
+	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"
+)
+
+var (
+	errENOTTY error = unix.ENOTTY
+)
+
+func ignoringEINTR(fn func() error) (err error) {
+	for {
+		err = fn()
+		if err != unix.EINTR {
+			break
+		}
+	}
+	return err
+}
+
+func ioctl(f *os.File, request uintptr, attrp *uint32) error {
+	return ignoringEINTR(func() error {
+		argp := uintptr(unsafe.Pointer(attrp))
+
+		_, _, errno := unix.Syscall(unix.SYS_IOCTL, f.Fd(), request, argp)
+		if errno == 0 {
+			return nil
+		} else if errno == unix.ENOTTY {
+			return errENOTTY
+		}
+		return errno
+	})
+}
+
+func (entry *Entry) readAttributes(fi os.FileInfo, fullPath string, normalize bool) error {
+	attributes, err := xattr.LList(fullPath)
+	if err != nil {
+		return err
+	}
+
+	if len(attributes) > 0 {
+		entry.Attributes = &map[string][]byte{}
+	}
+	var allErrors error
+	for _, name := range attributes {
+		value, err := xattr.LGet(fullPath, name)
+		if err != nil {
+			allErrors = errors.Join(allErrors, err)
+		} else {
+			(*entry.Attributes)[name] = value
+		}
+	}
+
+	return allErrors
+}
+
+func (entry *Entry) getFileFlags(fileInfo os.FileInfo) bool {
+	return false
+}
+
+func (entry *Entry) readFileFlags(fileInfo os.FileInfo, fullPath string) error {
+	// the linux file flags interface is quite depressing. The half assed attempt at statx
+	// doesn't even cover the flags we're usually interested in for btrfs
+	if !(entry.IsFile() || entry.IsDir()) {
+		return nil
+	}
+
+	f, err := os.OpenFile(fullPath, os.O_RDONLY|unix.O_NONBLOCK|unix.O_NOFOLLOW|unix.O_NOATIME, 0)
+	if err != nil {
+		return err
+	}
+
+	var flags uint32
+
+	err = ioctl(f, unix.FS_IOC_GETFLAGS, &flags)
+	f.Close()
+	if err != nil {
+		// inappropriate ioctl for device means flags aren't a thing on that FS
+		if err == unix.ENOTTY {
+			return 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
+	}
+	return nil
+}
+
+func (entry *Entry) setAttributesToFile(fullPath string, normalize bool) error {
+	if entry.Attributes == nil || len(*entry.Attributes) == 0 {
+		return nil
+	}
+	attributes := *entry.Attributes
+
+	if _, haveFlags := attributes[linuxFileFlagsKey]; haveFlags && len(attributes) <= 1 {
+		return nil
+	}
+
+	names, err := xattr.LList(fullPath)
+	if err != nil {
+		return err
+	}
+	for _, name := range names {
+		newAttribute, found := (*entry.Attributes)[name]
+		if found {
+			oldAttribute, _ := xattr.LGet(fullPath, name)
+			if !bytes.Equal(oldAttribute, newAttribute) {
+				err = errors.Join(err, xattr.LSet(fullPath, name, newAttribute))
+			}
+			delete(*entry.Attributes, name)
+		} else {
+			err = errors.Join(err, xattr.LRemove(fullPath, name))
+		}
+	}
+
+	for name, attribute := range *entry.Attributes {
+		if len(name) > 0 && name[0] == '\x00' {
+			continue
+		}
+		err = errors.Join(err, xattr.LSet(fullPath, name, attribute))
+	}
+	return err
+}
+
+func (entry *Entry) restoreEarlyDirFlags(fullPath string, mask uint32) error {
+	if entry.Attributes == nil || mask == math.MaxUint32 {
+		return nil
+	}
+	var flags uint32
+
+	if v, have := (*entry.Attributes)[linuxFileFlagsKey]; have {
+		flags = binary.LittleEndian.Uint32(v) & linuxIocFlagsDirEarly & ^mask
+	}
+
+	if flags != 0 {
+		f, err := os.OpenFile(fullPath, os.O_RDONLY|unix.O_DIRECTORY, 0)
+		if err != nil {
+			return err
+		}
+		err = ioctl(f, unix.FS_IOC_SETFLAGS, &flags)
+		f.Close()
+		if err != nil {
+			return fmt.Errorf("Set flags 0x%.8x failed: %w", flags, err)
+		}
+	}
+	return nil
+}
+
+func (entry *Entry) restoreEarlyFileFlags(f *os.File, mask uint32) error {
+	if entry.Attributes == nil || mask == math.MaxUint32 {
+		return nil
+	}
+	var flags uint32
+
+	if v, have := (*entry.Attributes)[linuxFileFlagsKey]; have {
+		flags = binary.LittleEndian.Uint32(v) & linuxIocFlagsFileEarly & ^mask
+	}
+
+	if flags != 0 {
+		err := ioctl(f, unix.FS_IOC_SETFLAGS, &flags)
+		if err != nil {
+			return fmt.Errorf("Set flags 0x%.8x failed: %w", flags, err)
+		}
+	}
+	return nil
+}
+
+func (entry *Entry) restoreLateFileFlags(fullPath string, fileInfo os.FileInfo, mask uint32) error {
+	if entry.IsLink() || entry.Attributes == nil || mask == math.MaxUint32 {
+		return nil
+	}
+	var flags uint32
+
+	if v, have := (*entry.Attributes)[linuxFileFlagsKey]; have {
+		flags = binary.LittleEndian.Uint32(v) & (linuxIocFlagsFileEarly | linuxIocFlagsDirEarly | linuxIocFlagsLate) & ^mask
+	}
+
+	if flags != 0 {
+		f, err := os.OpenFile(fullPath, os.O_RDONLY|unix.O_NOFOLLOW, 0)
+		if err != nil {
+			return err
+		}
+		err = ioctl(f, unix.FS_IOC_SETFLAGS, &flags)
+		f.Close()
+		if err != nil {
+			return fmt.Errorf("Set flags 0x%.8x failed: %w", flags, err)
+		}
+	}
+	return nil
+}
--- a/src/duplicacy_xattr_windows.go
+++ b/src/duplicacy_xattr_windows.go
@@ -0,0 +1,35 @@
+// 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 "os"
+
+func (entry *Entry) readAttributes(fi os.FileInfo, fullPath string, normalize bool) error {
+	return nil
+}
+
+func (entry *Entry) getFileFlags(fileInfo os.FileInfo) bool {
+	return true
+}
+
+func (entry *Entry) readFileFlags(fileInfo os.FileInfo, fullPath string) error {
+	return nil
+}
+
+func (entry *Entry) setAttributesToFile(fullPath string, normalize bool) error {
+	return nil
+}
+
+func (entry *Entry) restoreEarlyDirFlags(fullPath string, mask uint32) error {
+	return nil
+}
+
+func (entry *Entry) restoreEarlyFileFlags(f *os.File, mask uint32) error {
+	return nil
+}
+
+func (entry *Entry) restoreLateFileFlags(fullPath string, fileInfo os.FileInfo, mask uint32) error {
+	return nil
+}
--- a/src/duplicacy_xattr_xbsd.go
+++ b/src/duplicacy_xattr_xbsd.go
@@ -0,0 +1,155 @@
+// 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
+// +build freebsd netbsd
+
+package duplicacy
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"math"
+	"os"
+	"syscall"
+	"unsafe"
+
+	"github.com/pkg/xattr"
+)
+
+const (
+	bsd_UF_NODUMP   = 0x1
+	bsd_SF_SETTABLE = 0xffff0000
+	bsd_UF_SETTABLE = 0x0000ffff
+
+	bsdFileFlagsKey = "\x00bf"
+)
+
+var bsdIsSuperUser bool
+
+func init() {
+	bsdIsSuperUser = syscall.Geteuid() == 0
+}
+
+func (entry *Entry) readAttributes(fi os.FileInfo, fullPath string, normalize bool) error {
+	if entry.IsSpecial() {
+		return nil
+	}
+
+	attributes, err := xattr.LList(fullPath)
+	if err != nil {
+		return err
+	}
+
+	if len(attributes) > 0 {
+		entry.Attributes = &map[string][]byte{}
+	}
+	var allErrors error
+	for _, name := range attributes {
+		value, err := xattr.LGet(fullPath, name)
+		if err != nil {
+			allErrors = errors.Join(allErrors, err)
+		} else {
+			(*entry.Attributes)[name] = value
+		}
+	}
+
+	return allErrors
+}
+
+func (entry *Entry) getFileFlags(fileInfo os.FileInfo) bool {
+	stat := fileInfo.Sys().(*syscall.Stat_t)
+	if 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
+	}
+	return true
+}
+
+func (entry *Entry) readFileFlags(fileInfo os.FileInfo, fullPath string) error {
+	return nil
+}
+
+func (entry *Entry) setAttributesToFile(fullPath string, normalize bool) error {
+	if entry.Attributes == nil || len(*entry.Attributes) == 0 || entry.IsSpecial() {
+		return nil
+	}
+	attributes := *entry.Attributes
+
+	if _, haveFlags := attributes[bsdFileFlagsKey]; haveFlags && len(attributes) <= 1 {
+		return nil
+	}
+
+	names, err := xattr.LList(fullPath)
+	if err != nil {
+		return err
+	}
+	for _, name := range names {
+		newAttribute, found := attributes[name]
+		if found {
+			oldAttribute, _ := xattr.LGet(fullPath, name)
+			if !bytes.Equal(oldAttribute, newAttribute) {
+				err = errors.Join(err, xattr.LSet(fullPath, name, newAttribute))
+			}
+			delete(attributes, name)
+		} else {
+			err = errors.Join(err, xattr.LRemove(fullPath, name))
+		}
+	}
+
+	for name, attribute := range attributes {
+		if len(name) > 0 && name[0] == '\x00' {
+			continue
+		}
+		err = errors.Join(err, xattr.LSet(fullPath, name, attribute))
+	}
+	return err
+}
+
+func (entry *Entry) restoreEarlyDirFlags(fullPath string, mask uint32) error {
+	return nil
+}
+
+func (entry *Entry) restoreEarlyFileFlags(f *os.File, mask uint32) error {
+	return nil
+}
+
+func (entry *Entry) restoreLateFileFlags(fullPath string, fileInfo os.FileInfo, mask uint32) error {
+	if mask == math.MaxUint32 {
+		return nil
+	}
+
+	if bsdIsSuperUser {
+		mask |= ^uint32(bsd_UF_SETTABLE | bsd_SF_SETTABLE)
+	} else {
+		mask |= ^uint32(bsd_UF_SETTABLE)
+	}
+
+	var flags uint32
+
+	if entry.Attributes != nil {
+		if v, have := (*entry.Attributes)[bsdFileFlagsKey]; have {
+			flags = binary.LittleEndian.Uint32(v)
+		}
+	}
+
+	stat := fileInfo.Sys().(*syscall.Stat_t)
+
+	flags = (flags & ^mask) | (stat.Flags & mask)
+
+	if flags != stat.Flags {
+		pPath, _ := syscall.BytePtrFromString(fullPath)
+		if _, _, errno := syscall.Syscall(syscall.SYS_LCHFLAGS,
+			uintptr(unsafe.Pointer(pPath)),
+			uintptr(flags), 0); errno != 0 {
+			return os.NewSyscallError("lchflags", errno)
+		}
+	}
+	return nil
+}
Author	SHA1	Message	Date
John K. Luebs	518d02a57d	Normalize and add options for backup, add more file flags options - Move more function arguments to structs with some convenience functions. - Add a flag to enable backup/restore of file flags. It works a little bit differently depending on system. Since we don't need to do anything to get file flags on darwin/BSD, it's in the stat buffer so just save it. For linux we have to open the file and do a - Add the normalize flag to ReadAttributes. Implementation TBD. - stub out common xattr file for doc comments	2023-10-07 13:55:51 -05:00
John K. Luebs	58d21eb17a	Refactor the BackupManager options interface some more - Move the pref based (repository associated) options back to init of the backup manager. This is still a bit of an unholy mess but the existing setup is a little insane. There are mostly runtime associated settings, like revision, tag, thread count, quick mode, show stats. Then there are the more fuzzy ones, like allow failures, patterns. However something like set-owner, mostly likely that's going to be static for a "repository", same with exclude by attribute. In any event things that make sense to be associated with the repository preferences will stay in a backup mananger initialization time options structure, and no more growing of the arguments list - go doesn't look good there. RestoreOptions for the more ephemeral run associated settings. The Backup routine with it's large argument list stays for now, but will get revamped if anything new gets added.	2023-10-07 13:55:51 -05:00
John K. Luebs	c151b21f5c	Remove deprecated rand functions in tests With requirement for golang 1.20 the deprecated rand functions can be dropped. Do not have to call seed.	2023-10-07 13:55:51 -05:00
John K. Luebs	6d5cb4b7b9	Add metadata and special files restore options Add options to control if xattrs and specials get restored. Add file flag mask preference. It's a rough interface, but this is a niche use case. Refactoring of options passing since golang ergonomics are poor for long parameter lists.	2023-10-07 13:55:51 -05:00
John K. Luebs	09637c69bc	ReadFileFlags on linux minor fix Add ignoring EINTR to syscall, set O_NOATIME on open, ignore ENOTTY error (unsupported ioctl) to avoid massive spam for non-exceptional failure on nonsupporting file systems	2023-10-07 13:55:51 -05:00
John K. Luebs	bede63f33f	Fix hardlink to symlink naming bug When creating cloned entries of hardlinked symlinks we have to preserve the target link data in the entry obviously.	2023-10-07 13:55:51 -05:00
John K. Luebs	95063913ae	Split out xattr and flags routines to new files	2023-10-07 13:55:51 -05:00
John K. Luebs	3481814562	Cleanup some of the unix code and don't pass ptr to iface to GetOwner Don't bother using checked type assertion for stat since we are guarded by specific build configuration, we should know the correct type, and if not, panicing is fine. Despite syscall being deprecated a decade ago, we still need it for FileInfo and sys/windows still calls it as well.	2023-10-07 13:55:51 -05:00
John K. Luebs	9ff5484ec0	Fix some deprecated functions in windows code	2023-10-07 13:55:51 -05:00
John K. Luebs	a33bf0a21b	Break up Restore options into struct	2023-10-07 13:55:51 -05:00
John K. Luebs	228ca7005c	Improve error handling and setting of xattr and file flags - Improve error handling of file flags and xattrs. You now get warnings - file flags on *BSD/Darwin use a mask and combine with the user/superuser mask to prevent spurious warnings. The mask is not yet implemented as a preference - error handling/report for reading special files - bump to go 1.20 for errors.Join	2023-10-07 13:55:51 -05:00
John K. Luebs	23a3cce0ad	RestoreMetadata improved error messages	2023-10-07 13:55:51 -05:00
John K. Luebs	8427c03b71	Remove unnecessary fileInfo indirection (it's already interface)	2023-10-07 13:55:51 -05:00
John K. Luebs	af89dd5e7b	Remove obsolete fileEncoder	2023-10-07 13:55:51 -05:00
John K. Luebs	a479fa5197	Set file attributes before setting mode and owner.	2023-10-07 13:55:51 -05:00
John K. Luebs	986e6a6ef2	update readme	2023-10-07 13:55:51 -05:00
John K. Luebs	756a003fb3	Factor out hard link code for cross platform build Move system specific code out of entry so the build continues to work on Windows. Hard links are not currently supported on Windows, the behavior is a no-op.	2023-10-07 13:55:51 -05:00
John K. Luebs	07c796a46b	Fix and reorganize for build for FreeBSD - the xattr handling of namespaces is different on BSD with the xattr package, the user namespace is implicit - Don't backup/exclude files with flag nodump on BSD/Darwin	2023-10-07 13:55:51 -05:00
John K. Luebs	f24e8d2cbb	Don't rewrite existing special file	2023-10-07 13:55:51 -05:00
John K. Luebs	cfff4ff425	update readme	2023-10-07 13:55:51 -05:00
John K. Luebs	6c1600e8c8	Rename hardlink to hard link (two words)	2023-10-07 13:55:51 -05:00
John K. Luebs	807268d337	minor: missing variable assignment in CheckSnapshot, struct-tag	2023-10-07 13:55:51 -05:00
John K. Luebs	ab8fc0faa6	fix broken tests	2023-10-07 13:55:51 -05:00
John K. Luebs	8cd457447b	Fix formatting of diagnostic some diagnostic messages	2023-10-07 13:55:51 -05:00
John K. Luebs	ee19d44403	Cleanup hardlinking code This moves special file link data to the chunk fields like symlink hardlinks.	2023-10-07 13:55:51 -05:00
John K. Luebs	b8c0b1f86e	tweak the symlink hardlink chunk ids	2023-10-07 13:55:51 -05:00
John K. Luebs	059e74da17	Support backup of sockets This only works on Linux. Darwin does not allow mknod of a socket. Have not tested BSD.	2023-10-07 13:55:51 -05:00
John K. Luebs	31c131b9e3	gofmt some files	2023-10-07 13:55:51 -05:00
John K. Luebs	e01008a56b	Fix handling of hardlinks and special files Also, don't attempt xattr ops on special files on the BSD likes. TODO: Should have a way to allow restore without special files, otherwise very cumbersome for a regular user.	2023-10-07 13:55:51 -05:00
John K. Luebs	4934df4e08	Support for hardlinks to symlinks This is a specialized use-case, but it is indeed possible to do this and can be used if xattrs are attached to the symlink.	2023-10-07 13:55:51 -05:00
John K. Luebs	52e628ac93	Fix handling of xattrs with symlinks Fix Linux, Darwin, and other BSD (untested) to allow proper handling of xattrs with symlinks. On Linux we cannot use the f* syscalls for symlinks because symlinks cannot be opened. File flags must be handled differently on darwin and other BSD due to the lack of the LCHFLAGS syscall on darwin, and the fact that it is emulated in libc. However, we do have O_SYMLINK on darwin.	2023-10-07 13:55:51 -05:00
John K. Luebs	88c92da9bd	Support backup and restore of special files on POSIX style systems Special files are device nodes and named pipes. The necessity of the former is clear, the latter is debatable. In order to preserve backward compatibility, the device number is encoded in the StartChunk/StartOffset fields of the entry.	2023-10-07 13:55:51 -05:00
John K. Luebs	fee1cb859e	Don't overwrite symlinks if file already exists	2023-10-07 13:55:51 -05:00
John K. Luebs	e61f5c2192	Support backup and restore of hardlinks This tracks inode/device from the stat info and creates backward compatible snapshots that allow preserving hardlinks. Backwards compatibility is preserved by saving a virtual inode number index in the Link field of the file entry. Since this field was previously only used for symlinks, this won't break old versions. Additionally, the entry data is cloned so restoration with an old version works. Current limitations are primarility with restore. They include: - no command line option to prevent hard link restore - if a file has the immutable or append only flag it will be set before hardlinks are restored, so hardlinking will fail. - if a partial restore includes a hardlink but not the parent directories the hardlink will fail. These will be solved by grouping restore of hardlinks together with file, prior to applying final metadata. - if a file is changed and is being rewritten by a restore hardlinks are not preserved.	2023-10-07 13:55:51 -05:00
John K. Luebs	d3b7cdc02d	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.	2023-10-07 13:55:51 -05:00
John K. Luebs	0bfab89057	Increase b2 client max file listing count to 10000 Considerable speed improvement with listing large storage.	2023-10-07 13:55:51 -05:00
John K. Luebs	3468117fe1	Fix exclude_by_attribute feature on POSIX The exclude by attribute function is broken on non-Darwin POSIX: linux and freebsd. This is because those xattrs must be prefixed by a legal namespace. The old xattr library implicitly appended the user namespace to the xattr, but the current official go pkg does not (which is just as well). Also fix the test to remove the discordant old xattr dependency and provide test cases for both darwin and non-darwin POSIX.	2023-10-07 13:55:51 -05:00
John K. Luebs	b443e05113	Use S3 ListObjectsV2 for listing files ListObjects has been deprecated since 2016 and ListObjectsV2 with use of explicit pagination tokens is more performant for large listings as well. This also mitigates an issue with iDrive E2 where the StartAfter/Marker is included in the output, leading to duplicate entries. Right now this causes an exhaustive prune to delete chunks erroneously flagged as duplicate, destroying the storage.	2023-10-07 13:55:51 -05:00
Gilbert Chen	2549532676	Bump version to 3.2.3	2023-10-06 22:13:33 -04:00
Gilbert Chen	e99dfea048	Upgrade storj.io/uplink to v1.12.1 to fix an 64 bit alignment issue	2023-10-06 22:12:12 -04:00
Gilbert Chen	50120146df	Bump version to 3.2.2	2023-10-03 22:35:18 -04:00
Gilbert Chen	7bfc0e7d51	Save passwords after a storj storage has been created	2023-10-03 22:33:41 -04:00