From 6c1d2afbe9cbcb227cf62b8176e9064cbb9449bb Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sat, 18 Jul 2026 20:38:27 +0200 Subject: [PATCH 01/12] Added submodule --- .gitmodules | 5 ++++- lib/FuseSharp | 1 + 2 files changed, 5 insertions(+), 1 deletion(-) create mode 160000 lib/FuseSharp diff --git a/.gitmodules b/.gitmodules index 6131918f6..0a1560294 100644 --- a/.gitmodules +++ b/.gitmodules @@ -3,4 +3,7 @@ url = https://github.com/securefolderfs-community/nwebdav.git [submodule "lib/Tmds.Fuse"] path = lib/Tmds.Fuse - url = https://github.com/securefolderfs-community/Tmds.Fuse \ No newline at end of file + url = https://github.com/securefolderfs-community/Tmds.Fuse +[submodule "lib/FuseSharp"] + path = lib/FuseSharp + url = git@github.com:securefolderfs-community/FuseSharp.git diff --git a/lib/FuseSharp b/lib/FuseSharp new file mode 160000 index 000000000..b6492effa --- /dev/null +++ b/lib/FuseSharp @@ -0,0 +1 @@ +Subproject commit b6492effa1a8f58115e81e22692d577248dfd6dc From 60540074b24b370aa1fe5b8c67b1ac361810689b Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sat, 18 Jul 2026 20:43:07 +0200 Subject: [PATCH 02/12] Added SecureFolderFS.Core.MacFuse --- SecureFolderFS.Public.slnx | 2 ++ .../SecureFolderFS.Core.FUSE.csproj | 9 +-------- src/Core/SecureFolderFS.Core.MacFuse/Class1.cs | 5 +++++ .../SecureFolderFS.Core.MacFuse.csproj | 15 +++++++++++++++ 4 files changed, 23 insertions(+), 8 deletions(-) create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/Class1.cs create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/SecureFolderFS.Core.MacFuse.csproj diff --git a/SecureFolderFS.Public.slnx b/SecureFolderFS.Public.slnx index c7b978124..2d771d68c 100644 --- a/SecureFolderFS.Public.slnx +++ b/SecureFolderFS.Public.slnx @@ -3,6 +3,7 @@ + @@ -19,6 +20,7 @@ + diff --git a/src/Core/SecureFolderFS.Core.FUSE/SecureFolderFS.Core.FUSE.csproj b/src/Core/SecureFolderFS.Core.FUSE/SecureFolderFS.Core.FUSE.csproj index 62fffd219..f4feb3bfa 100644 --- a/src/Core/SecureFolderFS.Core.FUSE/SecureFolderFS.Core.FUSE.csproj +++ b/src/Core/SecureFolderFS.Core.FUSE/SecureFolderFS.Core.FUSE.csproj @@ -4,14 +4,7 @@ net10.0 enable enable - - - - true - - - - true + true diff --git a/src/Core/SecureFolderFS.Core.MacFuse/Class1.cs b/src/Core/SecureFolderFS.Core.MacFuse/Class1.cs new file mode 100644 index 000000000..0e6269c68 --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/Class1.cs @@ -0,0 +1,5 @@ +namespace SecureFolderFS.Core.MacFuse; + +public class Class1 +{ +} \ No newline at end of file diff --git a/src/Core/SecureFolderFS.Core.MacFuse/SecureFolderFS.Core.MacFuse.csproj b/src/Core/SecureFolderFS.Core.MacFuse/SecureFolderFS.Core.MacFuse.csproj new file mode 100644 index 000000000..beffab7f5 --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/SecureFolderFS.Core.MacFuse.csproj @@ -0,0 +1,15 @@ + + + + net10.0 + enable + + + + + + + + + + From 0ea3374a7649c2e56571789596e73fdd0b20bc4b Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sat, 18 Jul 2026 23:50:42 +0200 Subject: [PATCH 03/12] Added base implementation classes for MacFuse --- .../AppModels/MacFuseOptions.cs | 73 +++++++++++++ .../MacFuseVfsRoot.cs | 36 +++++++ .../MacFuseWrapper.cs | 57 ++++++++++ .../OpenHandles/MacFuseFileHandle.cs | 22 ++++ .../OpenHandles/MacFuseHandlesManager.cs | 101 ++++++++++++++++++ .../SecureFolderFS.Core.MacFuse.csproj | 10 +- 6 files changed, 298 insertions(+), 1 deletion(-) create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/AppModels/MacFuseOptions.cs create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/MacFuseVfsRoot.cs create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/MacFuseWrapper.cs create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/OpenHandles/MacFuseFileHandle.cs create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/OpenHandles/MacFuseHandlesManager.cs diff --git a/src/Core/SecureFolderFS.Core.MacFuse/AppModels/MacFuseOptions.cs b/src/Core/SecureFolderFS.Core.MacFuse/AppModels/MacFuseOptions.cs new file mode 100644 index 000000000..f645865ac --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/AppModels/MacFuseOptions.cs @@ -0,0 +1,73 @@ +using SecureFolderFS.Core.FileSystem.AppModels; +using SecureFolderFS.Shared.Extensions; +using SecureFolderFS.Storage.VirtualFileSystem; + +namespace SecureFolderFS.Core.MacFuse.AppModels +{ + /// + public sealed class MacFuseOptions : VirtualFileSystemOptions + { + /// + /// Gets the path where the file system should be mounted. If a null value is given, default mount point will be used. + /// + public string? MountPoint { get; init; } + + /// + /// Gets whether the root user should have access to the filesystem. + /// + /// + /// + /// Requires the allow_other macFUSE tunable to be enabled (sysctl vfs.generic.macfuse.tunables.allow_other=1). + /// + /// + /// This option is mutually exclusive with . + /// + /// + public bool AllowRootUserAccess { get; init; } + + /// + /// Gets whether other users, including root, should have access to the filesystem. + /// + /// + /// + /// Requires the allow_other macFUSE tunable to be enabled (sysctl vfs.generic.macfuse.tunables.allow_other=1). + /// + /// + /// This option is mutually exclusive with . + /// + /// + public bool AllowOtherUserAccess { get; init; } + + /// + /// Gets whether to print debugging information to the console. + /// + public bool PrintDebugInformation { get; init; } + + /// + public override string? GetDescription() + { + return MountPoint; + } + + public static MacFuseOptions ToOptions(IDictionary options) + { + return new() + { + VolumeName = (string?)options.Get(nameof(VolumeName)) ?? throw new ArgumentNullException(nameof(VolumeName)), + HealthStatistics = (IHealthStatistics?)options.Get(nameof(HealthStatistics)) ?? new HealthStatistics(), + FileSystemStatistics = (IFileSystemStatistics?)options.Get(nameof(FileSystemStatistics)) ?? new FileSystemStatistics(), + IsReadOnly = (bool?)options.Get(nameof(IsReadOnly)) ?? false, + IsCachingChunks = (bool?)options.Get(nameof(IsCachingChunks)) ?? true, + IsCachingFileNames = (bool?)options.Get(nameof(IsCachingFileNames)) ?? false, + IsCachingDirectoryIds = (bool?)options.Get(nameof(IsCachingDirectoryIds)) ?? true, + RecycleBinSize = (long?)options.Get(nameof(RecycleBinSize)) ?? 0L, + + // macFUSE specific + MountPoint = (string?)options.Get(nameof(MountPoint)), + AllowRootUserAccess = (bool?)options.Get(nameof(AllowRootUserAccess)) ?? false, + AllowOtherUserAccess = (bool?)options.Get(nameof(AllowOtherUserAccess)) ?? false, + PrintDebugInformation = (bool?)options.Get(nameof(PrintDebugInformation)) ?? false + }; + } + } +} diff --git a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseVfsRoot.cs b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseVfsRoot.cs new file mode 100644 index 000000000..a80785a12 --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseVfsRoot.cs @@ -0,0 +1,36 @@ +using OwlCore.Storage; +using SecureFolderFS.Core.FileSystem; +using SecureFolderFS.Storage.VirtualFileSystem; + +namespace SecureFolderFS.Core.MacFuse +{ + /// + internal sealed class MacFuseVfsRoot : VfsRoot + { + private readonly MacFuseWrapper _fuseWrapper; + private bool _disposed; + + /// + public override string FileSystemName { get; } = Constants.FileSystem.FS_NAME; + + public MacFuseVfsRoot(MacFuseWrapper fuseWrapper, IFolder virtualizedRoot, IFolder plaintextRoot, FileSystemSpecifics specifics) + : base(virtualizedRoot, plaintextRoot, specifics) + { + _fuseWrapper = fuseWrapper; + } + + /// + public override async ValueTask DisposeAsync() + { + if (_disposed) + return; + + _disposed = await _fuseWrapper.CloseFileSystemAsync(); + if (_disposed) + { + FileSystemManager.Instance.FileSystems.Remove(this); + await base.DisposeAsync(); + } + } + } +} diff --git a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseWrapper.cs b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseWrapper.cs new file mode 100644 index 000000000..17cb4b46e --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseWrapper.cs @@ -0,0 +1,57 @@ +using FuseSharp; +using SecureFolderFS.Core.MacFuse.AppModels; +using SecureFolderFS.Core.MacFuse.Callbacks; + +namespace SecureFolderFS.Core.MacFuse +{ + internal sealed class MacFuseWrapper + { + private readonly BaseMacFuseCallbacks _fuseCallbacks; + private IFuseMount? _fuseMount; + + public MacFuseWrapper(BaseMacFuseCallbacks fuseCallbacks) + { + _fuseCallbacks = fuseCallbacks; + } + + public void StartFileSystem(string mountPoint, MacFuseOptions mountOptions) + { + var rawOptions = $"default_permissions,fsname={nameof(SecureFolderFS)},volname={SanitizeOptionValue(mountOptions.VolumeName)}"; + + // Extended attributes are forwarded to the ciphertext folder, + // so AppleDouble (._) companion files are not needed + rawOptions += ",noappledouble"; + + if (mountOptions.AllowOtherUserAccess) + rawOptions += ",allow_other"; + else if (mountOptions.AllowRootUserAccess) + rawOptions += ",allow_root"; + + if (mountOptions.IsReadOnly) + rawOptions += ",ro"; + + if (mountOptions.PrintDebugInformation) + rawOptions += ",debug"; + + _fuseCallbacks.FuseOptions = mountOptions; + _fuseMount = Fuse.Mount(mountPoint, _fuseCallbacks, new MountOptions() + { + Options = rawOptions + }); + } + + public Task CloseFileSystemAsync() + { + if (_fuseMount is null) + throw new InvalidOperationException("The filesystem has not been started."); + + return _fuseMount.UnmountAsync(force: true); + } + + private static string SanitizeOptionValue(string value) + { + // Commas separate mount options and cannot appear inside a value + return value.Replace(',', '_'); + } + } +} diff --git a/src/Core/SecureFolderFS.Core.MacFuse/OpenHandles/MacFuseFileHandle.cs b/src/Core/SecureFolderFS.Core.MacFuse/OpenHandles/MacFuseFileHandle.cs new file mode 100644 index 000000000..c26d6fae9 --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/OpenHandles/MacFuseFileHandle.cs @@ -0,0 +1,22 @@ +using SecureFolderFS.Core.FileSystem.OpenHandles; + +namespace SecureFolderFS.Core.MacFuse.OpenHandles +{ + /// + internal sealed class MacFuseFileHandle : FileHandle + { + public FileAccess FileAccess { get; } + + public FileMode FileMode { get; } + + public string Directory { get; } + + public MacFuseFileHandle(Stream stream, FileAccess fileAccess, FileMode fileMode, string directory) + : base(stream) + { + FileAccess = fileAccess; + FileMode = fileMode; + Directory = directory; + } + } +} diff --git a/src/Core/SecureFolderFS.Core.MacFuse/OpenHandles/MacFuseHandlesManager.cs b/src/Core/SecureFolderFS.Core.MacFuse/OpenHandles/MacFuseHandlesManager.cs new file mode 100644 index 000000000..63750fd2b --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/OpenHandles/MacFuseHandlesManager.cs @@ -0,0 +1,101 @@ +using SecureFolderFS.Core.FileSystem.Extensions; +using SecureFolderFS.Core.FileSystem.OpenHandles; +using SecureFolderFS.Core.FileSystem.Streams; +using SecureFolderFS.Storage.VirtualFileSystem; + +namespace SecureFolderFS.Core.MacFuse.OpenHandles +{ + /// + internal sealed class MacFuseHandlesManager : BaseHandlesManager + { + public MacFuseHandlesManager(StreamsAccess streamsAccess, VirtualFileSystemOptions fileSystemOptions) + : base(streamsAccess, fileSystemOptions) + { + } + + /// + /// Provides an enumerable collection of all currently active handles managed by the instance. + /// + /// + /// The handles are returned as a snapshot of the internal collection to prevent race conditions + /// when accessing or enumerating the data. Any modifications to the collection are thread-safe + /// and do not affect the snapshot returned by this property. + /// + public IEnumerable OpenHandles + { + get + { + // Return a snapshot - the live collection could be mutated + // by another thread while the caller is enumerating it + lock (handles) + return handles.Values.ToArray(); + } + } + + /// + public override ulong OpenFileHandle(string ciphertextPath, FileMode mode, FileAccess access, FileShare share, FileOptions options) + { + // Make sure the handles manager was not disposed + if (disposed) + return FileSystem.Constants.INVALID_HANDLE; + + if (fileSystemOptions.IsReadOnly && mode.IsWriteFlag()) + return FileSystem.Constants.INVALID_HANDLE; + + // Open ciphertext stream + var ciphertextStream = new FileStream(ciphertextPath, new FileStreamOptions() + { + // A file cannot be opened with both FileMode.Append and FileMode.Read, but opening it with + // FileMode.Write would cause an error when writing, as the stream needs to be readable. + Mode = mode == FileMode.Append ? FileMode.Open : mode, + + // Writes require read access as well (chunks are read-modify-write), but read-only + // opens must not request write access. Otherwise, files with read-only permissions + // (or vaults on read-only media) could not be opened at all + Access = access == FileAccess.Read ? FileAccess.Read : FileAccess.ReadWrite, + Share = share | FileShare.Delete, + Options = options + }); + + // Open plaintext stream on top of ciphertext stream + var plaintextStream = streamsAccess.TryOpenPlaintextStream(ciphertextPath, ciphertextStream); + if (plaintextStream is null) + return FileSystem.Constants.INVALID_HANDLE; + + // Flush ChunkAccess if the opened to Truncate + if (mode == FileMode.Truncate) + plaintextStream.Flush(); + + // Create handle + var fileHandle = new MacFuseFileHandle(plaintextStream, access, mode, Path.GetDirectoryName(ciphertextPath)!); + var handle = handlesGenerator.ThreadSafeIncrement(); + + lock (handles) + handles.TryAdd(handle, fileHandle); + + return handle; + } + + /// + public override ulong OpenDirectoryHandle(string ciphertextPath) + { + // Not supported, return invalid handle + return FileSystem.Constants.INVALID_HANDLE; + } + + /// + public override THandle? GetHandle(ulong handleId) + where THandle : class + { + lock (handles) + return base.GetHandle(handleId); + } + + /// + public override void CloseHandle(ulong handle) + { + lock (handles) + base.CloseHandle(handle); + } + } +} diff --git a/src/Core/SecureFolderFS.Core.MacFuse/SecureFolderFS.Core.MacFuse.csproj b/src/Core/SecureFolderFS.Core.MacFuse/SecureFolderFS.Core.MacFuse.csproj index beffab7f5..5060ca03b 100644 --- a/src/Core/SecureFolderFS.Core.MacFuse/SecureFolderFS.Core.MacFuse.csproj +++ b/src/Core/SecureFolderFS.Core.MacFuse/SecureFolderFS.Core.MacFuse.csproj @@ -1,10 +1,18 @@ - + net10.0 + enable enable + true + + + <_Parameter1>macos + + + From 4f501cac991f9dcf94738ae217449135a5d9bb38 Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sat, 18 Jul 2026 23:51:03 +0200 Subject: [PATCH 04/12] Create MacFuseFileSystem.Helpers.cs --- .../MacFuseFileSystem.Helpers.cs | 93 +++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Helpers.cs diff --git a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Helpers.cs b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Helpers.cs new file mode 100644 index 000000000..e276f6187 --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Helpers.cs @@ -0,0 +1,93 @@ +using System.Text; +using FuseSharp; +using FuseSharp.Native; +using SecureFolderFS.Storage.VirtualFileSystem; + +namespace SecureFolderFS.Core.MacFuse +{ + /// + public sealed partial class MacFuseFileSystem + { + private static string MountDirectory { get; } = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), nameof(SecureFolderFS), "mount"); + + /// Whether a filesystem is mounted in the specified directory. + private static unsafe bool IsMountPoint(string directory) + { + var parent = Directory.GetParent(directory)?.FullName; + if (parent is null) + return false; + + StatVfs directoryStat = default; + fixed (byte* pathPtr = Encoding.UTF8.GetBytes(directory)) + { + if (LibC.statvfs(pathPtr, &directoryStat) == -1) + { + // A dead FUSE mount point cannot be stat-ed but is still a mount point + return LibC.errno is LibC.ENXIO or LibC.EIO; + } + } + + StatVfs parentStat = default; + fixed (byte* parentPathPtr = Encoding.UTF8.GetBytes(parent)) + { + if (LibC.statvfs(parentPathPtr, &parentStat) == -1) + return false; + } + + return directoryStat.f_fsid != parentStat.f_fsid; + } + + private static string GetFreeMountPoint(string vaultName) + { + var mountPoint = Path.Combine(MountDirectory, vaultName); + + var i = 1; + while (IsMountPoint(mountPoint)) + { + mountPoint = Path.Combine(MountDirectory, $"{vaultName} ({i++})"); + } + + return mountPoint; + } + + /// + /// Removes mount points without a connected transport endpoint in the default mount directory. + /// + private static void Cleanup() + { + foreach (var directory in Directory.GetDirectories(MountDirectory)) + { + Cleanup(directory); + } + } + + /// + /// Unmounts and deletes the specified directory if it is a mount point without a connected transport endpoint. + /// Otherwise, nothing happens. + /// + private static void Cleanup(string directory) + { + try + { + Directory.EnumerateFileSystemEntries(directory); + } + catch (IOException) + { + Fuse.LazyUnmount(directory); + Directory.Delete(directory); + } + } + + /// Whether the allow_other macFUSE tunable is enabled. + private static unsafe bool CanAllowOtherUsers() + { + var value = 0; + var length = (nuint)sizeof(int); + + if (LibC.sysctlbyname("vfs.generic.macfuse.tunables.allow_other", &value, &length, null, 0) == -1) + return false; + + return value != 0; + } + } +} From a2a55dae3306108416e9e840eecca92e88d29921 Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sun, 19 Jul 2026 00:45:00 +0200 Subject: [PATCH 05/12] Fixed UnoFileExplorerService on macOS --- src/Core/SecureFolderFS.Core.MacFuse/Class1.cs | 5 ----- .../SecureFolderFS.Core.MacFuse/MacFuseVfsRoot.cs | 13 +++++++++++++ .../SecureFolderFS.Uno/SecureFolderFS.Uno.csproj | 1 + .../ServiceImplementation/UnoFileExplorerService.cs | 5 ++++- 4 files changed, 18 insertions(+), 6 deletions(-) delete mode 100644 src/Core/SecureFolderFS.Core.MacFuse/Class1.cs diff --git a/src/Core/SecureFolderFS.Core.MacFuse/Class1.cs b/src/Core/SecureFolderFS.Core.MacFuse/Class1.cs deleted file mode 100644 index 0e6269c68..000000000 --- a/src/Core/SecureFolderFS.Core.MacFuse/Class1.cs +++ /dev/null @@ -1,5 +0,0 @@ -namespace SecureFolderFS.Core.MacFuse; - -public class Class1 -{ -} \ No newline at end of file diff --git a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseVfsRoot.cs b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseVfsRoot.cs index a80785a12..79d05dafd 100644 --- a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseVfsRoot.cs +++ b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseVfsRoot.cs @@ -30,6 +30,19 @@ public override async ValueTask DisposeAsync() { FileSystemManager.Instance.FileSystems.Remove(this); await base.DisposeAsync(); + + try + { + // Remove the now-empty mount point directory. Delete is non-recursive, + // so a directory which is unexpectedly not empty is left untouched + Directory.Delete(VirtualizedRoot.Id, recursive: false); + } + catch (IOException) + { + } + catch (UnauthorizedAccessException) + { + } } } } diff --git a/src/Platforms/SecureFolderFS.Uno/SecureFolderFS.Uno.csproj b/src/Platforms/SecureFolderFS.Uno/SecureFolderFS.Uno.csproj index a77f984d0..e2cf67010 100644 --- a/src/Platforms/SecureFolderFS.Uno/SecureFolderFS.Uno.csproj +++ b/src/Platforms/SecureFolderFS.Uno/SecureFolderFS.Uno.csproj @@ -86,6 +86,7 @@ + diff --git a/src/Platforms/SecureFolderFS.Uno/ServiceImplementation/UnoFileExplorerService.cs b/src/Platforms/SecureFolderFS.Uno/ServiceImplementation/UnoFileExplorerService.cs index a5f8d99e0..884c98d84 100644 --- a/src/Platforms/SecureFolderFS.Uno/ServiceImplementation/UnoFileExplorerService.cs +++ b/src/Platforms/SecureFolderFS.Uno/ServiceImplementation/UnoFileExplorerService.cs @@ -85,7 +85,10 @@ public async Task TryOpenInFileExplorerAsync(IFolder folder, CancellationT } #if __MACOS__ || __MACCATALYST__ || __UNO_SKIA_MACOS__ - Process.Start("sh", ["-c", $"open {folder.Id}"]); + // Pass the path as a discrete argument instead of interpolating it into a shell + // command. The FUSE mount point lives under "Application Support", whose space + // would otherwise be split by the shell and cause 'open' to fail + Process.Start("/usr/bin/open", [folder.Id]); return true; #elif WINDOWS await global::Windows.System.Launcher.LaunchFolderPathAsync(folder.Id).AsTask(cancellationToken); From 8653ce896be19fbea160d94cc689a378cea02b1b Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sun, 19 Jul 2026 01:13:00 +0200 Subject: [PATCH 06/12] Implemented macFuse file system handlers --- SecureFolderFS.slnx | 10 + lib/FuseSharp | 2 +- .../Callbacks/BaseMacFuseCallbacks.cs | 26 + .../Callbacks/OnDeviceMacFuse.cs | 707 ++++++++++++++++++ .../SecureFolderFS.Core.MacFuse/Constants.cs | 11 + .../MacFuseFileSystem.Availability.cs | 24 + .../MacFuseFileSystem.cs | 77 ++ .../CliVaultFileSystemService.cs | 5 +- .../SecureFolderFS.Cli.csproj | 1 + .../SkiaVaultFileSystemService.cs | 8 +- 10 files changed, 867 insertions(+), 4 deletions(-) create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/Callbacks/BaseMacFuseCallbacks.cs create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/Constants.cs create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Availability.cs create mode 100644 src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.cs diff --git a/SecureFolderFS.slnx b/SecureFolderFS.slnx index f7d1d4207..ddfb900cc 100644 --- a/SecureFolderFS.slnx +++ b/SecureFolderFS.slnx @@ -21,6 +21,11 @@ + + + + + @@ -57,6 +62,11 @@ + + + + + diff --git a/lib/FuseSharp b/lib/FuseSharp index b6492effa..fc1f76aa7 160000 --- a/lib/FuseSharp +++ b/lib/FuseSharp @@ -1 +1 @@ -Subproject commit b6492effa1a8f58115e81e22692d577248dfd6dc +Subproject commit fc1f76aa780d0fa90f2517a5eea9ff901feb2635 diff --git a/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/BaseMacFuseCallbacks.cs b/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/BaseMacFuseCallbacks.cs new file mode 100644 index 000000000..470b3eab6 --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/BaseMacFuseCallbacks.cs @@ -0,0 +1,26 @@ +using FuseSharp; +using SecureFolderFS.Core.FileSystem; +using SecureFolderFS.Core.MacFuse.AppModels; +using SecureFolderFS.Core.MacFuse.OpenHandles; + +namespace SecureFolderFS.Core.MacFuse.Callbacks +{ + internal abstract class BaseMacFuseCallbacks : FuseFileSystemBase + { + protected FileSystemSpecifics specifics; + protected readonly MacFuseHandlesManager handlesManager; + + protected BaseMacFuseCallbacks(FileSystemSpecifics specifics, MacFuseHandlesManager handlesManager) + { + this.specifics = specifics; + this.handlesManager = handlesManager; + } + + /// + /// Null before the filesystem has been mounted. + /// + public MacFuseOptions? FuseOptions { get; set; } + + protected abstract string? GetCiphertextPath(ReadOnlySpan plaintextName); + } +} diff --git a/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs b/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs new file mode 100644 index 000000000..327035bee --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs @@ -0,0 +1,707 @@ +using System.Text; +using FuseSharp; +using FuseSharp.Native; +using SecureFolderFS.Core.FileSystem; +using SecureFolderFS.Core.FileSystem.Helpers.Paths; +using SecureFolderFS.Core.FileSystem.Helpers.Paths.Abstract; +using SecureFolderFS.Core.FileSystem.Helpers.Paths.Native; +using SecureFolderFS.Core.MacFuse.OpenHandles; +using static FuseSharp.Native.LibC; + +namespace SecureFolderFS.Core.MacFuse.Callbacks +{ + internal sealed class OnDeviceMacFuse : BaseMacFuseCallbacks + { + public override bool SupportsMultiThreading => true; + + public OnDeviceMacFuse(FileSystemSpecifics specifics, MacFuseHandlesManager handlesManager) + : base(specifics, handlesManager) + { + } + + // Access doesn't need to be implemented due to the default_permissions mount option + + public override int ChMod(ReadOnlySpan path, uint mode, FuseFileInfoRef fiRef) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + try + { + File.SetUnixFileMode(ciphertextPath, (UnixFileMode)(mode & 0xFFFu)); + return 0; + } + catch (Exception ex) + { + return -MapExceptionToErrno(ex); + } + } + + public override unsafe int Chown(ReadOnlySpan path, uint uid, uint gid, FuseFileInfoRef fiRef) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + fixed (byte* ciphertextPathPtr = Encoding.UTF8.GetBytes(ciphertextPath)) + { + if (chown(ciphertextPathPtr, uid, gid) == -1) + return -errno; + } + + return 0; + } + + public override int Create(ReadOnlySpan path, uint mode, ref FuseFileInfo fi) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + var fileExists = File.Exists(ciphertextPath); + if ((fi.flags & O_CREAT) != 0 && (fi.flags & O_EXCL) != 0 && fileExists) + return -EEXIST; + + try + { + if (!fileExists) + { + using (File.Create(ciphertextPath)) + { + } + + File.SetUnixFileMode(ciphertextPath, (UnixFileMode)(mode & 0xFFFu)); + } + } + catch (Exception ex) + { + return -MapExceptionToErrno(ex); + } + + return Open(path, ref fi); + } + + public override int FAllocate(ReadOnlySpan path, int mode, ulong offset, long length, ref FuseFileInfo fi) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + var handle = handlesManager.GetHandle(fi.fh); + if (handle is null || !handle.FileAccess.HasFlag(FileAccess.Write)) + return -EBADF; + + // Only the default mode (extend allocation and size) is supported + if (mode != 0) + return -ENOTSUP; + + var newLength = (long)offset + length; + lock (handle.Stream) + { + if (newLength > handle.Stream.Length) + handle.Stream.SetLength(newLength); + } + + return 0; + } + + public override int Flush(ReadOnlySpan path, ref FuseFileInfo fi) + { + var handle = handlesManager.GetHandle(fi.fh); + if (handle is null) + return -EBADF; + + // Flush is invoked for every close(2), including read-only descriptors + if (!handle.FileAccess.HasFlag(FileAccess.Write)) + return 0; + + lock (handle.Stream) + handle.Stream.Flush(); + + return 0; + } + + public override int FSync(ReadOnlySpan path, bool onlyData, ref FuseFileInfo fi) + { + var handle = handlesManager.GetHandle(fi.fh); + if (handle is null) + return -EBADF; + + // fsync(2) is valid on read-only descriptors - there is nothing to flush + if (!handle.FileAccess.HasFlag(FileAccess.Write)) + return 0; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + lock (handle.Stream) + handle.Stream.Flush(); + + if (onlyData) + return 0; + + return FlushCiphertextToDisk(ciphertextPath); + } + + public override int FSyncDir(ReadOnlySpan path, bool onlyData, ref FuseFileInfo fi) + { + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + // Flush writable handles of files located inside the directory being synced + foreach (var handle in handlesManager.OpenHandles) + { + if (handle is MacFuseFileHandle { Stream.CanWrite: true } macFuseFileHandle && macFuseFileHandle.Directory.StartsWith(ciphertextPath, StringComparison.Ordinal)) + { + lock (macFuseFileHandle.Stream) + macFuseFileHandle.Stream.Flush(); + } + } + + return 0; + } + + public override int GetAttr(ReadOnlySpan path, ref Stat stat, FuseFileInfoRef fiRef) + { + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + var isDirectory = Directory.Exists(ciphertextPath); + var isFile = !isDirectory && File.Exists(ciphertextPath); + if (!path.SequenceEqual(RootPath) && !isDirectory && !isFile) + return -ENOENT; + + try + { + FileSystemInfo info = isFile ? new FileInfo(ciphertextPath) : new DirectoryInfo(ciphertextPath); + + stat.st_mode = (ushort)((isFile ? S_IFREG : S_IFDIR) | (ushort)File.GetUnixFileMode(ciphertextPath)); + stat.st_nlink = (ushort)(isFile ? 1 : 2); + stat.st_uid = getuid(); + stat.st_gid = getgid(); + stat.st_atimespec = TimeSpec.FromDateTime(info.LastAccessTimeUtc); + stat.st_mtimespec = TimeSpec.FromDateTime(info.LastWriteTimeUtc); + stat.st_ctimespec = TimeSpec.FromDateTime(info.LastWriteTimeUtc); + stat.st_birthtimespec = TimeSpec.FromDateTime(info.CreationTimeUtc); + + // Prefer the open handle's stream length. It may include data that + // has not been flushed to the ciphertext file yet + if (!fiRef.IsNull && handlesManager.GetHandle(fiRef.Value.fh) is { } handle) + { + lock (handle.Stream) + stat.st_size = handle.Stream.Length; + } + else if (isFile) + { + var ciphertextSize = ((FileInfo)info).Length; + stat.st_size = Math.Max(0, specifics.Security.ContentCrypt.CalculatePlaintextSize(ciphertextSize - specifics.Security.HeaderCrypt.HeaderCiphertextSize)); + } + + stat.st_blksize = 4096; + stat.st_blocks = (stat.st_size + 511) / 512; + + return 0; + } + catch (Exception ex) + { + return -MapExceptionToErrno(ex); + } + } + + public override unsafe int GetXAttr(ReadOnlySpan path, ReadOnlySpan name, Span value, uint position) + { + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + fixed (byte* namePtr = NullTerminate(name)) + fixed (byte* ciphertextPathPtr = Encoding.UTF8.GetBytes(ciphertextPath)) + { + nint result; + if (value.Length == 0) + result = getxattr(ciphertextPathPtr, namePtr, null, 0, position, 0); + else + { + fixed (void* valuePtr = value) + result = getxattr(ciphertextPathPtr, namePtr, valuePtr, (nuint)value.Length, position, 0); + } + + if (result == -1) + return -errno; + + return (int)result; + } + } + + public override unsafe int ListXAttr(ReadOnlySpan path, Span list) + { + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + fixed (byte* ciphertextPathPtr = Encoding.UTF8.GetBytes(ciphertextPath)) + { + nint result; + if (list.Length == 0) + result = listxattr(ciphertextPathPtr, null, 0, 0); + else + { + fixed (byte* listPtr = list) + result = listxattr(ciphertextPathPtr, listPtr, (nuint)list.Length, 0); + } + + if (result == -1) + return -errno; + + return (int)result; + } + } + + public override int MkDir(ReadOnlySpan path, uint mode) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + if (Directory.Exists(ciphertextPath) || File.Exists(ciphertextPath)) + return -EEXIST; + + try + { + Directory.CreateDirectory(ciphertextPath, (UnixFileMode)(mode & 0xFFFu)); + } + catch (Exception ex) + { + return -MapExceptionToErrno(ex); + } + + // Create new DirectoryID + var directoryId = Guid.NewGuid().ToByteArray(); + var directoryIdPath = Path.Combine(ciphertextPath, FileSystem.Constants.Names.DIRECTORY_ID_FILENAME); + + // Initialize directory with DirectoryID + using var directoryIdStream = File.Create(directoryIdPath); + directoryIdStream.Write(directoryId); + + // Set DirectoryID to known IDs + specifics.DirectoryIdCache.CacheSet(directoryIdPath, new(directoryId)); + + return 0; + } + + public override int Open(ReadOnlySpan path, ref FuseFileInfo fi) + { + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + var mode = FileMode.Open; + if ((fi.flags & O_APPEND) != 0) + mode = FileMode.Append; + else if ((fi.flags & O_TRUNC) != 0) + mode = (fi.flags & O_CREAT) != 0 ? FileMode.Create : FileMode.Truncate; + else if ((fi.flags & O_CREAT) != 0) + mode = FileMode.OpenOrCreate; // O_CREAT without O_TRUNC must not truncate an existing file + + var options = FileOptions.None; + if ((fi.flags & O_ASYNC) != 0) + options |= FileOptions.Asynchronous; + + if ((fi.flags & O_SYNC) != 0) + options |= FileOptions.WriteThrough; + + var wantsWrite = (fi.flags & (O_WRONLY | O_RDWR)) != 0; + if (FuseOptions!.IsReadOnly && (mode is FileMode.Create or FileMode.Truncate or FileMode.OpenOrCreate || wantsWrite)) + return -EROFS; + + // Read-only opens must not request write access. Otherwise, files with + // read-only permissions (or on read-only media) cannot be opened at all + var access = mode switch + { + FileMode.Append => FileAccess.Write, + FileMode.Create or FileMode.Truncate => FileAccess.ReadWrite, + _ => wantsWrite ? FileAccess.ReadWrite : FileAccess.Read + }; + + var handle = handlesManager.OpenFileHandle(ciphertextPath, mode, access, FileShare.ReadWrite, options); + if (handle == FileSystem.Constants.INVALID_HANDLE) + return -EACCES; + + fi.fh = handle; + return 0; + } + + public override int OpenDir(ReadOnlySpan path, ref FuseFileInfo fi) + { + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + if (File.Exists(ciphertextPath)) + return -ENOTDIR; + + if (!Directory.Exists(ciphertextPath)) + return -ENOENT; + + return 0; + } + + public override int Read(ReadOnlySpan path, ulong offset, Span buffer, ref FuseFileInfo fi) + { + var handle = handlesManager.GetHandle(fi.fh); + if (handle is null) + return -EBADF; + + // Lock on the handle's stream. The kernel can issue concurrent operations + // on the same handle, and setting the position and reading must be atomic + lock (handle.Stream) + { + if ((long)offset > handle.Stream.Length) + return 0; + + handle.Stream.Position = (long)offset; + return handle.Stream.Read(buffer); + } + } + + public override int ReadDir(ReadOnlySpan path, ulong offset, DirectoryContent content, ref FuseFileInfo fi) + { + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + content.AddEntry("."); + content.AddEntry(".."); + + var directoryId = AbstractPathHelpers.AllocateDirectoryId(specifics.Security); + foreach (var entry in Directory.GetFileSystemEntries(ciphertextPath)) + { + var ciphertextName = Path.GetFileName(entry); + if (PathHelpers.IsCoreName(ciphertextName)) + continue; + + // Skip entries whose names cannot be decrypted + var plaintextName = NativePathHelpers.DecryptName(ciphertextName, ciphertextPath, specifics, directoryId); + if (string.IsNullOrEmpty(plaintextName)) + continue; + + content.AddEntry(plaintextName); + } + + return 0; + } + + public override void Release(ReadOnlySpan path, ref FuseFileInfo fi) + { + handlesManager.CloseHandle(fi.fh); + } + + public override int ReleaseDir(ReadOnlySpan path, ref FuseFileInfo fi) + { + return 0; + } + + public override unsafe int RemoveXAttr(ReadOnlySpan path, ReadOnlySpan name) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + fixed (byte* namePtr = NullTerminate(name)) + fixed (byte* ciphertextPathPtr = Encoding.UTF8.GetBytes(ciphertextPath)) + { + if (removexattr(ciphertextPathPtr, namePtr, 0) == -1) + return -errno; + } + + return 0; + } + + public override unsafe int Rename(ReadOnlySpan path, ReadOnlySpan newPath, uint flags) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + var newCiphertextPath = GetCiphertextPath(newPath); + if (ciphertextPath is null || newCiphertextPath is null) + return -ENOENT; + + fixed (byte* ciphertextPathPtr = Encoding.UTF8.GetBytes(ciphertextPath)) + fixed (byte* newCiphertextPathPtr = Encoding.UTF8.GetBytes(newCiphertextPath)) + { + var result = flags == 0u + ? rename(ciphertextPathPtr, newCiphertextPathPtr) + : renamex_np(ciphertextPathPtr, newCiphertextPathPtr, flags); + + if (result == -1) + return -errno; + } + + return 0; + } + + public override int RmDir(ReadOnlySpan path) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + if (!Directory.Exists(ciphertextPath)) + return -ENOENT; + + if (Directory.EnumerateFileSystemEntries(ciphertextPath).Any(static x => !PathHelpers.IsCoreName(x))) + return -ENOTEMPTY; + + var directoryIdPath = Path.Combine(ciphertextPath, FileSystem.Constants.Names.DIRECTORY_ID_FILENAME); + + try + { + // Remove DirectoryID + File.Delete(directoryIdPath); + specifics.DirectoryIdCache.CacheRemove(directoryIdPath); + + Directory.Delete(ciphertextPath, recursive: false); + return 0; + } + catch (Exception ex) + { + return -MapExceptionToErrno(ex); + } + } + + public override unsafe int SetXAttr(ReadOnlySpan path, ReadOnlySpan name, ReadOnlySpan value, int flags, uint position) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + // macFUSE forwards the kernel's internal VFS xattr flags (e.g. XATTR_NOSECURITY, + // XATTR_NODEFAULT), but the setxattr(2) syscall only accepts XATTR_CREATE/XATTR_REPLACE + // and rejects the rest with EINVAL. Re-issuing them verbatim on the backing file makes + // Finder's FinderInfo write fail with error -50 and can leave copied files empty. + var options = flags & (XATTR_CREATE | XATTR_REPLACE); + + fixed (byte* namePtr = NullTerminate(name)) + fixed (void* valuePtr = value) + fixed (byte* ciphertextPathPtr = Encoding.UTF8.GetBytes(ciphertextPath)) + { + if (setxattr(ciphertextPathPtr, namePtr, valuePtr, (nuint)value.Length, position, options) == -1) + return -errno; + } + + return 0; + } + + public override unsafe int StatFS(ReadOnlySpan path, ref StatVfs statfs) + { + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + fixed (StatVfs* statfsPtr = &statfs) + fixed (byte* ciphertextPathPtr = Encoding.UTF8.GetBytes(ciphertextPath)) + { + if (statvfs(ciphertextPathPtr, statfsPtr) == -1) + return -errno; + } + + return 0; + } + + public override int Truncate(ReadOnlySpan path, long length, FuseFileInfoRef fiRef) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + if (Directory.Exists(ciphertextPath)) + return -EISDIR; + + if (!File.Exists(ciphertextPath)) + return -ENOENT; + + MacFuseFileHandle? handle; + var temporaryHandleId = FileSystem.Constants.INVALID_HANDLE; + if (fiRef.IsNull) + { + temporaryHandleId = handlesManager.OpenFileHandle(ciphertextPath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite, FileOptions.None); + if (temporaryHandleId == FileSystem.Constants.INVALID_HANDLE) + return -EIO; + + handle = handlesManager.GetHandle(temporaryHandleId)!; + } + else + { + handle = handlesManager.GetHandle(fiRef.Value.fh); + if (handle is null || !handle.FileAccess.HasFlag(FileAccess.Write)) + return -EBADF; + } + + try + { + lock (handle.Stream) + { + var position = handle.Stream.Position; + handle.Stream.SetLength(length); + handle.Stream.Position = position; + } + + return 0; + } + finally + { + // Close the temporary handle + if (temporaryHandleId != FileSystem.Constants.INVALID_HANDLE) + handlesManager.CloseHandle(temporaryHandleId); + } + } + + /// + /// This method is also responsible for file deletion. + /// + public override int Unlink(ReadOnlySpan path) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null || !File.Exists(ciphertextPath)) + return -ENOENT; + + if (Directory.Exists(ciphertextPath)) + return -EISDIR; + + try + { + File.Delete(ciphertextPath); + return 0; + } + catch (Exception ex) + { + return -MapExceptionToErrno(ex); + } + } + + public override unsafe int UpdateTimestamps(ReadOnlySpan path, ref TimeSpec atime, ref TimeSpec mtime, FuseFileInfoRef fiRef) + { + if (FuseOptions!.IsReadOnly) + return -EROFS; + + var ciphertextPath = GetCiphertextPath(path); + if (ciphertextPath is null) + return -ENOENT; + + if (!File.Exists(ciphertextPath) && !Directory.Exists(ciphertextPath)) + return -ENOENT; + + var times = stackalloc TimeSpec[2] { atime, mtime }; + fixed (byte* ciphertextPathPtr = Encoding.UTF8.GetBytes(ciphertextPath)) + { + if (utimensat(AT_FDCWD, ciphertextPathPtr, times, 0) == -1) + return -errno; + } + + return 0; + } + + public override int Write(ReadOnlySpan path, ulong offset, ReadOnlySpan buffer, ref FuseFileInfo fi) + { + var handle = handlesManager.GetHandle(fi.fh); + if (handle is null || !handle.FileAccess.HasFlag(FileAccess.Write)) + return -EBADF; + + // Lock on the handle's stream. The kernel can issue concurrent operations + // on the same handle, and setting the position and writing must be atomic + lock (handle.Stream) + { + if (handle.FileMode == FileMode.Append) + offset = (ulong)handle.Stream.Length; + + // No SetLength needed here as the plaintext stream extends itself and + // fills any gap with zeros when writing past the end of the file + handle.Stream.Position = (long)offset; + handle.Stream.Write(buffer); + } + + return buffer.Length; + } + + protected override unsafe string? GetCiphertextPath(ReadOnlySpan plaintextName) + { + fixed (byte* plaintextNamePtr = plaintextName) + { + var directoryId = new byte[FileSystem.Constants.DIRECTORY_ID_SIZE]; + return NativePathHelpers.GetCiphertextPath(Encoding.UTF8.GetString(plaintextNamePtr, plaintextName.Length), specifics, directoryId); + } + } + + /// + /// Opens the ciphertext file and forces buffered data to permanent storage (F_FULLFSYNC). + /// + private static int FlushCiphertextToDisk(string ciphertextPath) + { + try + { + using var fileStream = new FileStream(ciphertextPath, FileMode.Open, FileAccess.Write, FileShare.ReadWrite | FileShare.Delete); + fileStream.Flush(flushToDisk: true); + return 0; + } + catch (Exception ex) + { + return -MapExceptionToErrno(ex); + } + } + + private static byte[] NullTerminate(ReadOnlySpan value) + { + var buffer = new byte[value.Length + 1]; + value.CopyTo(buffer); + + return buffer; + } + + private static int MapExceptionToErrno(Exception exception) + { + return exception switch + { + FileNotFoundException or DirectoryNotFoundException => ENOENT, + UnauthorizedAccessException => EACCES, + PathTooLongException => ENAMETOOLONG, + IOException => EIO, + _ => EIO + }; + } + } +} diff --git a/src/Core/SecureFolderFS.Core.MacFuse/Constants.cs b/src/Core/SecureFolderFS.Core.MacFuse/Constants.cs new file mode 100644 index 000000000..bea3d75c8 --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/Constants.cs @@ -0,0 +1,11 @@ +namespace SecureFolderFS.Core.MacFuse +{ + public static class Constants + { + public static class FileSystem + { + public const string FS_ID = "MacFUSE"; + public const string FS_NAME = "macFUSE"; + } + } +} diff --git a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Availability.cs b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Availability.cs new file mode 100644 index 000000000..db4ecfd9a --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Availability.cs @@ -0,0 +1,24 @@ +using FuseSharp; +using SecureFolderFS.Storage.Enums; +using SecureFolderFS.Storage.VirtualFileSystem; + +namespace SecureFolderFS.Core.MacFuse +{ + /// + public sealed partial class MacFuseFileSystem + { + /// + public partial async Task GetStatusAsync(CancellationToken cancellationToken) + { + await Task.CompletedTask; + try + { + return Fuse.CheckDependencies() ? FileSystemAvailability.Available : FileSystemAvailability.ModuleUnavailable; + } + catch (TypeInitializationException) + { + return FileSystemAvailability.ModuleUnavailable; + } + } + } +} diff --git a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.cs b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.cs new file mode 100644 index 000000000..ff00f03ae --- /dev/null +++ b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.cs @@ -0,0 +1,77 @@ +using OwlCore.Storage; +using SecureFolderFS.Core.Cryptography; +using SecureFolderFS.Core.FileSystem; +using SecureFolderFS.Core.FileSystem.Extensions; +using SecureFolderFS.Core.FileSystem.Storage; +using SecureFolderFS.Core.MacFuse.AppModels; +using SecureFolderFS.Core.MacFuse.Callbacks; +using SecureFolderFS.Core.MacFuse.OpenHandles; +using SecureFolderFS.Shared.ComponentModel; +using SecureFolderFS.Storage.Enums; +using SecureFolderFS.Storage.SystemStorageEx; +using SecureFolderFS.Storage.VirtualFileSystem; + +namespace SecureFolderFS.Core.MacFuse +{ + /// + public sealed partial class MacFuseFileSystem : IFileSystemInfo + { + /// + public string Id { get; } = Constants.FileSystem.FS_ID; + + /// + public string Name { get; } = Constants.FileSystem.FS_NAME; + + /// + public partial Task GetStatusAsync(CancellationToken cancellationToken = default); + + /// + public Task GetVolumeNameAsync(string candidateName, CancellationToken cancellationToken = default) + { + return Task.FromResult(candidateName); + } + + /// + public async Task MountAsync(IFolder folder, IDisposable unlockContract, IDictionary options, CancellationToken cancellationToken = default) + { + await Task.CompletedTask; + if (unlockContract is not IWrapper wrapper) + throw new ArgumentException($"The {nameof(unlockContract)} is invalid."); + + var fuseOptions = MacFuseOptions.ToOptions(options.AppendContract(unlockContract)); + if (!Directory.Exists(MountDirectory)) + Directory.CreateDirectory(MountDirectory); + + if (fuseOptions is { AllowOtherUserAccess: true, AllowRootUserAccess: true }) + throw new ArgumentException($"{nameof(MacFuseOptions)}.{nameof(fuseOptions.AllowOtherUserAccess)} and {nameof(MacFuseOptions)}.{nameof(fuseOptions.AllowRootUserAccess)} are mutually exclusive."); + + if ((fuseOptions.AllowOtherUserAccess || fuseOptions.AllowRootUserAccess) && !CanAllowOtherUsers()) + throw new ArgumentException($"{nameof(fuseOptions.AllowOtherUserAccess)} has been specified but the allow_other macFUSE tunable is not enabled."); + + var mountPoint = fuseOptions.MountPoint; + if (mountPoint == null) + Cleanup(); + else + Cleanup(mountPoint); + + if (mountPoint != null && IsMountPoint(mountPoint)) + throw new ArgumentException("A filesystem is already mounted in the specified path."); + + mountPoint ??= GetFreeMountPoint(fuseOptions.VolumeName); + if (!Directory.Exists(mountPoint)) + Directory.CreateDirectory(mountPoint); + + var specifics = FileSystemSpecifics.CreateNew(wrapper.Inner, folder, fuseOptions); + fuseOptions.SetupValidators(specifics); + + var handlesManager = new MacFuseHandlesManager(specifics.StreamsAccess, specifics.Options); + var fuseCallbacks = new OnDeviceMacFuse(specifics, handlesManager); + var fuseWrapper = new MacFuseWrapper(fuseCallbacks); + fuseWrapper.StartFileSystem(mountPoint, fuseOptions); + + var virtualizedRoot = new SystemFolderEx(mountPoint); + var plaintextRoot = new CryptoFolder(Path.DirectorySeparatorChar.ToString(), specifics.ContentFolder, specifics); + return new MacFuseVfsRoot(fuseWrapper, virtualizedRoot, plaintextRoot, specifics); + } + } +} diff --git a/src/Platforms/SecureFolderFS.Cli/CliVaultFileSystemService.cs b/src/Platforms/SecureFolderFS.Cli/CliVaultFileSystemService.cs index c6c017695..be42a7f41 100644 --- a/src/Platforms/SecureFolderFS.Cli/CliVaultFileSystemService.cs +++ b/src/Platforms/SecureFolderFS.Cli/CliVaultFileSystemService.cs @@ -20,7 +20,10 @@ public override async IAsyncEnumerable GetFileSystemsAsync([Enu // Keep ordering aligned with desktop targets: WebDAV first, then native adapters. yield return new CliWebDavFileSystem(); - yield return new FuseFileSystem(); + if (System.OperatingSystem.IsMacOS()) + yield return new SecureFolderFS.Core.MacFuse.MacFuseFileSystem(); + else + yield return new FuseFileSystem(); #if SFFS_WINDOWS_FS yield return new SecureFolderFS.Core.WinFsp.WinFspFileSystem(); diff --git a/src/Platforms/SecureFolderFS.Cli/SecureFolderFS.Cli.csproj b/src/Platforms/SecureFolderFS.Cli/SecureFolderFS.Cli.csproj index ff9ced8fa..59f753706 100644 --- a/src/Platforms/SecureFolderFS.Cli/SecureFolderFS.Cli.csproj +++ b/src/Platforms/SecureFolderFS.Cli/SecureFolderFS.Cli.csproj @@ -13,6 +13,7 @@ + diff --git a/src/Platforms/SecureFolderFS.Uno/Platforms/Desktop/ServiceImplementation/SkiaVaultFileSystemService.cs b/src/Platforms/SecureFolderFS.Uno/Platforms/Desktop/ServiceImplementation/SkiaVaultFileSystemService.cs index 35ed9d036..c7e41d26f 100644 --- a/src/Platforms/SecureFolderFS.Uno/Platforms/Desktop/ServiceImplementation/SkiaVaultFileSystemService.cs +++ b/src/Platforms/SecureFolderFS.Uno/Platforms/Desktop/ServiceImplementation/SkiaVaultFileSystemService.cs @@ -13,7 +13,9 @@ using SecureFolderFS.UI.ServiceImplementation; using static SecureFolderFS.Sdk.Constants.DataSources; -#if !__UNO_SKIA_MACOS__ +#if __UNO_SKIA_MACOS__ +using SecureFolderFS.Core.MacFuse; +#else using System; using SecureFolderFS.Uno.Platforms.Desktop.ViewModels; #endif @@ -29,7 +31,9 @@ public override async IAsyncEnumerable GetFileSystemsAsync([Enu await Task.CompletedTask; yield return new SkiaWebDavFileSystem(); -#if !__UNO_SKIA_MACOS__ +#if __UNO_SKIA_MACOS__ + yield return new MacFuseFileSystem(); +#else // Inside a Flatpak sandbox the FUSE userspace may appear available, but mounts // are confined to the sandbox's mount namespace and invisible to the host if (!FuseInstallationViewModel.IsSandboxed) From b988f4cfbf2f119b19ee2f164233d23c550dbfcf Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sun, 19 Jul 2026 01:13:11 +0200 Subject: [PATCH 07/12] Added tests --- .../FileSystemTests/MacFuseTests.cs | 191 ++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 tests/SecureFolderFS.Tests/FileSystemTests/MacFuseTests.cs diff --git a/tests/SecureFolderFS.Tests/FileSystemTests/MacFuseTests.cs b/tests/SecureFolderFS.Tests/FileSystemTests/MacFuseTests.cs new file mode 100644 index 000000000..a74d095fb --- /dev/null +++ b/tests/SecureFolderFS.Tests/FileSystemTests/MacFuseTests.cs @@ -0,0 +1,191 @@ +using FluentAssertions; +using NUnit.Framework; +using SecureFolderFS.Core.MacFuse; +using SecureFolderFS.Storage.SystemStorageEx; +using SecureFolderFS.Storage.VirtualFileSystem; +using SecureFolderFS.Tests.Models; + +namespace SecureFolderFS.Tests.FileSystemTests +{ + /// + /// End-to-end tests which mount a real vault through macFUSE and exercise it with regular file APIs. + /// + [TestFixture] + [Platform("MacOsX")] + public class MacFuseTests : BaseFileSystemTests + { + private IVfsRoot? _storageRoot; + private string? _vaultPath; + + [SetUp] + public async Task Initialize() + { + if (OperatingSystem.IsMacOS() && FuseSharp.Fuse.CheckDependencies()) + { + // The FUSE file system operates on raw file system paths, + // so the vault must reside on disk instead of in memory + _vaultPath = Directory.CreateTempSubdirectory("MacFuseTests_").FullName; + _storageRoot = await MountVault(new MacFuseFileSystem(), new MockVaultOptions() + { + VaultFolder = new SystemFolderEx(_vaultPath) + }); + } + else + Assert.Ignore("macFUSE is not installed."); + + // The mount point must be a real mounted volume. Without this the tests would + // still pass by reading and writing the raw (unmounted) mount point directory + var mountPoint = _storageRoot.VirtualizedRoot.Id; + DriveInfo.GetDrives().Should().Contain(x => x.RootDirectory.FullName.TrimEnd('/') == mountPoint.TrimEnd('/')); + } + + [TearDown] + public async Task Cleanup() + { + if (_storageRoot is null) + return; + + var mountPoint = _storageRoot.VirtualizedRoot.Id; + await _storageRoot.DisposeAsync(); + + // After a clean unmount the empty mount point directory is removed. Files written + // past the file system (plaintext leakage) would leave the directory behind + DriveInfo.GetDrives().Should().NotContain(x => x.RootDirectory.FullName.TrimEnd('/') == mountPoint.TrimEnd('/')); + Directory.Exists(mountPoint).Should().BeFalse(); + + if (_vaultPath is not null) + Directory.Delete(_vaultPath, recursive: true); + } + + [Test] + public async Task Mount_WriteFile_ReadBack_ThroughKernel() + { + ArgumentNullException.ThrowIfNull(_storageRoot); + var mountPoint = _storageRoot.VirtualizedRoot.Id; + + Directory.Exists(mountPoint).Should().BeTrue(); + + var filePath = Path.Combine(mountPoint, "hello.txt"); + await File.WriteAllTextAsync(filePath, "Hello from macFUSE!"); + + var contents = await File.ReadAllTextAsync(filePath); + contents.Should().Be("Hello from macFUSE!"); + } + + [Test] + public async Task Mount_CreateDirectory_Enumerate_Rename_Delete() + { + ArgumentNullException.ThrowIfNull(_storageRoot); + var mountPoint = _storageRoot.VirtualizedRoot.Id; + + var directoryPath = Path.Combine(mountPoint, "folder"); + Directory.CreateDirectory(directoryPath); + + var filePath = Path.Combine(directoryPath, "data.bin"); + var payload = Enumerable.Range(0, 1024 * 128).Select(static i => (byte)i).ToArray(); + await File.WriteAllBytesAsync(filePath, payload); + + (await File.ReadAllBytesAsync(filePath)).Should().Equal(payload); + Directory.EnumerateFiles(directoryPath).Select(Path.GetFileName).Should().ContainSingle(static x => x == "data.bin"); + + var renamedPath = Path.Combine(directoryPath, "renamed.bin"); + File.Move(filePath, renamedPath); + File.Exists(renamedPath).Should().BeTrue(); + File.Exists(filePath).Should().BeFalse(); + + File.Delete(renamedPath); + Directory.Delete(directoryPath); + Directory.Exists(directoryPath).Should().BeFalse(); + } + + [Test] + public async Task Mount_FinderCopy_PreservesFinderInfoAndContent() + { + // Regression for the Finder "error -50 / zero-byte copy" bug. macFUSE's kernel extension + // tags the com.apple.FinderInfo setxattr of a Finder drag-copy with internal VFS flags + // (XATTR_NOSECURITY/XATTR_NODEFAULT). The setxattr(2) syscall rejects those with EINVAL, so + // re-issuing them verbatim on the backing file made Finder report -50 and (depending on + // copyfile's ordering) leave the copied file empty. Only a real Finder copy reproduces the + // exact flags, so this drives Finder via AppleScript. + ArgumentNullException.ThrowIfNull(_storageRoot); + var mountPoint = _storageRoot.VirtualizedRoot.Id; + + var payload = Enumerable.Range(0, 100_000).Select(static i => (byte)(i % 251)).ToArray(); + var src = Path.Combine(Path.GetTempPath(), $"macfuse-finder-{Guid.NewGuid():N}.bin"); + await File.WriteAllBytesAsync(src, payload); + + // Give the source a non-zero FinderInfo so Finder copies a meaningful one (an all-zero + // FinderInfo is treated as absent by macOS and would not be persisted) + var finderInfo = Enumerable.Range(1, 32).Select(static i => (byte)i).ToArray(); + SetXAttr(src, "com.apple.FinderInfo", finderInfo); + + try + { + var script = $"tell application \"Finder\" to duplicate (POSIX file \"{src}\") to (POSIX file \"{mountPoint}\")"; + var p = System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo( + "/usr/bin/osascript", ["-e", script]) { RedirectStandardError = true, RedirectStandardOutput = true })!; + await p.WaitForExitAsync(); + var stderr = (await p.StandardError.ReadToEndAsync()).Trim(); + + var dest = Path.Combine(mountPoint, Path.GetFileName(src)); + + // Only skip when Finder automation is genuinely blocked (TCC). A copy error such as + // "-50" is the regression itself and must fail the test, not skip it. + var automationBlocked = stderr.Contains("-1743") || stderr.Contains("Not authorized") + || stderr.Contains("assistive access") || stderr.Contains("isn't running"); + if (automationBlocked) + Assert.Ignore($"Finder automation unavailable: '{stderr}'."); + + p.ExitCode.Should().Be(0, $"Finder copy into the vault must succeed, but failed: '{stderr}'"); + File.Exists(dest).Should().BeTrue("the Finder-copied file must exist"); + + // The data fork must be fully copied, not left empty + new FileInfo(dest).Length.Should().Be(payload.Length, "the Finder-copied file must not be left empty"); + (await File.ReadAllBytesAsync(dest)).Should().Equal(payload); + + // Finder writes com.apple.FinderInfo during the copy - the setxattr that failed with + // EINVAL (Finder error -50) before the flag mask was applied + var destFinderInfo = new byte[32]; + GetXAttr(dest, "com.apple.FinderInfo", destFinderInfo) + .Should().Be(32, "Finder must be able to write FinderInfo on the copied file"); + destFinderInfo.Should().Equal(finderInfo); + + File.Delete(dest); + } + finally + { + File.Delete(src); + } + } + + [System.Runtime.InteropServices.DllImport("libSystem.dylib", EntryPoint = "getxattr", CharSet = System.Runtime.InteropServices.CharSet.Ansi, SetLastError = true)] + private static extern nint NativeGetXAttr(string path, string name, byte[] value, nuint size, uint position, int options); + + [System.Runtime.InteropServices.DllImport("libSystem.dylib", EntryPoint = "setxattr", CharSet = System.Runtime.InteropServices.CharSet.Ansi, SetLastError = true)] + private static extern int NativeSetXAttr(string path, string name, byte[] value, nuint size, uint position, int options); + + private static int GetXAttr(string path, string name, byte[] value) => (int)NativeGetXAttr(path, name, value, (nuint)value.Length, 0, 0); + + private static int SetXAttr(string path, string name, byte[] value) => NativeSetXAttr(path, name, value, (nuint)value.Length, 0, 0); + + [Test] + public async Task Mount_Truncate_And_Append() + { + ArgumentNullException.ThrowIfNull(_storageRoot); + var mountPoint = _storageRoot.VirtualizedRoot.Id; + + var filePath = Path.Combine(mountPoint, "resize.txt"); + await File.WriteAllTextAsync(filePath, "0123456789"); + + using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite)) + stream.SetLength(5); + + (await File.ReadAllTextAsync(filePath)).Should().Be("01234"); + + await File.AppendAllTextAsync(filePath, "ABC"); + (await File.ReadAllTextAsync(filePath)).Should().Be("01234ABC"); + + File.Delete(filePath); + } + } +} From 2776ab1922d937246076afb540aeceb00ed928ed Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sun, 19 Jul 2026 01:31:14 +0200 Subject: [PATCH 08/12] Added MacFuse icon --- .../SecureFolderFS.Core.MacFuse/Constants.cs | 2 +- .../MacFuseFileSystem.Availability.cs | 2 +- .../MacFuseFileSystem.Helpers.cs | 2 +- .../Assets/AppAssets/FileSystems/mac_fuse.png | Bin 0 -> 63187 bytes .../ServiceImplementation/UnoMediaService.cs | 2 ++ .../InterfaceRoot/MainWindowRootControl.xaml.cs | 10 ++++++---- .../Overlays/IntroductionOverlayViewModel.cs | 1 + 7 files changed, 12 insertions(+), 7 deletions(-) create mode 100644 src/Platforms/SecureFolderFS.UI/Assets/AppAssets/FileSystems/mac_fuse.png diff --git a/src/Core/SecureFolderFS.Core.MacFuse/Constants.cs b/src/Core/SecureFolderFS.Core.MacFuse/Constants.cs index bea3d75c8..3771b42ea 100644 --- a/src/Core/SecureFolderFS.Core.MacFuse/Constants.cs +++ b/src/Core/SecureFolderFS.Core.MacFuse/Constants.cs @@ -4,7 +4,7 @@ public static class Constants { public static class FileSystem { - public const string FS_ID = "MacFUSE"; + public const string FS_ID = "MAC_FUSE"; public const string FS_NAME = "macFUSE"; } } diff --git a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Availability.cs b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Availability.cs index db4ecfd9a..90ae673a7 100644 --- a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Availability.cs +++ b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Availability.cs @@ -4,7 +4,7 @@ namespace SecureFolderFS.Core.MacFuse { - /// + /// public sealed partial class MacFuseFileSystem { /// diff --git a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Helpers.cs b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Helpers.cs index e276f6187..5d1bee06f 100644 --- a/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Helpers.cs +++ b/src/Core/SecureFolderFS.Core.MacFuse/MacFuseFileSystem.Helpers.cs @@ -5,7 +5,7 @@ namespace SecureFolderFS.Core.MacFuse { - /// + /// public sealed partial class MacFuseFileSystem { private static string MountDirectory { get; } = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), nameof(SecureFolderFS), "mount"); diff --git a/src/Platforms/SecureFolderFS.UI/Assets/AppAssets/FileSystems/mac_fuse.png b/src/Platforms/SecureFolderFS.UI/Assets/AppAssets/FileSystems/mac_fuse.png new file mode 100644 index 0000000000000000000000000000000000000000..a539ccfbf1ff290a46e65c634551b5c5e647e5b3 GIT binary patch literal 63187 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 GetImageFromResourceAsync(string resourceName, CancellationT "DOKANY" => new ImageResource("ms-appx:///Assets/AppAssets/FileSystems/dokany.png"), "WINFSP" => new ImageResource("ms-appx:///Assets/AppAssets/FileSystems/winfsp.png"), "WEBDAV" => new ImageResource("ms-appx:///Assets/AppAssets/FileSystems/webdav.png"), + "MAC_FUSE" => new ImageResource("ms-appx:///Assets/AppAssets/FileSystems/mac_fuse.png"), #else "DOKANY" => new ImageResource("ms-appx:///Assets/AppAssets/FileSystems/dokany.png"), "WINFSP" => new ImageResource("ms-appx:///Assets/AppAssets/FileSystems/winfsp.png"), "WEBDAV" => new ImageResource("ms-appx:///Assets/AppAssets/FileSystems/webdav.png"), + "MAC_FUSE" => new ImageResource("ms-appx:///Assets/AppAssets/FileSystems/mac_fuse.png"), #endif _ => new ImageResource(resourceName, true) diff --git a/src/Platforms/SecureFolderFS.Uno/UserControls/InterfaceRoot/MainWindowRootControl.xaml.cs b/src/Platforms/SecureFolderFS.Uno/UserControls/InterfaceRoot/MainWindowRootControl.xaml.cs index 48e9a15cd..bb3102d2c 100644 --- a/src/Platforms/SecureFolderFS.Uno/UserControls/InterfaceRoot/MainWindowRootControl.xaml.cs +++ b/src/Platforms/SecureFolderFS.Uno/UserControls/InterfaceRoot/MainWindowRootControl.xaml.cs @@ -84,10 +84,12 @@ private async Task EnsureRootAsync() if (!settingsService.AppSettings.WasIntroduced) { var overlayService = DI.Service(); - await overlayService.ShowAsync(new IntroductionOverlayViewModel().WithInitAsync()); - - settingsService.AppSettings.WasIntroduced = true; - await settingsService.AppSettings.SaveAsync(); + var result = await overlayService.ShowAsync(new IntroductionOverlayViewModel().WithInitAsync()); + if (result.Positive()) + { + settingsService.AppSettings.WasIntroduced = true; + await settingsService.AppSettings.SaveAsync(); + } } if (!ViewModel.VaultCollectionModel.IsEmpty()) // Has vaults diff --git a/src/Sdk/SecureFolderFS.Sdk/ViewModels/Views/Overlays/IntroductionOverlayViewModel.cs b/src/Sdk/SecureFolderFS.Sdk/ViewModels/Views/Overlays/IntroductionOverlayViewModel.cs index de98990dc..a1c397574 100644 --- a/src/Sdk/SecureFolderFS.Sdk/ViewModels/Views/Overlays/IntroductionOverlayViewModel.cs +++ b/src/Sdk/SecureFolderFS.Sdk/ViewModels/Views/Overlays/IntroductionOverlayViewModel.cs @@ -109,6 +109,7 @@ private async Task OpenSettingsAsync() partial void OnCurrentIndexChanged(int value) { + _ = value; CurrentStep = $"{CurrentIndex+1}/{SlidesCount}"; } } From 2cc0e38a2cd755ce2cdd06a2dbc994b44fd01eff Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sun, 19 Jul 2026 01:35:38 +0200 Subject: [PATCH 09/12] Updated MacFuse icon --- .../Assets/AppAssets/FileSystems/mac_fuse.png | Bin 63187 -> 105261 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/src/Platforms/SecureFolderFS.UI/Assets/AppAssets/FileSystems/mac_fuse.png b/src/Platforms/SecureFolderFS.UI/Assets/AppAssets/FileSystems/mac_fuse.png index a539ccfbf1ff290a46e65c634551b5c5e647e5b3..8cd6d80447d87e91eca9a92f05bc850272d2e4d5 100644 GIT binary patch literal 105261 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

