Changeset 2189

Timestamp:

6/18/2010 2:36:03 PM (3 years ago)

Author:

lowjoel

Message:

• Define a VolumeStream? class which is a FileStream? customised for raw volume access. This results in the VolumeLock? class being merged into the VolumeStream? class, automatically handling locking and unlocking of volumes.
• Change all internal OpenHandle? functions to private, since they should not be callable from outside the class.
• Perform error checking in OpenHandle? so that even callers of OpenHandle? gets error checking.

Location:

trunk/eraser

Files:

• Eraser.DefaultPlugins/FileSystems/Fat.cs (modified) (1 diff)
• Eraser.Util/NtfsApi.cs (modified) (1 diff)
• Eraser.Util/VolumeInfo.cs (modified) (5 diffs)

trunk/eraser/Eraser.DefaultPlugins/FileSystems/Fat.cs

@@ -89 +89 @@
                 try
                 {
-                    using (VolumeLock volumeLock = info.LockVolume(stream))
+                    while (eraseQueue.Count != 0)
                     {
-                        while (eraseQueue.Count != 0)
-                        {
-                            if (callback != null)
-                                callback(directoriesCleaned, directoriesCleaned + eraseQueue.Count);
+                        if (callback != null)
+                            callback(directoriesCleaned, directoriesCleaned + eraseQueue.Count);
 
-                            FatDirectoryBase currentDir = api.LoadDirectory(eraseQueue[0].FullName);
-                            eraseQueue.RemoveAt(0);
+                        FatDirectoryBase currentDir = api.LoadDirectory(eraseQueue[0].FullName);
+                        eraseQueue.RemoveAt(0);
 
-                            //Queue the subfolders in this directory
-                            foreach (KeyValuePair<string, FatDirectoryEntry> entry in currentDir.Items)
-                                if (entry.Value.EntryType == FatDirectoryEntryType.Directory)
-                                {
-                                    //Check that we don't have the same cluster queued twice (e.g. for
-                                    //long/8.3 file names)
-                                    if (eraseQueueClusters.Contains(entry.Value.Cluster))
-                                        continue;
+                        //Queue the subfolders in this directory
+                        foreach (KeyValuePair<string, FatDirectoryEntry> entry in currentDir.Items)
+                            if (entry.Value.EntryType == FatDirectoryEntryType.Directory)
+                            {
+                                //Check that we don't have the same cluster queued twice (e.g. for
+                                //long/8.3 file names)
+                                if (eraseQueueClusters.Contains(entry.Value.Cluster))
+                                    continue;
 
-                                    eraseQueueClusters.Add(entry.Value.Cluster);
-                                    eraseQueue.Add(entry.Value);
-                                }
+                                eraseQueueClusters.Add(entry.Value.Cluster);
+                                eraseQueue.Add(entry.Value);
+                            }
 
-                            currentDir.ClearDeletedEntries();
-                            ++directoriesCleaned;
-                        }
+                        currentDir.ClearDeletedEntries();
+                        ++directoriesCleaned;
                     }
                 }

trunk/eraser/Eraser.Util/NtfsApi.cs

