code/FileSystem/Drive.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using Microsoft.Win32.SafeHandles;

namespace Sylloge
{
    public static partial class FileSystem
    {
        public class Drive : System.IDisposable
        {
            #region Events

            public delegate void DelegateError(Sylloge.FileSystem.Drive sender, string error);
            public event DelegateError Error;

            private void OnError(string error)
            {
                if (this.Error != null) { this.Error(this, error); }
            }

            #endregion

            #region Attributes

            public int BytesPerSector { get; protected set; }
            public string Caption { get; protected set; }
            public string DeviceID { get; protected set; }
            public string[] DriveLetters { get; protected set; }
            public string Description { get; protected set; }
            public ulong FreeSpace { get; protected set; }
            public Microsoft.Win32.SafeHandles.SafeFileHandle Handle { get; protected set; }
            public bool IsLogicalDrive { get; protected set; }
            public string Name { get; protected set; }
            public uint Partitions { get; protected set; }
            public uint SectorsPerTrack { get; protected set; }
            public ulong Size { get; protected set; }
            public long TotalCylinders { get; protected set; }
            public ulong TotalSectors { get; protected set; }
            public ulong TotalTracks { get; protected set; }
            public uint TracksPerCylinder { get; protected set; }
            public System.IO.DriveType Type { get; protected set; }
            public ulong UsedSpace { get; protected set; }

            private bool m_IsOpen { get; set; }
            private System.IO.Stream m_Stream { get; set; }
            private System.Management.ManagementObject m_DiskObject { get; set; }

            #endregion

            #region Methods

            public Drive()
            {
            }

            public Drive(string letterOrDeviceID)
            {
                this.DeviceID = letterOrDeviceID;
                this.Initialize(true);
            }

            public Drive(string letterOrDeviceID, bool open)
            {
                this.DeviceID = letterOrDeviceID;
                this.Initialize(open);
            }

            ~Drive()
            {
                this.Dispose();
            }

            public void Dispose()
            {
                this.Close();
                GC.SuppressFinalize(this);
            }

            public void Close()
            {
                if (this.Handle != null && !this.Handle.IsClosed) {
                    Sylloge.WinAPI.Kernel32.CloseHandle(this.Handle);
                    this.Handle.Close();
                }
                if (this.m_Stream != null) {
                    try {
                        this.m_Stream.Close();
                    } catch (Exception ex) {
                        Sylloge.App.Out(ex);
                    }
                }
                this.IsOpen = false;
            }

            public Sylloge.FileSystem.Drive Clone()
            {
                System.Runtime.Serialization.Formatters.Binary.BinaryFormatter val = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                System.IO.MemoryStream s = new System.IO.MemoryStream();
                val.Serialize(s, this);
                Sylloge.FileSystem.Drive res = (Sylloge.FileSystem.Drive)val.Deserialize(s);
                s.Close();
                return res;
            }

            private long CTL_CODE(long fileSystemCode, long functionCode, long method, long access)
            {
                return ((fileSystemCode * ((long)System.Math.Pow(2, 16))) | (access * ((long)System.Math.Pow(2, 14))) | (functionCode * ((long)System.Math.Pow(2, 2))) | method);
            }

            public int DeletePartitionInformation()
            {
                if (!this.IsReady) { return -1; }
                uint dummy = 0;
                if (!Sylloge.WinAPI.Kernel32.DeviceIoControl(this.Handle, (uint)Sylloge.WinAPI.Constants.IOCTL_DISK_DELETE_DRIVE_LAYOUT, IntPtr.Zero, 0, IntPtr.Zero, 0, ref dummy, IntPtr.Zero)) {
                    Sylloge.App.Out("Error Deleting Partition Information: " + Sylloge.WinAPI.GetLastError().ToString());
                    return Sylloge.WinAPI.GetLastError().Code;
                }
                return 0;
            }

