source: trunk/eraser/Eraser.Util/PhysicalDriveInfo.cs @ 2174

/* 
 * $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.Collections.Generic;
using System.Linq;
using System.Text;

using System.IO;
using System.Runtime.InteropServices;
using System.Globalization;
using System.Text.RegularExpressions;
using Microsoft.Win32.SafeHandles;

namespace Eraser.Util
{
    public class PhysicalDriveInfo
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="index">The physical drive index in the computer.</param>
        public PhysicalDriveInfo(int index)
        {
            Index = index;
        }

        /// <summary>
        /// The physical drive index of the current drive in the computer.
        /// </summary>
        public int Index
        {
            get;
            private set;
        }

        /// <summary>
        /// Lists all physical drives in the computer.
        /// </summary>
        public static IList<PhysicalDriveInfo> Drives
        {
            get
            {
                List<PhysicalDriveInfo> result = new List<PhysicalDriveInfo>();

                //Iterate over every hard disk index until we find one that doesn't exist.
                for (int i = 0; ; ++i)
                {
                    string path = string.Format(CultureInfo.InvariantCulture,
                        "\\Device\\Harddisk{0}\\Partition0", i);
                    using (SafeFileHandle handle = OpenWin32Device(path))
                    {
                        if (handle.IsInvalid)
                            break;

                        result.Add(new PhysicalDriveInfo(i));
                    }
                }

                return result.AsReadOnly();
            }
        }

        /// <summary>
        /// Opens a device in the Win32 Namespace.
        /// </summary>
        /// <param name="deviceName">The name of the device to open.</param>
        /// <returns>A <see cref="SafeFileHandle"/> to the device.</returns>
        private static SafeFileHandle OpenWin32Device(string deviceName)
        {
            //Define the DOS device name for access
            string dosDeviceName = string.Format(CultureInfo.InvariantCulture,
                "eraser{0}_{1}", System.Diagnostics.Process.GetCurrentProcess().Id,
                System.AppDomain.GetCurrentThreadId());
            if (!NativeMethods.DefineDosDevice(
                NativeMethods.DosDeviceDefineFlags.RawTargetPath, dosDeviceName,
                deviceName))
            {
                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());
            }

            try
            {
                //Open the device handle.
                return NativeMethods.CreateFile(string.Format(CultureInfo.InvariantCulture,
                    "\\\\.\\{0}", dosDeviceName), NativeMethods.FILE_READ_ATTRIBUTES,
                    NativeMethods.FILE_SHARE_READ | NativeMethods.FILE_SHARE_WRITE, IntPtr.Zero,
                    (int)FileMode.Open, (uint)FileAttributes.ReadOnly, IntPtr.Zero);
            }
            finally
            {
                //Then undefine the DOS device
                if (!NativeMethods.DefineDosDevice(
                    NativeMethods.DosDeviceDefineFlags.ExactMatchOnRmove |
                    NativeMethods.DosDeviceDefineFlags.RawTargetPath |
                    NativeMethods.DosDeviceDefineFlags.RemoveDefinition,
                    dosDeviceName, deviceName))
                {
                    throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error());
                }
            }
        }

        /// <summary>
        /// Gets the volumes stored on that drive.
        /// </summary>
        public IList<VolumeInfo> Volumes
        {
            get
            {
                //Get all registered DOS Device names.
                string[] dosDevices = NativeMethods.QueryDosDevices();

                //Get a list of Win32 device names, and map it to DOS Devices.
                ComLib.Collections.DictionaryMultiValue<string, string> devices =
                    new ComLib.Collections.DictionaryMultiValue<string, string>();
                foreach (string dosDevice in dosDevices)
                {
                    string win32Device = NativeMethods.QueryDosDevice(dosDevice);
                    if (win32Device != null)
                        devices.Add(win32Device, dosDevice);
                }

                List<VolumeInfo> result = new List<VolumeInfo>();
                foreach (VolumeInfo info in VolumeInfo.Volumes)
                {
                    if (info.VolumeId.Substring(0, 4) == "\\\\?\\")
                    {
                        string win32Device = NativeMethods.QueryDosDevice(
                            info.VolumeId.Substring(4, info.VolumeId.Length - 5));
                        foreach (string dosDevice in devices.Get(win32Device))
                        {
                            Match match = HarddiskPartitionRegex.Match(dosDevice);
                            if (!match.Success)
                                continue;

                            //Check the HardDisk ID: if it is the same as our index, it is our partition.
                            if (Convert.ToInt32(match.Groups[1].Value) == Index)
                            {
                                int partition = Convert.ToInt32(match.Groups[2].Value) - 1;
                                while (partition >= result.Count)
                                    result.Add(null);

                                result[partition] = info;
                            }
                        }
                    }
                }

                return result;
            }
        }

        /// <summary>
        /// The regular expression which parses DOS Device names for the hard disk and partition.
        /// </summary>
        private static readonly Regex HarddiskPartitionRegex =
            new Regex("Harddisk([\\d]+)Partition([\\d]+)", RegexOptions.Compiled);
    }
}