source: trunk/eraser/Eraser.Util/VolumeInfo.cs @ 2206

/* 
 * $Id$
 * Copyright 2008-2010 The Eraser Project
 * Original Author: Joel Low <lowjoel@users.sourceforge.net>
 * Modified By:
 * 
 * This file is part of Eraser.
 * 
 * Eraser is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 * 
 * Eraser is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 * 
 * A copy of the GNU General Public License can be found at
 * <http://www.gnu.org/licenses/>.
 */

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;

using System.Runtime.InteropServices;
using System.ComponentModel;
using System.IO;
using Microsoft.Win32.SafeHandles;
using System.Collections.ObjectModel;

namespace Eraser.Util
{
    public class VolumeInfo
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="volumeId">The ID of the volume, either in the form
        /// "\\?\Volume{GUID}\" or as a valid UNC path.</param>
        public VolumeInfo(string volumeId)
        {
            //We only accept UNC paths as well as volume identifiers.
            if (!(volumeId.StartsWith("\\\\?\\") || volumeId.StartsWith("\\\\")))
                throw new ArgumentException("The volumeId parameter only accepts volume GUID " +
                    "and UNC paths", "volumeId");

            //Verify that the path ends with a trailing backslash
            if (!volumeId.EndsWith("\\"))
                throw new ArgumentException("The volumeId parameter must end with a trailing " +
                    "backslash.", "volumeId");

            //Set the volume ID
            VolumeId = volumeId;

            //Fill up the remaining members of the structure: file system, label, etc.
            StringBuilder volumeName = new StringBuilder(NativeMethods.MaxPath * sizeof(char)),
                fileSystemName = new StringBuilder(NativeMethods.MaxPath * sizeof(char));
            uint serialNumber, maxComponentLength, filesystemFlags;
            if (NativeMethods.GetVolumeInformation(volumeId, volumeName, NativeMethods.MaxPath,
                out serialNumber, out maxComponentLength, out filesystemFlags, fileSystemName,
                NativeMethods.MaxPath))
            {
                IsReady = true;
            }

            //If GetVolumeInformation returns zero some of the information may
            //have been stored, so we just try to extract it.
            VolumeLabel = volumeName.Length == 0 ? null : volumeName.ToString();
            VolumeFormat = fileSystemName.Length == 0 ? null : fileSystemName.ToString();

            //Determine whether it is FAT12 or FAT16
            if (VolumeFormat == "FAT")
            {
                uint clusterSize, sectorSize, freeClusters, totalClusters;
                if (NativeMethods.GetDiskFreeSpace(VolumeId, out clusterSize,
                    out sectorSize, out freeClusters, out totalClusters))
                {
                    if (totalClusters <= 0xFF0)
                        VolumeFormat += "12";
                    else
                        VolumeFormat += "16";
                }
            }
        }

        /// <summary>
        /// Gets the mountpoints associated with the current volume.
        /// </summary>
        /// <returns>A list of volume mount points for the current volume.</returns>
        private List<string> GetLocalVolumeMountPoints()
        {
            return new List<string>(NativeMethods.GetVolumePathNamesForVolumeName(VolumeId));
        }

        /// <summary>
        /// Gets the mountpoints associated with the network share.
        /// </summary>
        /// <returns>A list of network mount points for the given network share.</returns>
        private List<string> GetNetworkMountPoints()
        {
            List<string> result = new List<string>();
            foreach (KeyValuePair<string, string> mountpoint in GetNetworkDrivesInternal())
                if (mountpoint.Value == VolumeId)
                    result.Add(mountpoint.Key);

            return result;
        }