            public int Eject()
            {
                if (!this.IsReady) { return -1; }
                // For this, we mearly need to lock and dismount the volume. Ejecting will make it inaccessable to anything
                uint dummy = 0;
                long Function = 0;
                // Lock the volume
                Function = CTL_CODE(Sylloge.WinAPI.Constants.FILE_DEVICE_FILE_SYSTEM, Sylloge.WinAPI.Constants.FSCTL_LOCK_VOLUME, 0, 0);
                bool Locked = false;
                for (int i = 0; i < 5; i++) {
                    Locked = Sylloge.WinAPI.Kernel32.DeviceIoControl(this.Handle, (uint)Function, IntPtr.Zero, 0, IntPtr.Zero, 0, ref dummy, IntPtr.Zero);
                    if (Locked) { break; } else { Console.WriteLine("Error Locking Drive: " + Sylloge.WinAPI.GetLastError().ToString()); }
                    System.Threading.Thread.Sleep(500);
                }
                if (!Locked) { return -2; }
                // Dismount the volume
                Function = CTL_CODE(Sylloge.WinAPI.Constants.FILE_DEVICE_FILE_SYSTEM, Sylloge.WinAPI.Constants.FSCTL_DISMOUNT_VOLUME, 0, 0);
                if (!Sylloge.WinAPI.Kernel32.DeviceIoControl(this.Handle, (uint)Function, IntPtr.Zero, 0, IntPtr.Zero, 0, ref dummy, IntPtr.Zero)) {
                    Console.WriteLine("Error Dismount Drive: " + Sylloge.WinAPI.GetLastError().ToString());
                    return Sylloge.WinAPI.GetLastError().Code;
                }
                return 0;
            }

            private string GetValue(string value)
            {
                return this.GetValue(value, "");
            }

            private string GetValue(string value, string defaultValue)
            {
                return this.GetValue(this.m_DiskObject, value, defaultValue);
            }

            private string GetValue(System.Management.ManagementObject mgmtObject, string value, string defaultValue)
            {
                string RetValue = defaultValue;
                try {
                    object Retrieved = mgmtObject[value];
                    if (Retrieved == null) { return defaultValue; }
                    RetValue = Retrieved.ToString();
                } catch (Exception ex) {
                    this.OnError(ex.Message);
                    RetValue = defaultValue;
                }
                return RetValue;
            }

            private void Initialize(bool autoOpen)
            {
                if (this.DeviceID.ToUpper().Contains("PHYSICALDRIVE")) {
                    this.IsLogicalDrive = false;
                    string DeviceIndex = this.DeviceID.Substring(17);
                    int OutRes = 0;
                    bool IsValidIndex = Int32.TryParse(DeviceIndex, out OutRes);
                    if (this.DeviceID.Substring(0, 17).ToLower() != "\\\\.\\physicaldrive" || !IsValidIndex) {
                        throw new Exception("Device ID must be a valid drive id in the form of \"\\\\.\\PhysicalDriveX\" where X is a valid number");
                    }
                } else {
                    if (this.DeviceID.Length > 3 && this.DeviceID.Substring(0, 4) == "\\\\.\\") {
                        this.DeviceID = DeviceID.Substring(4);
                    }
                    if (this.DeviceID.Substring(this.DeviceID.Length - 1) == "\\") {
                        this.DeviceID = this.DeviceID.Substring(0, this.DeviceID.Length - 1);
                    }
                    if (this.DeviceID.Length > 2) {
                        this.DeviceID = this.DeviceID.Substring(0, 2);
                    }
                    if (this.DeviceID[1] == ':') {
                        if (this.DeviceID.Length > 2) {
                            this.DeviceID = this.DeviceID.Substring(0, 2);
                        }
                        this.IsLogicalDrive = true;
                    } else {
                        throw new Exception("Device ID must be a valid letter or ID in the form of one of the following: \"\\\\.\\A:\" or just the drive letter \"A:\"");
                    }
                }
                if (autoOpen) { this.Open(); }
            }

