Upload FastSeekWpf/Core/MftReader.cs

FastSeekWpf/Core/MftReader.cs

@@ -37,18 +37,22 @@ public class MftReader : IDisposable
         }
     }
 
-    /// <summary>
-    /// Primary: direct $MFT file read. Returns null if unavailable.
-    /// Matches Rust scan_direct() exactly.
-    /// </summary>
+    // ------------------------------------------------------------------
+    //  Primary: direct $MFT file read
+    // ------------------------------------------------------------------
+
     public ScanResult? ScanDirect()
     {
         int? recordSize = ReadMftRecordSize();
-        if (!recordSize.HasValue) return null;
+        if (!recordSize.HasValue)
+        {
+            Logger.Log($"[{Drive.Letter}] ReadMftRecordSize failed — cannot do direct scan");
+            return null;
+        }
 
         string mftPath = $"{_drive.Root}$MFT";
+        Logger.Log($"[{Drive.Letter}] Opening $MFT file: {mftPath}");
 
-        // Open $MFT as a normal file (not the volume device)
         IntPtr mftHandle = Win32Api.CreateFileW(
             mftPath,
             Win32Api.GENERIC_READ,
@@ -59,7 +63,13 @@ public class MftReader : IDisposable
             IntPtr.Zero);
 
         if (mftHandle == new IntPtr(-1))
+        {
+            int err = Marshal.GetLastWin32Error();
+            Logger.Log($"[{Drive.Letter}] CreateFileW({mftPath}) failed: {Win32Error(err)} (code={err})");
             return null;
+        }
+
+        Logger.Log($"[{Drive.Letter}] $MFT opened OK, handle=0x{mftHandle:X}");
 
         try
         {
@@ -68,16 +78,25 @@ public class MftReader : IDisposable
             byte[] buffer = new byte[DirectBuf];
             ulong mftIndex = 0;
             int leftover = 0;
+            long totalRead = 0;
 
             while (true)
             {
-                // CRITICAL: read into buffer starting at 'leftover', not at 0
-                // This matches Rust: ReadFile(mft_handle, &mut buffer[leftover..])
                 bool ok = Win32Api.ReadFile(
                     mftHandle, buffer, leftover, (uint)(buffer.Length - leftover), out uint bytesRead, IntPtr.Zero);
-                if (!ok || bytesRead == 0)
+                if (!ok)
+                {
+                    int err = Marshal.GetLastWin32Error();
+                    Logger.Log($"[{Drive.Letter}] ReadFile failed at offset {totalRead}: {Win32Error(err)} (code={err})");
+                    break;
+                }
+                if (bytesRead == 0)
+                {
+                    Logger.Log($"[{Drive.Letter}] ReadFile returned 0 bytes at offset {totalRead} — EOF");
                     break;
+                }
 
+                totalRead += bytesRead;
                 int total = leftover + (int)bytesRead;
                 int offset = 0;
 
@@ -93,15 +112,16 @@ public class MftReader : IDisposable
                     offset += recordSize.Value;
                 }
 
-                // Align offset down to record boundary
                 offset = total - (total % recordSize.Value);
-
                 leftover = total - offset;
                 if (leftover > 0)
                     Array.Copy(buffer, offset, buffer, 0, leftover);
+
+                if (mftIndex % 50000 == 0)
+                    Logger.Log($"[{Drive.Letter}] Progress: {mftIndex:N0} records parsed, {records.Count:N0} valid");
             }
 
-            Logger.Log($"[{Drive.Letter}] Direct scan: {records.Count} records from {mftIndex} positions");
+            Logger.Log($"[{Drive.Letter}] Direct scan: {records.Count} records from {mftIndex} positions, {totalRead:N0} bytes read");
             return new ScanResult(records, nameData);
         }
         finally
@@ -110,11 +130,14 @@ public class MftReader : IDisposable
         }
     }
 
-    /// <summary>
-    /// Fallback: FSCTL_ENUM_USN_DATA (4 MB buffer)
-    /// </summary>
+    // ------------------------------------------------------------------
+    //  Fallback: FSCTL_ENUM_USN_DATA
+    // ------------------------------------------------------------------
+
     public ScanResult Scan()
     {
+        Logger.Log($"[{Drive.Letter}] Starting FSCTL_ENUM_USN_DATA fallback...");
+
         var records = new List<CompactRecord>();
         var nameData = new List<char>();
         byte[] buffer = new byte[FallbackBuf];
@@ -127,6 +150,8 @@ public class MftReader : IDisposable
         };
 
         int enumDataSize = Marshal.SizeOf<MFT_ENUM_DATA_V0>();
+        Logger.Log($"[{Drive.Letter}] MFT_ENUM_DATA_V0 size = {enumDataSize} bytes");
+
         IntPtr enumDataPtr = Marshal.AllocHGlobal(enumDataSize);
         Marshal.StructureToPtr(enumData, enumDataPtr, false);
 
@@ -156,17 +181,17 @@ public class MftReader : IDisposable
                         }
                         if (error == 122) // ERROR_INSUFFICIENT_BUFFER
                         {
-                            Logger.Log($"[{Drive.Letter}] FSCTL_ENUM_USN_DATA: buffer too small, retrying");
+                            Logger.Log($"[{Drive.Letter}] FSCTL_ENUM_USN_DATA: buffer too small ({buffer.Length}), retrying with larger buffer");
                             buffer = new byte[buffer.Length * 2];
                             continue;
                         }