@@ -69 +69 @@
         internal static NativeMethods.NTFS_VOLUME_DATA_BUFFER? GetNtfsVolumeData(VolumeInfo volume)
         {
-            using (SafeFileHandle volumeHandle = volume.OpenHandle(
-                FileAccess.Read, FileShare.ReadWrite, FileOptions.None))
+            using (FileStream stream = volume.Open(FileAccess.Read, FileShare.ReadWrite,
+                FileOptions.None))
+            using (SafeFileHandle handle = stream.SafeFileHandle)
             {
-                if (volumeHandle.IsInvalid)
-                    return null;
-
                 uint resultSize = 0;
                 NativeMethods.NTFS_VOLUME_DATA_BUFFER volumeData =
                     new NativeMethods.NTFS_VOLUME_DATA_BUFFER();
-                if (NativeMethods.DeviceIoControl(volumeHandle,
+                if (NativeMethods.DeviceIoControl(handle,
                     NativeMethods.FSCTL_GET_NTFS_VOLUME_DATA, IntPtr.Zero, 0, out volumeData,
                     (uint)Marshal.SizeOf(volumeData), out resultSize, IntPtr.Zero))

trunk/eraser/Eraser.Util/VolumeInfo.cs

@@ -635 +635 @@
         public FileStream Open(FileAccess access, FileShare share, FileOptions options)
         {
-            SafeFileHandle handle = OpenHandle(access, share, options);
-
-            //Check that the handle is valid
-            if (handle.IsInvalid)
-            {
-                int errorCode = Marshal.GetLastWin32Error();
-                handle.Close();
-                throw Win32ErrorCode.GetExceptionForWin32Error(errorCode);
-            }
-
-            //Return the FileStream
-            return new FileStream(handle, access);
-        }
-
-        internal SafeFileHandle OpenHandle(FileAccess access, FileShare share, FileOptions options)
+            return new VolumeStream(this, OpenHandle(access, share, options), access);
+        }
+
+        private SafeFileHandle OpenHandle(FileAccess access, FileShare share, FileOptions options)
         {
             //Access mode
@@ -669 +658 @@
         }
 
-        internal SafeFileHandle OpenHandle(uint access, FileShare share, FileOptions options)
+        private SafeFileHandle OpenHandle(uint access, FileShare share, FileOptions options)
         {
             //Sharing mode
@@ -683 +672 @@
             if (openPath.Length > 0 && openPath[openPath.Length - 1] == '\\')
                 openPath = openPath.Remove(openPath.Length - 1);
-            return NativeMethods.CreateFile(openPath, access, (uint)share, IntPtr.Zero,
-                (uint)FileMode.Open, (uint)options, IntPtr.Zero);
+
+            SafeFileHandle result = NativeMethods.CreateFile(openPath, access, (uint)share,
+                IntPtr.Zero, (uint)FileMode.Open, (uint)options, IntPtr.Zero);
+
+            //Check that the handle is valid
+            if (result.IsInvalid)
+            {
+                int errorCode = Marshal.GetLastWin32Error();
+                result.Close();
+                throw Win32ErrorCode.GetExceptionForWin32Error(errorCode);
+            }
+
+            return result;
         }
 
@@ -739 +739 @@
             return VolumeId.GetHashCode();
         }
-
-        public VolumeLock LockVolume(FileStream stream)
-        {
-            return new VolumeLock(stream);
-        }
     }
 
-    public sealed class VolumeLock : IDisposable
+    public class VolumeStream : FileStream
     {
-        internal VolumeLock(FileStream stream)
-        {
+        internal VolumeStream(VolumeInfo volume, SafeFileHandle handle, FileAccess access)
+            : base(handle, access)
+        {
+            Volume = volume;
+            Access = access;
+
+            if (Access == FileAccess.Write || Access == FileAccess.ReadWrite)
+                LockVolume();
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (Access == FileAccess.Write || Access == FileAccess.ReadWrite)
+                UnlockVolume();
+            base.Dispose(disposing);
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new InvalidOperationException();
+        }
+
+        public override long Length
+        {
+            get
+            {
+                if (IsLocked)
+                    return LengthCache;
+                return Volume.TotalSize;
+            }
+        }
+
+        /// <summary>
+        /// Temporarily stores the length of the disk while the disk is locked.
+        /// </summary>
+        private long LengthCache;
+
+        private void LockVolume()
+        {
+            LengthCache = Length;
             uint result = 0;
-            for (int i = 0; !NativeMethods.DeviceIoControl(stream.SafeFileHandle,
+            for (int i = 0; !NativeMethods.DeviceIoControl(SafeFileHandle,
                     NativeMethods.FSCTL_LOCK_VOLUME, IntPtr.Zero, 0, IntPtr.Zero,
                     0, out result, IntPtr.Zero); ++i)
@@ -760 +793 @@
             }
 
-            Stream = stream;
-        }
-
-        ~VolumeLock()
-        {
-            Dispose(false);
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "disposing")]
-        private void Dispose(bool disposing)
-        {
-            if (Stream == null)
-                return;
-
+            IsLocked = true;
+        }
+
+        private void UnlockVolume()
+        {
             //Flush the contents of the buffer to disk since after we unlock the volume
             //we can no longer write to the volume.
-            Stream.Flush();
+            Flush();
 
             uint result = 0;
-            if (!NativeMethods.DeviceIoControl(Stream.SafeFileHandle,
-                NativeMethods.FSCTL_UNLOCK_VOLUME, IntPtr.Zero, 0, IntPtr.Zero,
-                0, out result, IntPtr.Zero))
+            if (!NativeMethods.DeviceIoControl(SafeFileHandle, NativeMethods.FSCTL_UNLOCK_VOLUME,
+                IntPtr.Zero, 0, IntPtr.Zero, 0, out result, IntPtr.Zero))
             {
                 throw new IOException("Could not unlock volume.");
             }
 
-            //Set the stream to null so that we won't run this function again.
-            Stream = null;
-        }
-
-        private FileStream Stream;
+            LengthCache = 0;
+            IsLocked = false;
+        }
+
+        /// <summary>
+        /// Reflects whether the current handle has exclusive access to the volume.
+        /// </summary>
+        private bool IsLocked;
+
+        /// <summary>
+        /// The <see cref="VolumeInfo"/> object this stream is encapsulating.
+        /// </summary>
+        private VolumeInfo Volume;
+
+        /// <summary>
+        /// The access parameter for this stream.
+        /// </summary>
+        private FileAccess Access;
     }