fix: improve thread safety, regex caching, volume label sanitization, and logging

Author: drpetersonfernandes

SimpleZipDrive.Core/DiagnosticLogger.cs

@@ -1,5 +1,4 @@
 using System.Globalization;
-using System.Text;
 
 namespace SimpleZipDrive.Core;
 
@@ -10,6 +9,7 @@ public static class DiagnosticLogger
 {
     private static readonly object Lock = new();
     internal static volatile bool Initialized;
+    private static StreamWriter? _writer;
 
     public static bool IsEnabled { get; internal set; }
 
@@ -75,6 +75,16 @@ public static void Initialize(string? logDir = null, bool enabled = true)
         {
             Directory.CreateDirectory(dir);
             LogFilePath = Path.Combine(dir, $"debug_{DateTime.Now:yyyyMMdd_HHmmss}_{Guid.NewGuid():N}.log");
+
+            lock (Lock)
+            {
+                _writer?.Dispose();
+                _writer = new StreamWriter(LogFilePath, false, System.Text.Encoding.UTF8)
+                {
+                    AutoFlush = true
+                };
+            }
+
             Initialized = true;
         }
         catch
@@ -83,6 +93,18 @@ public static void Initialize(string? logDir = null, bool enabled = true)
         }
     }
 
+    /// <summary>
+    /// Closes the underlying log file writer. Call during application shutdown.
+    /// </summary>
+    public static void Close()
+    {
+        lock (Lock)
+        {
+            _writer?.Dispose();
+            _writer = null;
+        }
+    }
+
     /// <summary>
     /// Writes a message to the diagnostic log.
     /// </summary>
@@ -93,15 +115,13 @@ public static void Log(string message)
 
         var timestamp = DateTime.Now.ToString("HH:mm:ss.fff", CultureInfo.InvariantCulture);
         var threadId = Environment.CurrentManagedThreadId;
-        var line = $"[{timestamp}][T{threadId}] {message}{Environment.NewLine}";
+        var line = $"[{timestamp}][T{threadId}] {message}";
 
         try
         {
             lock (Lock)
             {
-                var bytes = Encoding.UTF8.GetBytes(line);
-                using var fs = new FileStream(LogFilePath, FileMode.Append, FileAccess.Write, FileShare.Read | FileShare.Delete);
-                fs.Write(bytes, 0, bytes.Length);
+                _writer?.WriteLine(line);
             }
         }
         catch

SimpleZipDrive.Core/Services/UpdateService.cs

@@ -112,6 +112,6 @@ public async Task CheckForUpdateAsync(CancellationToken cancellationToken = defa
         }
     }
 
-    [GeneratedRegex(@"\d+\.\d+(?:\.\d+)?", RegexOptions.Compiled)]
+    [GeneratedRegex(@"\d+\.\d+\.\d+", RegexOptions.Compiled)]
     private static partial Regex VersionRegex();
 }

SimpleZipDrive.Core/ZipFileSystemCore.cs

@@ -37,7 +37,7 @@ public class ZipFileSystemCore : IDisposable
     private readonly object _memoryLock = new();
 
     private readonly Func<string?> _passwordProvider;
-    private volatile bool _disposed;
+    private int _disposedInt;
 
     public const string DefaultVolumeLabel = "SimpleZipDrive";
     public const long DefaultMaxMemorySize = 512L * 1024 * 1024;
@@ -103,7 +103,7 @@ public ZipFileSystemCore(
         }
     }
 
-    public bool IsDisposed => _disposed;
+    public bool IsDisposed => Volatile.Read(ref _disposedInt) != 0;
     public string ArchiveType { get; }
 
     public string TempDirectoryPath { get; }
@@ -427,8 +427,15 @@ public List<EntryNode> ListDirectory(string normalizedPath)
             }
         }
 
