Implemented remaining features and fixes for Release Candidate 1

global.json

@@ -1,5 +1,5 @@
 {
   "msbuild-sdks": {
-    "Uno.Sdk": "6.5.31"
+    "Uno.Sdk": "6.6.29"
   }
 }

src/Core/SecureFolderFS.Core.Dokany/Callbacks/OnDeviceDokany.cs

@@ -251,8 +251,10 @@ public override void Cleanup(string fileName, IDokanFileInfo info)
                         NativeRecycleBinHelpers.DeleteOrRecycle(ciphertextPath, specifics, StorableType.File);
                     }
                 }
-                catch (UnauthorizedAccessException)
+                catch (Exception)
                 {
+                    // An exception must never escape into the driver callback. Concurrent deletes
+                    // can surface IOException (sharing violations) besides UnauthorizedAccessException.
                 }
             }
         }
@@ -492,6 +494,10 @@ public override NtStatus DeleteFile(string fileName, IDokanFileInfo info)
             if (ciphertextPath is null)
                 return Trace(NtStatus.ObjectPathInvalid, fileName, info);
 
+            // Protect core files from deletion
+            if (PathHelpers.IsCoreName(Path.GetFileName(ciphertextPath)))
+                return Trace(DokanResult.AccessDenied, fileName, info);
+
             // Perform checks
             if (Directory.Exists(ciphertextPath))
                 return Trace(DokanResult.AccessDenied, fileName, info);
@@ -516,6 +522,10 @@ public override NtStatus DeleteDirectory(string fileName, IDokanFileInfo info)
             if (ciphertextPath is null)
                 return Trace(NtStatus.ObjectPathInvalid, fileName, info);
 
