Upload FastSeekWpf/Core/MftReader.cs

FastSeekWpf/Core/MftReader.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.IO;
 using System.Runtime.InteropServices;
 using FastSeekWpf.NativeInterop;
@@ -31,13 +32,17 @@ public class MftReader : IDisposable
             IntPtr.Zero);
 
         if (_handle == new IntPtr(-1))
-            throw new IOException($"Failed to open drive {drive.Letter}:");
+        {
+            int err = Marshal.GetLastWin32Error();
+            throw new IOException($"Failed to open drive {drive.Letter}: {Win32Error(err)}");
+        }
     }
 
-    public ScanResult? ScanDirect()
+    public ScanResult ScanDirect()
     {
         int? recordSize = ReadMftRecordSize();
-        if (recordSize == null) return null;
+        if (recordSize == null)
+            throw new IOException("Could not read boot sector / determine MFT record size.");
 
         string mftPath = $"{_drive.Root}$MFT";
         IntPtr mftHandle = Win32Api.CreateFileW(
@@ -50,7 +55,10 @@ public class MftReader : IDisposable
             IntPtr.Zero);
 
         if (mftHandle == new IntPtr(-1))
-            return null;
+        {
+            int err = Marshal.GetLastWin32Error();
+            throw new IOException($"Could not open {mftPath}: {Win32Error(err)}");
+        }
 
         try
         {
@@ -59,12 +67,19 @@ public class MftReader : IDisposable
             byte[] buffer = new byte[DirectBuf];
             ulong mftIndex = 0;
             int leftover = 0;
+            long totalBytesRead = 0;
 
             while (true)
             {
                 bool ok = Win32Api.ReadFile(mftHandle, buffer, (uint)(buffer.Length - leftover), out uint bytesRead, IntPtr.Zero);
-                if (!ok || bytesRead == 0) break;
+                if (!ok)
+                {
+                    int err = Marshal.GetLastWin32Error();
+                    throw new IOException($"ReadFile({mftPath}) failed at offset {totalBytesRead}: {Win32Error(err)}");
+                }
+                if (bytesRead == 0) break;
 
+                totalBytesRead += bytesRead;
                 int total = leftover + (int)bytesRead;
                 int offset = 0;
 
@@ -111,8 +126,10 @@ public class MftReader : IDisposable
 
         try
         {
+            int iterations = 0;
             while (true)
             {
+                iterations++;
                 IntPtr bufferPtr = Marshal.AllocHGlobal(buffer.Length);
                 try
                 {
@@ -126,8 +143,12 @@ public class MftReader : IDisposable
                     if (!ok)
                     {
                         int error = Marshal.GetLastWin32Error();
-                        if ((uint)error == 0x26) break;
-                        break;
+                        if ((uint)error == 0x26) // ERROR_HANDLE_EOF — normal end
+                            break;
+
+                        throw new IOException(
+                            $"FSCTL_ENUM_USN_DATA failed (iter {iterations}): {Win32Error(error)}. " +
+                            $"StartFileReferenceNumber={enumData.StartFileReferenceNumber}");
                     }
 
                     if (bytesReturned <= 8) break;
@@ -171,36 +192,53 @@ public class MftReader : IDisposable
                     Marshal.FreeHGlobal(bufferPtr);
                 }
             }
+
+            return new ScanResult(records, nameData);
         }
         finally
         {
             Marshal.FreeHGlobal(enumDataPtr);
         }
-
-        return new ScanResult(records, nameData);
     }
 
     private int? ReadMftRecordSize()
     {
         bool ok = Win32Api.SetFilePointerEx(_handle, 0, out _, 0);
-        if (!ok) return null;
+        if (!ok)
+        {
+            int err = Marshal.GetLastWin32Error();
+            Logger.Log($"ReadMftRecordSize: SetFilePointerEx failed: {Win32Error(err)}");
+            return null;
+        }
 
         byte[] boot = new byte[512];
         ok = Win32Api.ReadFile(_handle, boot, 512, out uint br, IntPtr.Zero);
-        if (!ok || br < 512) return null;
+        if (!ok || br < 512)
+        {
+            int err = Marshal.GetLastWin32Error();
+            Logger.Log($"ReadMftRecordSize: ReadFile failed (ok={ok}, read={br}): {Win32Error(err)}");
+            return null;
+        }
 
         if (boot[3] != 'N' || boot[4] != 'T' || boot[5] != 'F' || boot[6] != 'S')
+        {
+            Logger.Log("ReadMftRecordSize: Not an NTFS boot sector (missing 'NTFS' signature)");
             return null;
+        }
 
         ushort bytesPerSector = BinaryPrimitives.ReadUInt16LittleEndian(new ReadOnlySpan<byte>(boot, 0x0B, 2));
         byte sectorsPerCluster = boot[0x0D];
         int clusterSize = bytesPerSector * sectorsPerCluster;
 
         sbyte raw = (sbyte)boot[0x40];
+        int recordSize;
         if (raw > 0)
-            return raw * clusterSize;
+            recordSize = raw * clusterSize;
         else
-            return 1 << (-raw);
+            recordSize = 1 << (-raw);
+
+        Logger.Log($"ReadMftRecordSize: bytesPerSector={bytesPerSector}, sectorsPerCluster={sectorsPerCluster}, clusterSize={clusterSize}, raw={raw}, recordSize={recordSize}");
+        return recordSize;
     }
 
     private static bool ApplyFixup(ReadOnlySpan<byte> record, int recordSize)
@@ -315,6 +353,18 @@ public class MftReader : IDisposable
         }
     }
 
+    private static string Win32Error(int code)
+    {
+        try
+        {
+            return new Win32Exception(code).Message;
+        }
+        catch
+        {
+            return $"error {code} (0x{code:X})";
+        }
+    }
+
     public void Dispose()
     {
         if (!_disposed)