            public bool IsReady
            {
                get
                {
                    if (!this.IsOpen || this.Handle == null) { return false; }
                    uint dummy = 0;
                    var DiskGeometry = new Sylloge.WinAPI.DiskGeometry();
                    bool Success = Sylloge.WinAPI.Kernel32.DeviceIoControl(this.Handle, Sylloge.WinAPI.Constants.IOCTL_DISK_GET_DRIVE_GEOMETRY,
                                    IntPtr.Zero, 0, out DiskGeometry, (uint)Marshal.SizeOf(DiskGeometry), ref dummy, IntPtr.Zero);
                    return (Success && DiskGeometry.SectorsPerTrack > 0);
                }
            }

            public bool IsOpen
            {
                get
                {
                    return (this.m_IsOpen && this.Handle != null && !this.Handle.IsClosed);
                }
                private set
                {
                    this.m_IsOpen = value;
                }
            }

            public string MediaType
            {
                get
                {
                    return this.GetValue("MediaType", "NoMedia");
                }
            }

            public bool Open(string driveLetterOrDeviceId)
            {
                if (this.IsOpen) { this.Close(); }
                this.DeviceID = driveLetterOrDeviceId;
                this.Initialize(false);
                return this.Open();
            }

            public bool Open()
            {
                if (!this.IsLogicalDrive) {
                    this.m_DiskObject = new System.Management.ManagementObject("Win32_DiskDrive.DeviceID=\"" + this.DeviceID.Replace("\\", "\\\\") + "\"");
                    // Get the partitions
                    List<string> LogicalPartitions = new List<string>();
                    System.Management.ManagementObjectSearcher Partitions = new System.Management.ManagementObjectSearcher("ASSOCIATORS OF {Win32_DiskDrive.DeviceID=\"" + this.DeviceID.Replace("\\", "\\\\") + "\"} WHERE AssocClass = Win32_DiskDriveToDiskPartition");
                    foreach (System.Management.ManagementObject Partition in Partitions.Get()) {
                        // Now get the logical drives associated with the partitions
                        System.Management.ManagementObjectSearcher LogicalDrives = new System.Management.ManagementObjectSearcher("ASSOCIATORS OF {Win32_DiskPartition.DeviceID=\"" + Partition["DeviceID"].ToString() + "\"} WHERE AssocClass = Win32_LogicalDiskToPartition");
                        foreach (System.Management.ManagementObject LogicalDrive in LogicalDrives.Get()) {
                            LogicalPartitions.Add(LogicalDrive["DeviceID"].ToString());
                        }
                    }
                    this.DriveLetters = LogicalPartitions.ToArray();
                } else {
                    this.m_DiskObject = new System.Management.ManagementObject("Win32_LogicalDisk.DeviceID=\"" + this.DeviceID + "\"");
                    this.DriveLetters = new string[] { this.DeviceID };
                }
                this.Type = (System.IO.DriveType)Sylloge.WinAPI.Kernel32.GetDriveType(this.DeviceID + "\\");
                this.Caption = this.GetValue("Caption");
                this.Description = this.GetValue("Description");
                this.Name = this.GetValue("Name");
                this.Size = Convert.ToUInt64(this.GetValue("Size", "0"));
                this.Partitions = Convert.ToUInt32(this.GetValue("Partitions", "0"));
                string Path = (this.IsLogicalDrive ? ("\\\\.\\" + this.DeviceID) : this.DeviceID);
                if (this.Type == System.IO.DriveType.Removable && this.DriveLetters.Length > 0) {
                    // If we are trying to open a USB drive (thumb/sd/etc.) or a logical drive 
                    // then we must specify the drive (i.e. '\\.\X:')
                    Path = "\\\\.\\" + this.DriveLetters[0].Substring(0, 2);
                }
                this.Handle = Sylloge.WinAPI.Kernel32.CreateFile(Path,
                            Sylloge.WinAPI.Constants.GENERIC_READ | Sylloge.WinAPI.Constants.GENERIC_WRITE,
                            Sylloge.WinAPI.Constants.FILE_SHARE_READ | Sylloge.WinAPI.Constants.FILE_SHARE_WRITE,
                            IntPtr.Zero,
                            Sylloge.WinAPI.Constants.OPEN_EXISTING,
                            Sylloge.WinAPI.Constants.FILE_ATTRIBUTE_NORMAL | Sylloge.WinAPI.Constants.FILE_FLAG_NO_BUFFERING,
                            IntPtr.Zero);

                if (Sylloge.WinAPI.GetLastError().Code != 0 || this.Handle.IsInvalid) { return false; }
                this.IsOpen = (this.Handle != null && !this.Handle.IsClosed);
                if (this.IsOpen) {
                    this.m_Stream = new System.IO.FileStream(this.Handle, System.IO.FileAccess.ReadWrite);
                }
                uint dummy = 0;
                var diskGeo = new Sylloge.WinAPI.DiskGeometry();
                Sylloge.WinAPI.Kernel32.DeviceIoControl(this.Handle, Sylloge.WinAPI.Constants.IOCTL_DISK_GET_DRIVE_GEOMETRY,
                                IntPtr.Zero, 0, out diskGeo, (uint)Marshal.SizeOf(diskGeo), ref dummy, IntPtr.Zero);
                this.TotalCylinders = diskGeo.Cylinders;
                this.TracksPerCylinder = (uint)diskGeo.TracksPerCylinder;
                this.TotalTracks = (ulong)(this.TracksPerCylinder * this.TotalCylinders);
                this.SectorsPerTrack = (uint)diskGeo.SectorsPerTrack;
                this.TotalSectors = this.SectorsPerTrack * this.TotalTracks;
                this.BytesPerSector = diskGeo.BytesPerSector;
                if (this.IsLogicalDrive && this.BytesPerSector > 0) {
                    this.TotalSectors = (ulong)(this.Size / (ulong)this.BytesPerSector);
                }
                ulong Free = 0, Available = 0, Total = 0;
                if (this.Size == 0) {
                    // For some reason, we could not get the size of the drive, so calculate it the hard way
                    this.Size = (this.TotalSectors * (ulong)this.BytesPerSector);
                }
                Sylloge.WinAPI.Kernel32.GetDiskFreeSpaceEx(this.DeviceID, out Available, out Total, out Free);
                this.FreeSpace = Free;
                this.UsedSpace = (this.Size - this.FreeSpace);
                return true;
            }