        /// <summary>
        /// Lists all the volumes in the system.
        /// </summary>
        /// <returns>Returns a list of volumes representing all volumes present in
        /// the system.</returns>
        public static IList<VolumeInfo> Volumes
        {
            get
            {
                List<VolumeInfo> result = new List<VolumeInfo>();
                StringBuilder nextVolume = new StringBuilder(NativeMethods.LongPath * sizeof(char));
                SafeHandle handle = NativeMethods.FindFirstVolume(nextVolume, NativeMethods.LongPath);
                if (handle.IsInvalid)
                    return result;

                try
                {
                    //Iterate over the volume mountpoints
                    do
                        result.Add(new VolumeInfo(nextVolume.ToString()));
                    while (NativeMethods.FindNextVolume(handle, nextVolume, NativeMethods.LongPath));
                }
                finally
                {
                    //Close the handle
                    NativeMethods.FindVolumeClose(handle);
                }

                return result.AsReadOnly();
            }
        }

        /// <summary>
        /// Lists all mounted network drives on the current computer.
        /// </summary>
        public static IList<VolumeInfo> NetworkDrives
        {
            get
            {
                Dictionary<string, string> localToRemote = GetNetworkDrivesInternal();
                Dictionary<string, string> remoteToLocal = new Dictionary<string, string>();

                //Flip the dictionary to be indexed by value so we can map UNC paths to
                //drive letters/mount points.
                foreach (KeyValuePair<string, string> mountpoint in localToRemote)
                {
                    //If there are no UNC path for this current mount point, we just add it.
                    if (!remoteToLocal.ContainsKey(mountpoint.Value))
                        remoteToLocal.Add(mountpoint.Value, mountpoint.Key);

                    //Otherwise, we try to maintain the shortest path.
                    else if (remoteToLocal[mountpoint.Value].Length > mountpoint.Key.Length)
                        remoteToLocal[mountpoint.Value] = mountpoint.Key;
                }

                //Return the list of UNC paths mounted.
                List<VolumeInfo> result = new List<VolumeInfo>();
                foreach (string uncPath in remoteToLocal.Keys)
                    result.Add(new VolumeInfo(uncPath));

                return result.AsReadOnly();
            }
        }

        /// <summary>
        /// Lists all mounted network drives on the current computer. The key is
        /// the local path, the value is the remote path.
        /// </summary>
        private static Dictionary<string, string> GetNetworkDrivesInternal()
        {
            Dictionary<string, string> result = new Dictionary<string, string>();

            //Open an enumeration handle to list mount points.
            IntPtr enumHandle;
            uint errorCode = NativeMethods.WNetOpenEnum(NativeMethods.RESOURCE_CONNECTED,
                NativeMethods.RESOURCETYPE_DISK, 0, IntPtr.Zero, out enumHandle);
            if (errorCode != Win32ErrorCode.Success)
                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());

            try
            {
                int resultBufferCount = 32;
                int resultBufferSize = resultBufferCount *
                    Marshal.SizeOf(typeof(NativeMethods.NETRESOURCE));
                IntPtr resultBuffer = Marshal.AllocHGlobal(resultBufferSize);

                try
                {
                    for ( ; ; )
                    {
                        uint resultBufferStored = (uint)resultBufferCount;
                        uint resultBufferRequiredSize = (uint)resultBufferSize;
                        errorCode = NativeMethods.WNetEnumResource(enumHandle,
                            ref resultBufferStored, resultBuffer,
                            ref resultBufferRequiredSize);

                        if (errorCode == Win32ErrorCode.NoMoreItems)
                            break;
                        else if (errorCode != Win32ErrorCode.Success)
                            throw new Win32Exception((int)errorCode);

                        unsafe
                        {
                            //Marshal the memory block to managed structures.
                            byte* pointer = (byte*)resultBuffer.ToPointer();

                            for (uint i = 0; i < resultBufferStored;
                                ++i, pointer += Marshal.SizeOf(typeof(NativeMethods.NETRESOURCE)))
                            {
                                NativeMethods.NETRESOURCE resource =
                                    (NativeMethods.NETRESOURCE)Marshal.PtrToStructure(
                                        (IntPtr)pointer, typeof(NativeMethods.NETRESOURCE));

                                //Skip all UNC paths without a local mount point
                                if (resource.lpLocalName == null)
                                    continue;

                                //Ensure that the path in the resource structure ends with a trailing
                                //backslash as out volume ID ends with one.
                                if (string.IsNullOrEmpty(resource.lpRemoteName))
                                    continue;
                                if (resource.lpRemoteName[resource.lpRemoteName.Length - 1] != '\\')
                                    resource.lpRemoteName += '\\';
                                result.Add(resource.lpLocalName, resource.lpRemoteName);
                            }
                        }
                    }
                }
                finally
                {
                    Marshal.FreeHGlobal(resultBuffer);
                }
            }
            finally
            {
                NativeMethods.WNetCloseEnum(enumHandle);
            }