-                        Logger.Log($"[{Drive.Letter}] FSCTL_ENUM_USN_DATA failed: {Win32Error(error)}");
+                        Logger.Log($"[{Drive.Letter}] FSCTL_ENUM_USN_DATA failed (iter {iterations}): {Win32Error(error)} (code={error})");
                         break;
                     }
 
                     if (bytesReturned <= 8)
                     {
-                        Logger.Log($"[{Drive.Letter}] FSCTL: {bytesReturned} bytes, stopping");
+                        Logger.Log($"[{Drive.Letter}] FSCTL: {bytesReturned} bytes returned, stopping");
                         break;
                     }
 
@@ -226,15 +251,23 @@ public class MftReader : IDisposable
 
     private int? ReadMftRecordSize()
     {
+        Logger.Log($"[{Drive.Letter}] Reading boot sector from volume...");
         Win32Api.SetFilePointerEx(_volumeHandle, 0, out _, 0);
 
         byte[] boot = new byte[512];
         bool ok = Win32Api.ReadFile(_volumeHandle, boot, 512, out uint br, IntPtr.Zero);
         if (!ok || br < 512)
+        {
+            int err = Marshal.GetLastWin32Error();
+            Logger.Log($"[{Drive.Letter}] Boot sector read failed: {Win32Error(err)} (code={err})");
             return null;
+        }
 
         if (boot[3] != 'N' || boot[4] != 'T' || boot[5] != 'F' || boot[6] != 'S')
+        {
+            Logger.Log($"[{Drive.Letter}] Not NTFS (missing signature at offset 3)");
             return null;
+        }
 
         ushort bytesPerSector = BinaryPrimitives.ReadUInt16LittleEndian(boot.AsSpan(0x0B, 2));
         byte sectorsPerCluster = boot[0x0D];
@@ -243,14 +276,10 @@ public class MftReader : IDisposable
         sbyte raw = (sbyte)boot[0x40];
         int recordSize = raw > 0 ? raw * clusterSize : 1 << (-raw);
 
-        Logger.Log($"[{Drive.Letter}] Boot: bps={bytesPerSector}, spc={sectorsPerCluster}, clusterSize={clusterSize}, recordSize={recordSize}");
+        Logger.Log($"[{Drive.Letter}] Boot OK: bps={bytesPerSector}, spc={sectorsPerCluster}, clusterSize={clusterSize}, recordSize={recordSize}");
         return recordSize;
     }
 
-    /// <summary>
-    /// Apply NTFS multi-sector fixup. RESTORES bytes from fixup array.
-    /// Matches Rust apply_fixup() exactly.
-    /// </summary>
     private static bool ApplyFixup(byte[] record, int offset, int recordSize)
     {
         if (recordSize < 48 || record[offset] != 'F' || record[offset + 1] != 'I'
@@ -274,7 +303,6 @@ public class MftReader : IDisposable
             if (record[offset + end] != check0 || record[offset + end + 1] != check1)
                 return false;
 
-            // RESTORE the real bytes from the fixup array
             record[offset + end] = record[offset + fixupOff + i * 2];
             record[offset + end + 1] = record[offset + fixupOff + i * 2 + 1];
         }
@@ -282,9 +310,6 @@ public class MftReader : IDisposable
         return true;
     }
 
-    /// <summary>
-    /// Parse one MFT FILE record. Matches Rust parse_file_record() exactly.
-    /// </summary>
     private static void ParseFileRecord(
         ReadOnlySpan<byte> record,
         ulong mftIndex,
@@ -292,7 +317,7 @@ public class MftReader : IDisposable
         List<char> nameData)
     {
         ushort flags = BinaryPrimitives.ReadUInt16LittleEndian(record.Slice(0x16, 2));
-        if ((flags & 0x01) == 0) return; // Record not in use
+        if ((flags & 0x01) == 0) return;
 
         bool isDir = (flags & 0x02) != 0;
         ushort seq = BinaryPrimitives.ReadUInt16LittleEndian(record.Slice(0x10, 2));
@@ -312,7 +337,7 @@ public class MftReader : IDisposable
             uint alen = BinaryPrimitives.ReadUInt32LittleEndian(record.Slice(aoff + 4, 4));
             if (alen == 0 || aoff + alen > record.Length) break;
 
-            if (atype == 0x30 && record[aoff + 8] == 0) // $FILE_NAME, resident
+            if (atype == 0x30 && record[aoff + 8] == 0)
             {
                 uint vlen = BinaryPrimitives.ReadUInt32LittleEndian(record.Slice(aoff + 16, 4));
                 ushort voff = BinaryPrimitives.ReadUInt16LittleEndian(record.Slice(aoff + 20, 2));
@@ -326,7 +351,7 @@ public class MftReader : IDisposable
 
                     if (vs + 66 + nlen * 2 <= record.Length)
                     {
-                        if (ns == 2) // DOS 8.3 name — skip
+                        if (ns == 2)
                         {
                             aoff += (int)alen;
                             continue;
@@ -334,9 +359,9 @@ public class MftReader : IDisposable
 
                         byte priority = ns switch
                         {
-                            1 => 0, // Win32
-                            3 => 1, // Win32 + DOS
-                            0 => 2, // POSIX
+                            1 => 0,
+                            3 => 1,
+                            0 => 2,
                             _ => 3,
                         };