0_rbE|#e@oWj=ML(opX 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 literal 63187 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 Date: Sun, 19 Jul 2026 01:40:50 +0200 Subject: [PATCH 10/12] Update MainWindowRootControl.xaml.cs --- .../UserControls/InterfaceRoot/MainWindowRootControl.xaml.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/Platforms/SecureFolderFS.Uno/UserControls/InterfaceRoot/MainWindowRootControl.xaml.cs b/src/Platforms/SecureFolderFS.Uno/UserControls/InterfaceRoot/MainWindowRootControl.xaml.cs index bb3102d2c..1c7004af0 100644 --- a/src/Platforms/SecureFolderFS.Uno/UserControls/InterfaceRoot/MainWindowRootControl.xaml.cs +++ b/src/Platforms/SecureFolderFS.Uno/UserControls/InterfaceRoot/MainWindowRootControl.xaml.cs @@ -14,13 +14,12 @@ using SecureFolderFS.Sdk.Extensions; using SecureFolderFS.Sdk.Messages; using SecureFolderFS.Sdk.Services; -using SecureFolderFS.Sdk.ViewModels.Views.Root; using SecureFolderFS.Sdk.ViewModels.Views.Host; using SecureFolderFS.Sdk.ViewModels.Views.Overlays; +using SecureFolderFS.Sdk.ViewModels.Views.Root; using SecureFolderFS.Sdk.ViewModels.Views.Vault; using SecureFolderFS.Shared; using SecureFolderFS.Shared.Extensions; -using SecureFolderFS.Shared.Models; using SecureFolderFS.UI.Helpers; using SecureFolderFS.Uno.Helpers; using Uno.UI; From 7acab84e61d771d42819f51cd6f7c4ccf9154a9d Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sun, 19 Jul 2026 15:21:58 +0200 Subject: [PATCH 11/12] Carry over fixes from Linux FUSE --- .../Callbacks/OnDeviceMacFuse.cs | 28 +++++++++++++++---- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs b/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs index 327035bee..1327455b6 100644 --- a/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs +++ b/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs @@ -1,11 +1,14 @@ using System.Text; using FuseSharp; using FuseSharp.Native; +using OwlCore.Storage; using SecureFolderFS.Core.FileSystem; using SecureFolderFS.Core.FileSystem.Helpers.Paths; using SecureFolderFS.Core.FileSystem.Helpers.Paths.Abstract; using SecureFolderFS.Core.FileSystem.Helpers.Paths.Native; +using SecureFolderFS.Core.FileSystem.Helpers.RecycleBin.Native; using SecureFolderFS.Core.MacFuse.OpenHandles; +using SecureFolderFS.Storage.Extensions; using static FuseSharp.Native.LibC; namespace SecureFolderFS.Core.MacFuse.Callbacks @@ -475,18 +478,25 @@ public override int RmDir(ReadOnlySpan path) if (!Directory.Exists(ciphertextPath)) return -ENOENT; - if (Directory.EnumerateFileSystemEntries(ciphertextPath).Any(static x => !PathHelpers.IsCoreName(x))) + // Protect core folders from deletion + if (PathHelpers.IsCoreName(Path.GetFileName(Path.TrimEndingDirectorySeparator(ciphertextPath)))) + return -EACCES; + + if (Directory.EnumerateFileSystemEntries(ciphertextPath).Any(static x => !PathHelpers.IsCoreName(Path.GetFileName(x)))) return -ENOTEMPTY; var directoryIdPath = Path.Combine(ciphertextPath, FileSystem.Constants.Names.DIRECTORY_ID_FILENAME); - try { - // Remove DirectoryID + if (FuseOptions.IsRecycleBinEnabled()) + NativeRecycleBinHelpers.DeleteOrRecycle(ciphertextPath, specifics, StorableType.Folder); + else + Directory.Delete(ciphertextPath, recursive: true); // Recursive because we want to delete the Directory ID file + + // Delete and remove Directory ID File.Delete(directoryIdPath); specifics.DirectoryIdCache.CacheRemove(directoryIdPath); - Directory.Delete(ciphertextPath, recursive: false); return 0; } catch (Exception ex) @@ -603,9 +613,17 @@ public override int Unlink(ReadOnlySpan path) if (Directory.Exists(ciphertextPath)) return -EISDIR; + // Protect core files from deletion + if (PathHelpers.IsCoreName(Path.GetFileName(ciphertextPath))) + return -EACCES; + try { - File.Delete(ciphertextPath); + if (FuseOptions.IsRecycleBinEnabled()) + NativeRecycleBinHelpers.DeleteOrRecycle(ciphertextPath, specifics, StorableType.File); + else + File.Delete(ciphertextPath); + return 0; } catch (Exception ex) From a6bd4598f69578d54dd2641ef08e6cce0c09e3ac Mon Sep 17 00:00:00 2001 From: d2dyno <53011783+d2dyno1@users.noreply.github.com> Date: Sun, 19 Jul 2026 15:26:17 +0200 Subject: [PATCH 12/12] Update OnDeviceMacFuse.cs --- .../SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs b/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs index 1327455b6..79260bf2c 100644 --- a/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs +++ b/src/Core/SecureFolderFS.Core.MacFuse/Callbacks/OnDeviceMacFuse.cs @@ -79,10 +79,7 @@ public override int Create(ReadOnlySpan path, uint mode, ref FuseFileInfo { if (!fileExists) { - using (File.Create(ciphertextPath)) - { - } - + File.Create(ciphertextPath).Dispose(); File.SetUnixFileMode(ciphertextPath, (UnixFileMode)(mode & 0xFFFu)); } }