-        foreach (var dirPathKey in _directoryCreationTimes.Keys)
+        List<KeyValuePair<string, DateTime>> dirSnapshot;
+        lock (_archiveLock)
+        {
+            dirSnapshot = _directoryCreationTimes.ToList();
+        }
+
+        foreach (var dirKvp in dirSnapshot)
         {
+            var dirPathKey = dirKvp.Key;
             if (dirPathKey.Equals(searchPrefix, StringComparison.OrdinalIgnoreCase)) continue;
             if (!dirPathKey.StartsWith(searchPrefix, StringComparison.OrdinalIgnoreCase)) continue;
 
@@ -438,9 +445,13 @@ public List<EntryNode> ListDirectory(string normalizedPath)
             var name = dirPathKey.Split('/').LastOrDefault(static s => !string.IsNullOrEmpty(s));
             if (!string.IsNullOrEmpty(name) && seenFileNames.Add(name))
             {
-                _directoryCreationTimes.TryGetValue(dirPathKey, out var ct);
-                _directoryLastWriteTimes.TryGetValue(dirPathKey, out var lwt);
-                _directoryLastAccessTimes.TryGetValue(dirPathKey, out var lat);
+                DateTime ct, lwt, lat;
+                lock (_archiveLock)
+                {
+                    _directoryCreationTimes.TryGetValue(dirPathKey, out ct);
+                    _directoryLastWriteTimes.TryGetValue(dirPathKey, out lwt);
+                    _directoryLastAccessTimes.TryGetValue(dirPathKey, out lat);
+                }
 
                 var implicitPath = searchPrefix + name;
                 result.Add(new EntryNode
@@ -804,7 +815,13 @@ public void DumpEntries(int maxEntries = 100)
             if (_failedEntries.Count > 0)
             {
                 DiagnosticLogger.Log("  --- Failed entries ---");
-                foreach (var failed in _failedEntries)
+                string[] failedSnapshot;
+                lock (_archiveLock)
+                {
+                    failedSnapshot = _failedEntries.ToArray();
+                }
+
+                foreach (var failed in failedSnapshot)
                 {
                     DiagnosticLogger.Log($"  [FAILED] {failed}");
                 }
@@ -821,16 +838,11 @@ public void DumpEntries(int maxEntries = 100)
 
     public void Dispose()
     {
-        if (_disposed)
+        if (Interlocked.Exchange(ref _disposedInt, 1) != 0)
             return;
 
         DiagnosticLogger.LogHeader("ZipFs DISPOSE");
 
-        lock (_archiveLock)
-        {
-            _disposed = true;
-        }
-
         _archive.Dispose();
         _sourceArchiveStream.Dispose();
 

SimpleZipDrive.Core/ZipFsHelpers.cs

@@ -11,9 +11,11 @@ namespace SimpleZipDrive.Core;
 public static class ZipFsHelpers
 {
     // Cache for compiled regex patterns to avoid recompilation overhead.
-    // Uses a plain Dictionary guarded by a lock because all accesses are protected
-    // by the same lock to ensure atomic check-evict-add semantics.
-    private static readonly Dictionary<string, Regex> RegexCache = new();
+    // Uses a Dictionary + LinkedList for LRU eviction: the LinkedList tracks
+    // insertion/re-access order (most recent at the end), and when the cache
+    // is full the oldest entry (first in LinkedList) is evicted.
+    private static readonly Dictionary<string, (Regex Regex, LinkedListNode<string> Node)> RegexCache = new();
+    private static readonly LinkedList<string> RegexLruOrder = new();
     private static readonly object RegexCacheLock = new();
     private const int MaxRegexCacheSize = 100; // Limit cache size to prevent unbounded growth
 
@@ -233,20 +235,29 @@ internal static bool IsMatchSimple(string input, string pattern)
 
         lock (RegexCacheLock)
         {
-            if (RegexCache.TryGetValue(regexPattern, out var regex))
-                return regex.IsMatch(input);
+            if (RegexCache.TryGetValue(regexPattern, out var entry))
+            {
+                // Move to end of LRU list (most recently used)
+                RegexLruOrder.Remove(entry.Node);
+                var newNode = RegexLruOrder.AddLast(regexPattern);
+                RegexCache[regexPattern] = (entry.Regex, newNode);
+                return entry.Regex.IsMatch(input);
+            }
 
             if (RegexCache.Count >= MaxRegexCacheSize)
             {
-                var oldestKey = RegexCache.Keys.FirstOrDefault();
-                if (oldestKey != null)
+                // Evict the least recently used (first in the linked list)
+                var oldest = RegexLruOrder.First;
+                if (oldest != null)
                 {
-                    RegexCache.Remove(oldestKey);
+                    RegexLruOrder.RemoveFirst();
+                    RegexCache.Remove(oldest.Value);
                 }
             }
 
             var newRegex = new Regex(regexPattern, RegexOptions.IgnoreCase | RegexOptions.Compiled, TimeSpan.FromMilliseconds(100));
-            RegexCache[regexPattern] = newRegex;
+            var lruNode = RegexLruOrder.AddLast(regexPattern);
+            RegexCache[regexPattern] = (newRegex, lruNode);
             return newRegex.IsMatch(input);
         }
     }
@@ -270,4 +281,52 @@ internal static bool IsNameMatch(string name, string pattern)
 
         return IsMatchSimple(name, pattern);
     }
+
+    private const int MaxVolumeLabelLength = 32;
+    private static readonly char[] InvalidVolumeLabelChars = ['\\', '/', ':', '*', '?', '"', '<', '>', '|'];
+
+    /// <summary>
+    /// Sanitizes a string for use as a Windows volume label.
+    /// Strips invalid characters, trims whitespace, truncates to 32 characters,
+    /// and falls back to <see cref="ZipFileSystemCore.DefaultVolumeLabel"/> if the result is empty.
+    /// </summary>
+    internal static string SanitizeVolumeLabel(string? label)
+    {
+        if (string.IsNullOrWhiteSpace(label))
+            return ZipFileSystemCore.DefaultVolumeLabel;
+
+        Span<char> buffer = stackalloc char[label.Length];
+        var written = 0;
+
+        foreach (var ch in label)
+        {
+            if (Array.IndexOf(InvalidVolumeLabelChars, ch) < 0)
+            {
+                buffer[written++] = ch;
+            }
+        }
+
+        // Trim trailing spaces/dots (Windows trims these)
+        while (written > 0 && (buffer[written - 1] == ' ' || buffer[written - 1] == '.'))
+        {
+            written--;
+        }
+
+        // Truncate to NTFS limit
+        if (written > MaxVolumeLabelLength)
+        {
+            written = MaxVolumeLabelLength;
+        }
+
+        // Final trim in case truncation exposed trailing spaces/dots
+        while (written > 0 && (buffer[written - 1] == ' ' || buffer[written - 1] == '.'))
+        {
+            written--;
+        }
+
+        if (written == 0)
+            return ZipFileSystemCore.DefaultVolumeLabel;
+
+        return new string(buffer[..written]);
+    }
 }

SimpleZipDrive.Tests/WinFsp/WinFspMountServiceTests.cs

@@ -1,5 +1,5 @@
-using SimpleZipDrive.Core.Services;
 using SimpleZipDrive_WinFsp.Services;
+using SimpleZipDrive.Core.Services;
 
 namespace SimpleZipDrive.Tests.WinFsp;
 

SimpleZipDrive/Services/MountService.cs

@@ -163,9 +163,13 @@ public void Dispose()
         {
         }
 
+        // Give the driver time to finish pending callbacks before disposing resources
+        Thread.Sleep(500);
+
         _mountCancellation?.Dispose();
         _currentZipFs?.Dispose();
         _currentZipFs = null;
+        CurrentArchivePath = null;
         GC.SuppressFinalize(this);
     }
 
@@ -312,6 +316,7 @@ private async Task MountWithSpecifiedPointAsync(string archivePath, string mount
 
     private async Task<bool> AttemptMountLifecycleAsync(string archivePath, string mountPoint, Dokan dokan, string archiveType)
     {
+        _mountCancellation?.Dispose();
         _mountCancellation = new CancellationTokenSource();
 
         try
@@ -331,7 +336,7 @@ private async Task<bool> AttemptMountLifecycleAsync(string archivePath, string m
 
             try
             {
-                var volumeLabel = Path.GetFileNameWithoutExtension(archivePath);
+                var volumeLabel = ZipFsHelpers.SanitizeVolumeLabel(Path.GetFileNameWithoutExtension(archivePath));
                 _currentZipFs = new ZipFs(
                     fileStream,
                     mountPoint,
@@ -412,19 +417,22 @@ private async Task<bool> AttemptMountLifecycleAsync(string archivePath, string m
             _loggingService.LogError($"Dokan error: {ex.Message}");
             ErrorLoggerStatic.ReportSilentException(ex, $"MountService.AttemptMountLifecycleAsync: DokanException mounting '{archivePath}' to '{mountPoint}'", true);
             ShowDokanDriverErrorDialog(ex.Message);
+            CurrentArchivePath = null;
             return false;
         }
         catch (Exception ex) when (ex.Message.Contains("drive", StringComparison.OrdinalIgnoreCase) ||
                                    ex.Message.Contains("mount", StringComparison.OrdinalIgnoreCase))
         {
             _loggingService.LogError($"Mount error: {ex.Message}");
             ErrorLoggerStatic.ReportSilentException(ex, $"MountService.AttemptMountLifecycleAsync: Drive/mount error for '{archivePath}' to '{mountPoint}'", true);
+            CurrentArchivePath = null;
             return false;
         }
         catch (Exception ex)
         {
             _loggingService.LogError($"Mount error: {ex.Message}");
             ErrorLoggerStatic.LogErrorSync(ex, $"MountService.AttemptMountLifecycleAsync: Error mounting archive '{archivePath}' to '{mountPoint}'");
+            CurrentArchivePath = null;
             return false;
         }
     }

SimpleZipDrive_WinFsp/App.xaml.cs

@@ -4,6 +4,7 @@
 using System.Text;
 using System.Threading.Channels;
 using System.Windows;
+using SimpleZipDrive_WinFsp.Services;
 
 namespace SimpleZipDrive_WinFsp;
 

SimpleZipDrive_WinFsp/GlobalUsings.cs

@@ -7,5 +7,4 @@
 global using SimpleZipDrive.Core;
 global using SimpleZipDrive.Core.Models;
 global using SimpleZipDrive.Core.Services;
-global using SimpleZipDrive.Core.Views;
-global using SimpleZipDrive_WinFsp.Services;
+global using SimpleZipDrive.Core.Views;