            return result;
        }

        /// <summary>
        /// Creates a Volume object from its mountpoint.
        /// </summary>
        /// <param name="mountPoint">The path to the mountpoint.</param>
        /// <returns>The volume object if such a volume exists, or an exception
        /// is thrown.</returns>
        public static VolumeInfo FromMountPoint(string mountPoint)
        {
            //Verify that the mountpoint given exists; if it doesn't we'll raise
            //a DirectoryNotFound exception.
            DirectoryInfo mountpointDir = new DirectoryInfo(mountPoint);
            if (!mountpointDir.Exists)
                throw new DirectoryNotFoundException();

            do
            {
                //Ensure that the current path has a trailing backslash
                string currentDir = mountpointDir.FullName;
                if (currentDir.Length > 0 && currentDir[currentDir.Length - 1] != '\\')
                    currentDir += '\\';

                //The path cannot be empty.
                if (string.IsNullOrEmpty(currentDir))
                    throw new DirectoryNotFoundException();

                //Get the type of the drive
                DriveType driveType = (DriveType)NativeMethods.GetDriveType(currentDir);

                //We do different things for different kinds of drives. Network drives
                //will need us to resolve the drive to a UNC path. Local drives will
                //be resolved to a volume GUID
                StringBuilder volumeID = new StringBuilder(NativeMethods.MaxPath);
                if (driveType == DriveType.Network)
                {
                    //If the current directory is a UNC path, then return the VolumeInfo instance
                    //directly
                    if (currentDir.Substring(0, 2) == "\\\\" && currentDir.IndexOf('\\', 2) != -1)
                        return new VolumeInfo(currentDir);

                    //Otherwise, resolve the mountpoint to a UNC path
                    uint bufferCapacity = (uint)volumeID.Capacity;
                    uint errorCode = NativeMethods.WNetGetConnection(
                        currentDir.Substring(0, currentDir.Length - 1),
                        volumeID, ref bufferCapacity);

                    switch (errorCode)
                    {
                        case Win32ErrorCode.Success:
                            return new VolumeInfo(volumeID.ToString() + '\\');

                        case Win32ErrorCode.BadDevice: //Path is not a network share
                            break;

                        default:
                            throw new Win32Exception((int)errorCode);
                    }
                }
                else
                {
                    if (!NativeMethods.GetVolumeNameForVolumeMountPoint(currentDir, volumeID, 50))
                    {
                        int errorCode = Marshal.GetLastWin32Error();
                        switch (errorCode)
                        {
                            case Win32ErrorCode.InvalidFunction:
                            case Win32ErrorCode.FileNotFound:
                            case Win32ErrorCode.PathNotFound:
                            case Win32ErrorCode.NotAReparsePoint:
                                break;
                            default:
                                throw Win32ErrorCode.GetExceptionForWin32Error(
                                    Marshal.GetLastWin32Error());
                        }
                    }
                    else
                    {
                        return new VolumeInfo(volumeID.ToString());
                    }
                }

                mountpointDir = mountpointDir.Parent;
            }
            while (mountpointDir != null);

            throw Win32ErrorCode.GetExceptionForWin32Error(Win32ErrorCode.NotAReparsePoint);
        }

        /// <summary>
        /// Returns the volume identifier as would be returned from FindFirstVolume.
        /// </summary>
        public string VolumeId { get; private set; }

        /// <summary>
        /// Gets or sets the volume label of a drive.
        /// </summary>
        public string VolumeLabel { get; private set; }

        /// <summary>
        /// Gets the name of the file system, such as NTFS or FAT32.
        /// </summary>
        public string VolumeFormat { get; private set; }

        /// <summary>
        /// Gets the drive type; returns one of the System.IO.DriveType values.
        /// </summary>
        public DriveType VolumeType
        {
            get
            {
                return (DriveType)NativeMethods.GetDriveType(VolumeId);
            }
        }

        /// <summary>
        /// Determines the cluster size of the current volume.
        /// </summary>
        public int ClusterSize
        {
            get
            {
                if (!IsReady)
                    throw new InvalidOperationException("The volume has not been mounted or is not " +
                        "currently ready.");

                uint clusterSize, sectorSize, freeClusters, totalClusters;
                if (NativeMethods.GetDiskFreeSpace(VolumeId, out clusterSize,
                    out sectorSize, out freeClusters, out totalClusters))
                {
                    return (int)(clusterSize * sectorSize);
                }

                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());
            }
        }

        /// <summary>
        /// Determines the sector size of the current volume.
        /// </summary>
        public int SectorSize
        {
            get
            {
                if (!IsReady)
                    throw new InvalidOperationException("The volume has not been mounted or is not " +
                        "currently ready.");

                uint clusterSize, sectorSize, freeClusters, totalClusters;
                if (NativeMethods.GetDiskFreeSpace(VolumeId, out clusterSize,
                    out sectorSize, out freeClusters, out totalClusters))
                {
                    return (int)sectorSize;
                }

                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());
            }
        }

        /// <summary>
        /// Checks if the current user has disk quotas on the current volume.
        /// </summary>
        public bool HasQuota
        {
            get
            {
                ulong freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes;
                if (NativeMethods.GetDiskFreeSpaceEx(VolumeId, out freeBytesAvailable,
                    out totalNumberOfBytes, out totalNumberOfFreeBytes))
                {
                    return totalNumberOfFreeBytes != freeBytesAvailable;
                }
                else if (Marshal.GetLastWin32Error() == Win32ErrorCode.NotReady)
                {
                    //For the lack of more appropriate responses.
                    return false;
                }

                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());
            }
        }

        /// <summary>
        /// Gets a value indicating whether a drive is ready.
        /// </summary>
        public bool IsReady { get; private set; }

        /// <summary>
        /// Gets the total amount of free space available on a drive.
        /// </summary>
        public long TotalFreeSpace
        {
            get
            {
                if (!IsReady)
                    throw new InvalidOperationException("The volume has not been mounted or is not " +
                        "currently ready.");

                ulong result, dummy;
                if (NativeMethods.GetDiskFreeSpaceEx(VolumeId, out dummy, out dummy, out result))
                {
                    return (long)result;
                }

                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());
            }
        }
        
        /// <summary>
        /// Gets the total size of storage space on a drive.
        /// </summary>
        public long TotalSize
        {
            get
            {
                ulong result, dummy;
                if (NativeMethods.GetDiskFreeSpaceEx(VolumeId, out dummy, out result, out dummy))
                {
                    return (long)result;
                }

                //Try the alternative method
                using (SafeFileHandle handle = OpenHandle(NativeMethods.GENERIC_READ,
                    FileShare.ReadWrite, FileOptions.None))
                {
                    if (handle.IsInvalid)
                        throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());

                    long result2;
                    uint returned = 0;
                    if (NativeMethods.DeviceIoControl(handle,
                        NativeMethods.IOCTL_DISK_GET_LENGTH_INFO, IntPtr.Zero, 0, out result2,
                        sizeof(long), out returned, IntPtr.Zero))
                    {
                        return result2;
                    }
                }

                //Otherwise, throw
                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());
            }
        }

        /// <summary>
        /// Indicates the amount of available free space on a drive.
        /// </summary>
        public long AvailableFreeSpace
        {
            get
            {
                if (!IsReady)
                    throw new InvalidOperationException("The volume has not been mounted or is not " +
                        "currently ready.");

                ulong result, dummy;
                if (NativeMethods.GetDiskFreeSpaceEx(VolumeId, out result, out dummy, out dummy))
                {
                    return (long)result;
                }

                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());
            }
        }

        /// <summary>
        /// Retrieves all mountpoints in the current volume, if the current volume
        /// contains volume mountpoints.
        /// </summary>
        public IList<VolumeInfo> MountedVolumes
        {
            get
            {
                if (!IsReady)
                    throw new InvalidOperationException("The volume has not been mounted or is not " +
                        "currently ready.");

                List<VolumeInfo> result = new List<VolumeInfo>();
                StringBuilder nextMountpoint = new StringBuilder(NativeMethods.LongPath * sizeof(char));

                SafeHandle handle = NativeMethods.FindFirstVolumeMountPoint(VolumeId,
                    nextMountpoint, NativeMethods.LongPath);
                if (handle.IsInvalid)
                    return result;

                try
                {
                    //Iterate over the volume mountpoints
                    while (NativeMethods.FindNextVolumeMountPoint(handle, nextMountpoint,
                        NativeMethods.LongPath))
                    {
                        result.Add(new VolumeInfo(nextMountpoint.ToString()));
                    }
                }
                finally
                {
                    //Close the handle
                    NativeMethods.FindVolumeMountPointClose(handle);
                }

                return result.AsReadOnly();
            }
        }

        /// <summary>
        /// The various mountpoints to the root of the volume. This list contains
        /// paths which may be a drive or a mountpoint. Every string includes the
        /// trailing backslash.
        /// </summary>
        public IList<DirectoryInfo> MountPoints
        {
            get
            {
                List<string> paths = VolumeType == DriveType.Network ?
                    GetNetworkMountPoints() : GetLocalVolumeMountPoints();
                return new List<DirectoryInfo>(
                    paths.Select(x => new DirectoryInfo(x))).AsReadOnly();
            }
        }

        /// <summary>
        /// Gets whether the current volume is mounted at any place.
        /// </summary>
        public bool IsMounted
        {
            get { return MountPoints.Count != 0; }
        }

        /// <summary>
        /// Gets the Physical Drive this Volume is in.
        /// </summary>
        public PhysicalDriveInfo PhysicalDrive
        {
            get
            {
                IntPtr buffer = IntPtr.Zero;
                List<NativeMethods.DISK_EXTENT> extents = new List<NativeMethods.DISK_EXTENT>();
                SafeFileHandle handle = OpenHandle(FileAccess.Read, FileShare.ReadWrite,
                    FileOptions.None);

                try
                {
                    uint returnSize = 0;
                    int bufferSize = Marshal.SizeOf(typeof(NativeMethods.VOLUME_DISK_EXTENTS));
                    buffer = Marshal.AllocHGlobal(bufferSize);
                    NativeMethods.VOLUME_DISK_EXTENTS header;

                    if (!NativeMethods.DeviceIoControl(handle,
                        NativeMethods.IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, IntPtr.Zero, 0,
                        buffer, (uint)bufferSize, out returnSize, IntPtr.Zero))
                    {
                        int error = Marshal.GetLastWin32Error();
                        if (error != Win32ErrorCode.InsufficientBuffer)
                            throw Win32ErrorCode.GetExceptionForWin32Error(error);

                        //Calculate the size of the buffer required
                        header = (NativeMethods.VOLUME_DISK_EXTENTS)
                            Marshal.PtrToStructure(buffer,
                                typeof(NativeMethods.VOLUME_DISK_EXTENTS));
                        Marshal.FreeHGlobal(buffer);
                        bufferSize += (int)(header.NumberOfDiskExtents - 1) *
                            Marshal.SizeOf(typeof(NativeMethods.DISK_EXTENT));
                        buffer = Marshal.AllocHGlobal(bufferSize);

                        if (!NativeMethods.DeviceIoControl(handle,
                            NativeMethods.IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, IntPtr.Zero, 0,
                            buffer, (uint)bufferSize, out returnSize, IntPtr.Zero))
                        {
                            throw Win32ErrorCode.GetExceptionForWin32Error(
                                Marshal.GetLastWin32Error());
                        }
                    }

                    //Parse the structure.
                    header = (NativeMethods.VOLUME_DISK_EXTENTS)Marshal.PtrToStructure(buffer,
                        typeof(NativeMethods.VOLUME_DISK_EXTENTS));
                    extents.Add(header.Extent);

                    for (long i = 1, offset = (uint)Marshal.SizeOf(typeof(
                        NativeMethods.VOLUME_DISK_EXTENTS)); i < header.NumberOfDiskExtents;
                        ++i, offset += Marshal.SizeOf(typeof(NativeMethods.DISK_EXTENT)))
                    {
                        NativeMethods.DISK_EXTENT extent = new NativeMethods.DISK_EXTENT();
                        Marshal.PtrToStructure(new IntPtr(buffer.ToInt64() + offset), extent);
                        extents.Add(extent);
                    }
                }
                finally
                {
                    handle.Close();
                    Marshal.FreeHGlobal(buffer);
                }

                if (extents.Count == 1)
                    return new PhysicalDriveInfo((int)extents[0].DiskNumber);
                return null;
            }
        }

        /// <summary>
        /// Opens a file with read, write, or read/write access.
        /// </summary>
        /// <param name="access">A System.IO.FileAccess constant specifying whether
        /// to open the file with Read, Write, or ReadWrite file access.</param>
        /// <returns>A System.IO.FileStream object opened in the specified mode
        /// and access, unshared, and no special file options.</returns>
        public FileStream Open(FileAccess access)
        {
            return Open(access, FileShare.None, FileOptions.None);
        }

        /// <summary>
        /// Opens a file with read, write, or read/write access and the specified
        /// sharing option.
        /// </summary>
        /// <param name="access">A System.IO.FileAccess constant specifying whether
        /// to open the file with Read, Write, or ReadWrite file access.</param>
        /// <param name="share">A System.IO.FileShare constant specifying the type
        /// of access other FileStream objects have to this file.</param>
        /// <returns>A System.IO.FileStream object opened with the specified mode,
        /// access, sharing options, and no special file options.</returns>
        public FileStream Open(FileAccess access, FileShare share)
        {
            return Open(access, share, FileOptions.None);
        }

        /// <summary>
        /// Opens a file with read, write, or read/write access, the specified
        /// sharing option, and other advanced options.
        /// </summary>
        /// <param name="mode">A System.IO.FileMode constant specifying the mode
        /// (for example, Open or Append) in which to open the file.</param>
        /// <param name="access">A System.IO.FileAccess constant specifying whether
        /// to open the file with Read, Write, or ReadWrite file access.</param>
        /// <param name="share">A System.IO.FileShare constant specifying the type
        /// of access other FileStream objects have to this file.</param>
        /// <param name="options">The System.IO.FileOptions constant specifying
        /// the advanced file options to use when opening the file.</param>
        /// <returns>A System.IO.FileStream object opened with the specified mode,
        /// access, sharing options, and special file options.</returns>
        public FileStream Open(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
            uint iAccess = 0;
            switch (access)
            {
                case FileAccess.Read:
                    iAccess = NativeMethods.GENERIC_READ;
                    break;
                case FileAccess.ReadWrite:
                    iAccess = NativeMethods.GENERIC_READ | NativeMethods.GENERIC_WRITE;
                    break;
                case FileAccess.Write:
                    iAccess = NativeMethods.GENERIC_WRITE;
                    break;
            }

            return OpenHandle(iAccess, share, options);
        }

        private SafeFileHandle OpenHandle(uint access, FileShare share, FileOptions options)
        {
            //Sharing mode
            if ((share & FileShare.Inheritable) != 0)
                throw new NotSupportedException("Inheritable handles are not supported.");

            //Advanced options
            if ((options & FileOptions.Asynchronous) != 0)
                throw new NotSupportedException("Asynchronous handles are not implemented.");

            //Create the handle
            string openPath = VolumeId;
            if (openPath.Length > 0 && openPath[openPath.Length - 1] == '\\')
                openPath = openPath.Remove(openPath.Length - 1);

            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;
        }

        /// <summary>
        /// Queries the performance information for the given disk.
        /// </summary>
        public DiskPerformanceInfo Performance
        {
            get
            {
                using (SafeFileHandle handle = OpenHandle(NativeMethods.FILE_READ_ATTRIBUTES,
                    FileShare.ReadWrite, FileOptions.None))
                {
                    //This only works if the user has turned on the disk performance
                    //counters with 'diskperf -y'. These counters are off by default
                    NativeMethods.DiskPerformanceInfoInternal result =
                        new NativeMethods.DiskPerformanceInfoInternal();
                    uint bytesReturned = 0;
                    if (NativeMethods.DeviceIoControl(handle, NativeMethods.IOCTL_DISK_PERFORMANCE,
                        IntPtr.Zero, 0, out result, (uint)Marshal.SizeOf(result),
                        out bytesReturned, IntPtr.Zero))
                    {
                        return new DiskPerformanceInfo(result);
                    }

                    return null;
                }
            }
        }

        /// <summary>
        /// Gets the mount point of the volume, or the volume ID if the volume is
        /// not currently mounted.
        /// </summary>
        /// <returns>A string containing the mount point of the volume or the volume
        /// ID.</returns>
        public override string ToString()
        {
            IList<DirectoryInfo> mountPoints = MountPoints;
            return mountPoints.Count == 0 ? VolumeId : mountPoints[0].FullName;
        }

        public override bool Equals(object obj)
        {
            VolumeInfo rhs = obj as VolumeInfo;
            if (rhs == null)
                return base.Equals(obj);

            return VolumeId == rhs.VolumeId;
        }

        public override int GetHashCode()
        {
            return VolumeId.GetHashCode();
        }
    }

    public class VolumeStream : FileStream
    {
        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(SafeFileHandle,
                    NativeMethods.FSCTL_LOCK_VOLUME, IntPtr.Zero, 0, IntPtr.Zero,
                    0, out result, IntPtr.Zero); ++i)
            {
                if (i > 100)
                    throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());
                System.Threading.Thread.Sleep(100);
            }

            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.
            Flush();

            uint result = 0;
            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.");
            }

            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;
    }

    public class DiskPerformanceInfo
    {
        internal DiskPerformanceInfo(NativeMethods.DiskPerformanceInfoInternal info)
        {
            BytesRead = info.BytesRead;
            BytesWritten = info.BytesWritten;
            ReadTime = info.ReadTime;
            WriteTime = info.WriteTime;
            IdleTime = info.IdleTime;
            ReadCount = info.ReadCount;
            WriteCount = info.WriteCount;
            QueueDepth = info.QueueDepth;
            SplitCount = info.SplitCount;
            QueryTime = info.QueryTime;
            StorageDeviceNumber = info.StorageDeviceNumber;
            StorageManagerName = info.StorageManagerName;
        }

        public long BytesRead { get; private set; }
        public long BytesWritten { get; private set; }
        public long ReadTime { get; private set; }
        public long WriteTime { get; private set; }
        public long IdleTime { get; private set; }
        public uint ReadCount { get; private set; }
        public uint WriteCount { get; private set; }
        public uint QueueDepth { get; private set; }
        public uint SplitCount { get; private set; }
        public long QueryTime { get; private set; }
        public uint StorageDeviceNumber { get; private set; }
        public string StorageManagerName { get; private set; }
    }
}