            public long Position
            {
                get
                {
                    return this.m_Stream.Position;
                }
            }

            public byte[] Read(ulong sector)
            {
                if (!this.IsReady) {
                    this.OnError("Read failed, device is not ready");
                    return null;
                }
                if (sector > this.TotalSectors) {
                    this.OnError(("Read failed, sector is not within the range of the current device: sector=" + sector.ToString() + ", Total Sectors=" + this.TotalSectors.ToString()));
                    return null;
                }
                if (!this.Seek(sector, System.IO.SeekOrigin.Begin)) {
                    this.OnError("Read failed, could not seek to the specified sector " + sector.ToString());
                    return null;
                }
                byte[] Buffer = new byte[this.BytesPerSector];
                try {
                    this.m_Stream.Read(Buffer, 0, Buffer.Length);
                } catch (Exception ex) {
                    this.OnError("Read failed, " + ex.Message);
                    return null;
                }
                return Buffer;
            }

            public byte[] Read(ulong sector, int count)
            {
                if (!this.IsReady) {
                    this.OnError("Read failed, device is not ready");
                    return null;
                }
                if (sector > this.TotalSectors) {
                    this.OnError(("Read failed, sector is not within the range of the current device: sector=" + sector.ToString() + ", Total Sectors=" + this.TotalSectors.ToString()));
                    return null;
                }
                if (!this.Seek(sector, System.IO.SeekOrigin.Begin)) {
                    this.OnError("Read failed, could not seek to the specified sector " + sector.ToString());
                    return null;
                }
                byte[] Buffer = new byte[(this.BytesPerSector * count)];
                try {
                    this.m_Stream.Read(Buffer, 0, Buffer.Length);
                } catch (Exception ex) {
                    this.OnError("Read failed, " + ex.Message);
                    return null;
                }
                return Buffer;
            }