+            // Protect core folders from deletion
+            if (PathHelpers.IsCoreName(Path.GetFileName(ciphertextPath)))
+                return Trace(DokanResult.AccessDenied, fileName, info);
+
             try
             {
                 using var directoryEnumerator = Directory.EnumerateFileSystemEntries(ciphertextPath).GetEnumerator();

src/Core/SecureFolderFS.Core.FUSE/Callbacks/OnDeviceFuse.cs

@@ -1,10 +1,13 @@
 using System.Text;
+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.FUSE.OpenHandles;
 using SecureFolderFS.Core.FUSE.UnsafeNative;
+using SecureFolderFS.Storage.Extensions;
 using Tmds.Fuse;
 using Tmds.Linux;
 using static SecureFolderFS.Core.FUSE.UnsafeNative.UnsafeNativeApis;
@@ -470,19 +473,58 @@ public override unsafe int RmDir(ReadOnlySpan<byte> path)
             if (ciphertextPath is null)
                 return -ENOENT;
 
-            if (Directory.EnumerateFileSystemEntries(ciphertextPath).Any(x => !PathHelpers.IsCoreName(x)))
+            // Protect core folders from deletion
+            if (PathHelpers.IsCoreName(Path.GetFileName(Path.TrimEndingDirectorySeparator(ciphertextPath))))
+                return -EACCES;
+
+            if (Directory.EnumerateFileSystemEntries(ciphertextPath).Any(x => !PathHelpers.IsCoreName(Path.GetFileName(x))))
                 return -ENOTEMPTY;
 
             var directoryIdPath = Path.Combine(ciphertextPath, FileSystem.Constants.Names.DIRECTORY_ID_FILENAME);
+            specifics.DirectoryIdCache.CacheRemove(directoryIdPath);
+
+            if (FuseOptions.IsRecycleBinEnabled())
+            {
+                try
+                {
+                    // The folder is moved into the recycle bin together with its DirectoryID file
+                    NativeRecycleBinHelpers.DeleteOrRecycle(ciphertextPath, specifics, StorableType.Folder);
+                    return 0;
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    return -EACCES;
+                }
+                catch (Exception)
+                {
+                    return -EIO;
+                }
+            }
 
-            // Remove DirectoryID
+            // Read the DirectoryID so it can be restored if rmdir fails.
+            // Deleting it permanently while the folder survives would make its contents undecryptable
+            var directoryId = File.Exists(directoryIdPath) ? File.ReadAllBytes(directoryIdPath) : null;
             File.Delete(directoryIdPath);
-            specifics.DirectoryIdCache.CacheRemove(directoryIdPath);
 
             fixed (byte *ciphertextPathPtr = Encoding.UTF8.GetBytes(ciphertextPath))
             {
                 if (rmdir(ciphertextPathPtr) == -1)
-                    return -errno;
+                {
+                    var error = errno;
+                    if (directoryId is null)
+                        return -error;
+
+                    try
+                    {
+                        File.WriteAllBytes(directoryIdPath, directoryId);
+                    }
+                    catch (Exception)
+                    {
+                        // Best effort - the directory may have been removed concurrently
+                    }
+
+                    return -error;
+                }
             }
 
             return 0;
@@ -590,6 +632,27 @@ public override unsafe int Unlink(ReadOnlySpan<byte> path)
             if (Directory.Exists(ciphertextPath))
                 return -EISDIR;
 
+            // Protect core files from deletion
+            if (PathHelpers.IsCoreName(Path.GetFileName(ciphertextPath)))
+                return -EACCES;
+
+            if (FuseOptions.IsRecycleBinEnabled())
+            {
+                try
+                {
+                    NativeRecycleBinHelpers.DeleteOrRecycle(ciphertextPath, specifics, StorableType.File);
+                    return 0;
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    return -EACCES;
+                }
+                catch (Exception)
+                {
+                    return -EIO;
+                }
+            }
+
             fixed (byte *ciphertextPathPtr = Encoding.UTF8.GetBytes(ciphertextPath))
             {
                 if (unlink(ciphertextPathPtr) == -1)

src/Core/SecureFolderFS.Core.FileSystem/Constants.cs

@@ -6,6 +6,16 @@ public static class Constants
         public const string UNC_NAME = "securefolderfs";
         public const int FILE_EOF = 0;
         public const int DIRECTORY_ID_SIZE = 16;
+
+        /// <summary>
+        /// The time window within which previously recycled items are folded back into a
+        /// recycled parent folder. OS clients (Finder, Explorer, WebDav/FUSE drivers) delete
+        /// folder trees member-by-member; when the parent folder finally arrives at the recycle
+        /// bin, children recycled within this window are reattached to it so the tree appears
+        /// as a single restorable entry. Membership is proven by Directory ID, so this window
+        /// only limits how far back unrelated same-folder deletions are pulled in.
+        /// </summary>
+        public const long RECYCLE_BIN_FOLD_WINDOW_MS = 60L * 60L * 1000L;
         public const ulong INVALID_HANDLE = 0UL;
         public const bool OPT_IN_FOR_OPTIONAL_DEBUG_TRACING = false;
 

src/Core/SecureFolderFS.Core.FileSystem/FileSystemSpecifics.cs

@@ -5,6 +5,7 @@
 using SecureFolderFS.Shared.Models;
 using SecureFolderFS.Storage.VirtualFileSystem;
 using System;
+using System.Threading;
 
 namespace SecureFolderFS.Core.FileSystem
 {
@@ -48,13 +49,19 @@ public sealed class FileSystemSpecifics : IDisposable
         /// </summary>
         public required UniversalCache<NameWithDirectoryId, string> PlaintextFileNameCache { get; init; }
 
+        /// <summary>
+        /// Gets the lock that serializes recycle bin quota checks and occupied-size updates.
+        /// </summary>
+        public SemaphoreSlim RecycleBinSemaphore { get; } = new(1, 1);
+
         private FileSystemSpecifics()
         {
         }
 
         /// <inheritdoc/>
         public void Dispose()
         {
+            RecycleBinSemaphore.Dispose();
             PlaintextFileNameCache.Dispose();
             CiphertextFileNameCache.Dispose();
             DirectoryIdCache.Dispose();