Untitled

    /// <summary>
    /// Represents a raw device stream.
    /// </summary>
    public class VolumeStream : Stream
    {
        private FileStream _ntStream;
        private long _totalLength;
        private DISK_GEOMETRY _geometry;

        /// <summary>
        /// Gets the total cylinders.
        /// </summary>
        /// <value>The total cylinders.</value>
        public long TotalCylinders
        {
            get
            {
                return _geometry.Cylinders;
            }
        }

        /// <summary>
        /// Gets the tracks per cylinder.
        /// </summary>
        /// <value>The tracks per cylinder.</value>
        public int TracksPerCylinder
        {
            get
            {
                return _geometry.TracksPerCylinder;
            }
        }

        /// <summary>
        /// Gets the sectors per track.
        /// </summary>
        /// <value>The sectors per track.</value>
        public int SectorsPerTrack
        {
            get
            {
                return _geometry.SectorsPerTrack;
            }
        }

        /// <summary>
        /// Gets the bytes per sector.
        /// </summary>
        /// <value>The bytes per sector.</value>
        public int BytesPerSector
        {
            get
            {
                return _geometry.BytesPerSector;
            }
        }

        bool _locked = false;

        /// <summary>
        /// Initializes a new instance of the <see cref="RawDeviceStream"/> class.
        /// </summary>
        /// <param name="stream">The stream.</param>
        private VolumeStream(FileStream stream)
        {
            _ntStream = stream;
            _geometry = NativeMethods.GetGeometry(stream);
            _totalLength = _geometry.DiskSize;
            NativeMethods.LockVolume(stream);
            _locked = true;
            NativeMethods.DismountVolume(stream);
            Seek(0, SeekOrigin.Begin);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RawDeviceStream"/> class.
        /// </summary>
        /// <param name="deviceName">Name of the device.</param>
        public VolumeStream(string deviceName)
            : this(NativeMethods.GetDeviceStream(deviceName))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RawDeviceStream"/> class.
        /// </summary>
        /// <param name="drive">The drive.</param>
        public VolumeStream(DriveInfo drive)
            : this(NativeMethods.GetDeviceStream(NativeMethods.CleanName(drive.Name)))
        {
        }

        #region Wrappers
        /// <summary>
        /// Gets a value indicating whether the current stream supports reading.
        /// </summary>
        /// <value></value>
        /// <returns>true if the stream supports reading; otherwise, false.
        /// </returns>
        public override bool CanRead
        {
            get { return _ntStream.CanRead; }
        }

        /// <summary>
        /// Gets a value indicating whether the current stream supports seeking.
        /// </summary>
        /// <value></value>
        /// <returns>true if the stream supports seeking; otherwise, false.
        /// </returns>
        public override bool CanSeek
        {
            get { return _ntStream.CanSeek; }
        }

        /// <summary>
        /// Gets a value indicating whether the current stream supports writing.
        /// </summary>
        /// <value></value>
        /// <returns>true if the stream supports writing; otherwise, false.
        /// </returns>
        public override bool CanWrite
        {
            get { return _ntStream.CanWrite; }
        }

        /// <summary>
        /// Gets the length in bytes of the stream.
        /// </summary>
        /// <value></value>
        /// <returns>
        /// A long value representing the length of the stream in bytes.
        /// </returns>
        /// <exception cref="T:System.NotSupportedException">
        /// A class derived from Stream does not support seeking.
        /// </exception>
        /// <exception cref="T:System.ObjectDisposedException">
        /// Methods were called after the stream was closed.
        /// </exception>
        public override long Length
        {
            get { return _totalLength; }
        }

        private long _position;
        /// <summary>
        /// Gets or sets the position within the current stream.
        /// </summary>
        /// <value></value>
        /// <returns>
        /// The current position within the stream.
        /// </returns>
        /// <exception cref="T:System.IO.IOException">
        /// An I/O error occurs.
        /// </exception>
        /// <exception cref="T:System.NotSupportedException">
        /// The stream does not support seeking.
        /// </exception>
        /// <exception cref="T:System.ObjectDisposedException">
        /// Methods were called after the stream was closed.
        /// </exception>
        public override long Position
        {
            get
            {
                return _position;
            }
            set
            {
                Seek(value, SeekOrigin.Begin);
            }
        }

        /// <summary>
        /// Sets the length of the current stream. This is not supported.
        /// </summary>
        /// <param name="value">The desired length of the current stream in bytes.</param>
        /// <exception cref="T:System.IO.IOException">
        /// An I/O error occurs.
        /// </exception>
        /// <exception cref="T:System.NotSupportedException">
        /// The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output.
        /// </exception>
        /// <exception cref="T:System.ObjectDisposedException">
        /// Methods were called after the stream was closed.
        /// </exception>
        public override void SetLength(long value)
        {
            throw new NotSupportedException("Can't change the length of a drive.");
        }
        #endregion Wrappers

        /// <summary>
        /// Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
        /// </summary>
        /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between <paramref name="offset"/> and (<paramref name="offset"/> + <paramref name="count"/> - 1) replaced by the bytes read from the current source.</param>
        /// <param name="offset">The zero-based byte offset in <paramref name="buffer"/> at which to begin storing the data read from the current stream.</param>
        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
        /// <returns>
        /// The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
        /// </returns>
        /// <exception cref="T:System.ArgumentException">
        /// The sum of <paramref name="offset"/> and <paramref name="count"/> is larger than the buffer length.
        /// </exception>
        /// <exception cref="T:System.ArgumentNullException">
        ///     <paramref name="buffer"/> is null.
        /// </exception>
        /// <exception cref="T:System.ArgumentOutOfRangeException">
        ///     <paramref name="offset"/> or <paramref name="count"/> is negative.
        /// </exception>
        /// <exception cref="T:System.IO.IOException">
        /// An I/O error occurs.
        /// </exception>
        /// <exception cref="T:System.NotSupportedException">
        /// The stream does not support reading.
        /// </exception>
        /// <exception cref="T:System.ObjectDisposedException">
        /// Methods were called after the stream was closed.
        /// </exception>
        public override int Read(byte[] buffer, int offset, int count)
        {
            if (_position + count > _totalLength)
                count = (int)(_totalLength - _position);

            long origPos = _ntStream.Position;
            int diff = Diff();
            byte[] overBuffer = ReadTempBuffer(count + diff);
            Buffer.BlockCopy(overBuffer, diff, buffer, offset, count);
            _ntStream.Position = origPos;
            Position += count;
            return count;
        }

        /// <summary>
        /// Sets the position within the current stream.
        /// </summary>
        /// <param name="offset">A byte offset relative to the <paramref name="origin"/> parameter.</param>
        /// <param name="origin">A value of type <see cref="T:System.IO.SeekOrigin"/> indicating the reference point used to obtain the new position.</param>
        /// <returns>
        /// The new position within the current stream.
        /// </returns>
        /// <exception cref="T:System.IO.IOException">
        /// An I/O error occurs.
        /// </exception>
        /// <exception cref="T:System.NotSupportedException">
        /// The stream does not support seeking, such as if the stream is constructed from a pipe or console output.
        /// </exception>
        /// <exception cref="T:System.ObjectDisposedException">
        /// Methods were called after the stream was closed.
        /// </exception>
        public override long Seek(long offset, SeekOrigin origin)
        {
            long position = GetAbsolutePosition(offset, origin);
            _position = position;
            position = GetRealPosition(position);
            if (position == _ntStream.Position)
            {
                return _position;
            }
            _ntStream.Seek(position, SeekOrigin.Begin);
            return _position;
        }

        /// <summary>
        /// Sets the position within the current stream.
        /// </summary>
        /// <param name="offset">A byte offset relative to the <paramref name="origin"/> parameter.</param>
        /// <param name="origin">A value of type <see cref="T:System.IO.SeekOrigin"/> indicating the reference point used to obtain the new position.</param>
        /// <returns>
        /// The new position within the current stream.
        /// </returns>
        /// <exception cref="T:System.IO.IOException">
        /// An I/O error occurs.
        /// </exception>
        /// <exception cref="T:System.NotSupportedException">
        /// The stream does not support seeking, such as if the stream is constructed from a pipe or console output.
        /// </exception>
        /// <exception cref="T:System.ObjectDisposedException">
        /// Methods were called after the stream was closed.
        /// </exception>
        public long SeekSectorPosition(long offset, SeekOrigin origin)
        {
            long position = GetAbsolutePosition(offset, origin);
            position = GetRealPosition(position);
            _position = position;
            if (position == _ntStream.Position)
            {
                return _position;
            }
            _ntStream.Seek(position, SeekOrigin.Begin);
            return _position;
        }

        /// <summary>
        /// Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
        /// </summary>
        /// <param name="buffer">An array of bytes. This method copies <paramref name="count"/> bytes from <paramref name="buffer"/> to the current stream.</param>
        /// <param name="offset">The zero-based byte offset in <paramref name="buffer"/> at which to begin copying bytes to the current stream.</param>
        /// <param name="count">The number of bytes to be written to the current stream.</param>
        /// <exception cref="T:System.ArgumentException">
        /// The sum of <paramref name="offset"/> and <paramref name="count"/> is greater than the buffer length.
        /// </exception>
        /// <exception cref="T:System.ArgumentNullException">
        ///     <paramref name="buffer"/> is null.
        /// </exception>
        /// <exception cref="T:System.ArgumentOutOfRangeException">
        ///     <paramref name="offset"/> or <paramref name="count"/> is negative.
        /// </exception>
        /// <exception cref="T:System.IO.IOException">
        /// An I/O error occurs.
        /// </exception>
        /// <exception cref="T:System.NotSupportedException">
        /// The stream does not support writing.
        /// </exception>
        /// <exception cref="T:System.ObjectDisposedException">
        /// Methods were called after the stream was closed.
        /// </exception>
        public override void Write(byte[] buffer, int offset, int count)
        {
            if (_position + count > _totalLength)
                count = (int)(_totalLength - _position);

            if (count % BytesPerSector == 0 &&
                _position % BytesPerSector == 0)
            {
                _ntStream.Write(buffer, offset, count);
            }
            else
            {
                int diff = Diff();
                long origPos = _ntStream.Position;
                byte[] overBuffer = ReadTempBuffer(count + diff);
                Buffer.BlockCopy(buffer, offset, overBuffer, diff, count);
                _ntStream.Position = origPos;
                _ntStream.Write(overBuffer, 0, overBuffer.Length);
                _ntStream.Position = origPos;
                Position += count;
            }

        }

        /// <summary>
        /// Clears all buffers for this stream and causes any buffered data to be written to the underlying device.
        /// </summary>
        /// <exception cref="T:System.IO.IOException">
        /// An I/O error occurs.
        /// </exception>
        public override void Flush()
        {
            _ntStream.Flush();
        }

        /// <summary>
        /// Releases the unmanaged resources used by the <see cref="T:System.IO.Stream"/> and optionally releases the managed resources.
        /// </summary>
        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
        protected override void Dispose(bool disposing)
        {
            try
            {
                if (_locked)
                    NativeMethods.UnlockVolume(_ntStream);
            }
            catch { }
            if (disposing)
            {
                _ntStream.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Seek Helpers
        private long GetAbsolutePosition(long offset, SeekOrigin origin)
        {
            switch (origin)
            {
                case SeekOrigin.Begin:
                    return offset;
                case SeekOrigin.Current:
                    return _ntStream.Position + offset;
                case SeekOrigin.End:
                    return Length - offset;
            }
            return 0;
        }

        private byte[] ReadTempBuffer(int count)
        {
            byte[] buffer = new byte[GetBufSize(count)];
            _ntStream.Read(buffer, 0, buffer.Length);
            return buffer;
        }

        private int Diff()
        {
            return (int)(_position - _ntStream.Position);
        }

        private long GetRealPosition(long offset)
        {
            return offset - offset % BytesPerSector;
        }

        private int GetBufSize(int count)
        {
            if (count % BytesPerSector == 0)
                return count;
            else
                return BytesPerSector + count - count % BytesPerSector;
        }
        #endregion Seek Helpers

        #region Native
        [StructLayout(LayoutKind.Sequential)]
        private struct DISK_GEOMETRY
        {
            public long Cylinders;
            public int MediaType;
            public int TracksPerCylinder;
            public int SectorsPerTrack;
            public int BytesPerSector;

            public long DiskSize
            {
                get
                {
                    return Cylinders * (long)TracksPerCylinder * (long)SectorsPerTrack * (long)BytesPerSector;
                }
            }
        }

        private static class NativeMethods
        {
            const int GENERIC_READ = unchecked((int)0x80000000);
            const int GENERIC_WRITE = unchecked((int)0x40000000);
            const int FILE_SHARE_READ = unchecked((int)0x00000001);
            const int FILE_SHARE_WRITE = unchecked((int)0x00000002);
            const int OPEN_EXISTING = 3;
            const int FILE_ATTRIBUTE_NORMAL = 0x80;

            const Int64 INVALID_HANDLE_VALUE = -1;
            const uint IOCTL_STORAGE_GET_DEVICE_NUMBER = 0x2D1080;
            const uint FSCTL_LOCK_VOLUME = 0x00090018;
            const uint IOCTL_DISK_GET_DRIVE_GEOMETRY = 0x70000;
            const uint IOCTL_DISK_FORMAT_TRACKS = 0x7C018;
            const uint IOCTL_DISK_FORMAT_TRACKS_EX = 0x7C02C;
            const uint FSCTL_UNLOCK_VOLUME = 0x0009001C;
            const uint FSCTL_DISMOUNT_VOLUME = 0x00090020;


            [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
            static extern SafeFileHandle CreateFile(string lpFileName, int dwDesiredAccess, int dwShareMode, IntPtr lpSecurityAttributes, uint dwCreationDisposition, uint dwFlagsAndAttributes, SafeFileHandle hTemplateFile);

            [DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true, CharSet = CharSet.Auto)]
            static extern bool DeviceIoControl(SafeFileHandle hDevice, uint dwIoControlCode, IntPtr lpInBuffer, uint nInBufferSize,
                IntPtr lpOutBuffer, uint nOutBufferSize, out uint lpBytesReturned, IntPtr lpOverlapped);

            /// <summary>
            /// Gets a raw device stream.
            /// </summary>
            /// <param name="deviceName">The name of the device.</param>
            /// <returns>A stream that allows raw access to the device.</returns>
            public static FileStream GetDeviceStream(string deviceName)
            {
                SafeFileHandle h = null;

                if (!deviceName.StartsWith("\\\\.\\"))
                    deviceName = string.Format("\\\\.\\{0}", deviceName);

                h = CreateFile(deviceName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
                    IntPtr.Zero, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
                    new SafeFileHandle(IntPtr.Zero, true));

                if (!h.IsInvalid)
                {
                    FileStream stream = new FileStream(h, FileAccess.Read | FileAccess.Write, 512);
                    return stream;
                }
                else
                {
                    int error = Marshal.GetLastWin32Error();
                    throw new Win32Exception(error);
                }
            }

            /// <summary>
            /// Dismounts the volume.
            /// </summary>
            /// <param name="stream">The stream.</param>
            public static void DismountVolume(FileStream stream)
            {
                uint bytesReturned = 0;
                if (!DeviceIoControl(stream.SafeFileHandle, FSCTL_DISMOUNT_VOLUME, IntPtr.Zero, 0, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero))
                {
                    int error = Marshal.GetLastWin32Error();
                    throw new Win32Exception(error);
                }
            }

            /// <summary>
            /// Locks a volume.
            /// </summary>
            /// <param name="stream">The volume.</param>
            public static void LockVolume(FileStream stream)
            {
                uint bytesReturned = 0;
                if (!DeviceIoControl(stream.SafeFileHandle, FSCTL_LOCK_VOLUME, IntPtr.Zero, 0, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero))
                {
                    int error = Marshal.GetLastWin32Error();
                    throw new Win32Exception(error);
                }
            }

            /// <summary>
            /// Unlocks a volume.
            /// </summary>
            /// <param name="stream">The volume.</param>
            public static void UnlockVolume(FileStream stream)
            {
                uint bytesReturned = 0;
                if (!DeviceIoControl(stream.SafeFileHandle, FSCTL_UNLOCK_VOLUME, IntPtr.Zero, 0, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero))
                {
                    int error = Marshal.GetLastWin32Error();
                    throw new Win32Exception(error);
                }
            }

            /// <summary>
            /// Gets the geometry.
            /// </summary>
            /// <param name="stream">The stream.</param>
            /// <returns></returns>
            public static DISK_GEOMETRY GetGeometry(FileStream stream)
            {
                object outputBuffer = new DISK_GEOMETRY();
                uint bytesReturned = 0;

                GCHandle GC = GCHandle.Alloc(outputBuffer, GCHandleType.Pinned);
                try
                {
                    var outputBufferPointer = GC.AddrOfPinnedObject();

                    var ret = DeviceIoControl(stream.SafeFileHandle, IOCTL_DISK_GET_DRIVE_GEOMETRY, IntPtr.Zero, 24, outputBufferPointer, 24,
                        out bytesReturned, IntPtr.Zero);

                    if (!ret)
                    {
                        int error = Marshal.GetLastWin32Error();
                        throw new Win32Exception(error);
                    }

                    return (DISK_GEOMETRY)outputBuffer;
                }
                finally
                {
                    GC.Free();
                }
            }

            /// <summary>
            /// Cleans a name.
            /// </summary>
            /// <param name="logicalDrive">The logical drive.</param>
            /// <returns></returns>
            public static string CleanName(string logicalDrive)
            {
                logicalDrive = Directory.GetDirectoryRoot(logicalDrive);
                if (logicalDrive.Length > 2)
                    logicalDrive = logicalDrive.Substring(0, 2);
                return logicalDrive;
            }
        }
        #endregion
    }