            public bool Seek(ulong sector, System.IO.SeekOrigin origin)
            {
                if (!this.IsReady) {
                    this.OnError("Seek failed, device is not ready");
                    return false;
                }
                if (sector > this.TotalSectors) {
                    this.OnError(("Seek failed, sector is not within the range of the current device: sector=" + sector.ToString() + ", Total Sectors=" + this.TotalSectors.ToString()));
                    return false;
                }
                long Pos = 0, Seeked = 0;
                try {
                    Pos = ((long)sector * (long)this.BytesPerSector);
                    Seeked = this.m_Stream.Seek((long)Pos, origin);
                } catch (Exception ex) {
                    this.OnError("Seek failed, " + ex.Message);
                    return false;
                }
                return (Pos == Seeked);
            }

            public override string ToString()
            {
                if (!this.IsReady) { return this.DeviceID + " - Device not ready"; }
                string Value = this.DeviceID;
                if (!this.IsLogicalDrive) {
                    Value += " - ";
                    if (this.DriveLetters.Length == 0) {
                        if (this.Type == System.IO.DriveType.Removable) {
                            Value += "No Media";
                        } else {
                            Value += "No Readable Windows Volumes";
                        }
                    } else {
                        foreach (string Letter in this.DriveLetters) {
                            Value += " { " + Letter + " }";
                        }
                    }
                }
                return Value;
            }

            public bool Write(ulong sector, byte[] data)
            {
                if (!this.IsReady) {
                    this.OnError("Write failed, device is not ready");
                    return false;
                }
                if ((data.Length % this.BytesPerSector) != 0) {
                    this.OnError(("Write failed, data length to write should be on clean byte sectors (multiples of the BPS): data.Length=" + data.Length.ToString() + ", Bytes Per Sector=" + this.BytesPerSector.ToString()));
                    return false;
                }
                if (!this.Seek(sector, System.IO.SeekOrigin.Begin)) {
                    this.OnError("Write failed, could not seek to the specified sector " + sector.ToString());
                    return false;
                }
                try {
                    this.m_Stream.Write(data, 0, data.Length);
                    this.m_Stream.Flush();
                } catch (Exception ex) {
                    this.OnError("Write failed, " + ex.Message);
                    return false;
                }
                return true;
            }

            #endregion

            #region Static Members

            public static Sylloge.FileSystem.Drive[] GetDrives(bool autoOpen)
            {
                System.Collections.Generic.List<Sylloge.FileSystem.Drive> ret = new System.Collections.Generic.List<Sylloge.FileSystem.Drive>();
                System.Management.ManagementObjectSearcher Disks = new System.Management.ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive");
                foreach (System.Management.ManagementObject Disk in Disks.Get()) {
                    ret.Add((new Sylloge.FileSystem.Drive(Disk["DeviceID"].ToString(), autoOpen)));
                }
                return ret.ToArray();
            }

            public static Sylloge.FileSystem.Drive[] GetVolumes(bool autoOpen)
            {
                System.Collections.Generic.List<Sylloge.FileSystem.Drive> ret = new System.Collections.Generic.List<Sylloge.FileSystem.Drive>();
                foreach (string dev in System.Environment.GetLogicalDrives()) {
                    System.IO.DriveType Type = (new System.IO.DriveInfo(dev)).DriveType;
                    // Only add Fixed or Removable devices (in other words, no network/RAM/cd drives)
                    if (Type == System.IO.DriveType.Fixed || Type == System.IO.DriveType.Removable) {
                        ret.Add((new Sylloge.FileSystem.Drive(dev.Substring(0, 2), autoOpen)));
                    }
                }
                return ret.ToArray();
            }

            #endregion
        }
    }
}