CRITICAL FIX: Use Win32Api.ERROR_HANDLE_EOF (raw 38) instead of literal HRESULT 0x80070026. GetLastWin32Error() returns raw Win32 codes, not HRESULTs. This was causing EOF to never be detected, making the scan loop run forever on garbage data and return 0 records.

FastSeekWpf/Core/MftReader.cs

@@ -9,7 +9,7 @@ namespace FastSeekWpf.Core;
 
 public class MftReader : IDisposable
 {
-    private readonly IntPtr _volumeHandle;
+    private readonly IntPtr _handle;
     private readonly NtfsDrive _drive;
     private bool _disposed;
 
@@ -21,7 +21,7 @@ public class MftReader : IDisposable
     public MftReader(NtfsDrive drive)
     {
         _drive = drive;
-        _volumeHandle = Win32Api.CreateFileW(
+        _handle = Win32Api.CreateFileW(
             drive.DevicePath,
             Win32Api.GENERIC_READ,
             Win32Api.FILE_SHARE_READ | Win32Api.FILE_SHARE_WRITE | Win32Api.FILE_SHARE_DELETE,
@@ -30,17 +30,14 @@ public class MftReader : IDisposable
             Win32Api.FILE_FLAG_BACKUP_SEMANTICS,
             IntPtr.Zero);
 
-        if (_volumeHandle == new IntPtr(-1))
+        if (_handle == new IntPtr(-1))
         {
             int err = Marshal.GetLastWin32Error();
             throw new IOException($"Failed to open volume {drive.DevicePath}: {Win32Error(err)} (code={err})");
         }
     }
 
-    // ------------------------------------------------------------------
-    //  Try direct first, fall back to FSCTL (matches Rust main.rs exactly)
-    // ------------------------------------------------------------------
-
+    // Try direct first, fall back to FSCTL — matches Rust main.rs exactly
     public (ScanResult scan, string method) ScanAny()
     {
         var direct = ScanDirect();
@@ -49,10 +46,7 @@ public class MftReader : IDisposable
         return (Scan(), "ioctl");
     }
 
-    // ------------------------------------------------------------------
-    //  Primary: direct $MFT file read (matches Rust scan_direct())
-    // ------------------------------------------------------------------
-
+    // Primary: direct $MFT file read — matches Rust scan_direct()
     public ScanResult? ScanDirect()
     {
         int? recordSize = ReadMftRecordSize();
@@ -113,13 +107,13 @@ public class MftReader : IDisposable
                     offset += recordSize.Value;
                 }
 
-                // Align down to record boundary (matches Rust: offset = total - (total % record_size))
+                // Align down to record boundary — matches Rust offset = total - (total % record_size)
                 offset = total - (total % recordSize.Value);
 
                 leftover = total - offset;
                 if (leftover > 0)
                 {
-                    // Copy tail to front of buffer (matches Rust std::ptr::copy)
+                    // Copy tail to front — matches Rust std::ptr::copy
                     Buffer.BlockCopy(buffer, offset, buffer, 0, leftover);
                 }
             }
@@ -133,11 +127,7 @@ public class MftReader : IDisposable
         }
     }
 
-    // ------------------------------------------------------------------
-    //  Fallback: FSCTL_ENUM_USN_DATA (4 MB buffer)
-    //  Matches Rust scan() exactly.
-    // ------------------------------------------------------------------
-
+    // Fallback: FSCTL_ENUM_USN_DATA (4 MB buffer) — matches Rust scan() exactly
     public ScanResult Scan()
     {
         var records = new List<CompactRecord>();
@@ -157,16 +147,14 @@ public class MftReader : IDisposable
 
         try
         {
-            int iterations = 0;
             while (true)
             {
-                iterations++;
                 IntPtr bufferPtr = Marshal.AllocHGlobal(buffer.Length);
                 try
                 {
                     uint bytesReturned = 0;
                     bool ok = Win32Api.DeviceIoControl(
-                        _volumeHandle,
+                        _handle,
                         Win32Api.FSCTL_ENUM_USN_DATA,
                         enumDataPtr,
                         (uint)enumDataSize,
@@ -178,13 +166,13 @@ public class MftReader : IDisposable
                     if (!ok)
                     {
                         int error = Marshal.GetLastWin32Error();
-                        uint code = (uint)error;
-                        if (code == 0x80070026) // ERROR_HANDLE_EOF
+                        // CRITICAL: GetLastWin32Error returns RAW Win32 error (38), NOT HRESULT (0x80070026)
+                        if (error == Win32Api.ERROR_HANDLE_EOF)
                         {
-                            Logger.Log($"[{Drive.Letter}] FSCTL_ENUM_USN_DATA: EOF after {iterations} iterations");
+                            Logger.Log($"[{Drive.Letter}] FSCTL_ENUM_USN_DATA: EOF");
                             break;
                         }
-                        if (error == 122) // ERROR_INSUFFICIENT_BUFFER
+                        if (error == Win32Api.ERROR_INSUFFICIENT_BUFFER)
                         {
                             Logger.Log($"[{Drive.Letter}] FSCTL buffer too small ({buffer.Length}), retrying");
                             buffer = new byte[buffer.Length * 2];
@@ -249,13 +237,9 @@ public class MftReader : IDisposable
         return new ScanResult(records, nameData);
     }
 
-    // ------------------------------------------------------------------
-    //  NTFS helpers (match Rust exactly)
-    // ------------------------------------------------------------------
-
+    // Read MFT record size from NTFS boot sector — matches Rust read_mft_record_size()
     private int? ReadMftRecordSize()
     {
-        // Seek to beginning of volume
         Win32Api.SetFilePointerEx(_volumeHandle, 0, out _, 0);
 
         byte[] boot = new byte[512];
@@ -278,10 +262,7 @@ public class MftReader : IDisposable
         return recordSize;
     }
 
-    /// <summary>
-    /// Apply NTFS multi-sector fixup. Returns false if record is invalid.
-    /// CRITICAL: restores bytes from fixup array back to sector ends (matches Rust exactly).
-    /// </summary>
+    // Apply NTFS multi-sector fixup — matches Rust apply_fixup() exactly
     private static bool ApplyFixup(byte[] record, int offset, int recordSize)
     {
         if (recordSize < 48 || record[offset] != 'F' || record[offset + 1] != 'I'
@@ -305,7 +286,7 @@ public class MftReader : IDisposable
             if (record[offset + end] != check0 || record[offset + end + 1] != check1)
                 return false;
 
-            // RESTORE real bytes from fixup array (this is what Rust does)
+            // RESTORE real bytes from fixup array — matches Rust exactly
             record[offset + end] = record[offset + fixupOff + i * 2];
             record[offset + end + 1] = record[offset + fixupOff + i * 2 + 1];
         }
@@ -313,9 +294,7 @@ public class MftReader : IDisposable
         return true;
     }
 
-    /// <summary>
-    /// Parse one MFT FILE record (matches Rust parse_file_record exactly).
-    /// </summary>
+    // Parse one MFT FILE record — matches Rust parse_file_record() exactly
     private static void ParseFileRecord(
         ReadOnlySpan<byte> record,
         ulong mftIndex,