CreateFile函数直接读写硬盘实现的文件系统的完整代码

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;
using System.Threading;

namespace ReadWriteDisk
{
    public partial class Form1 : Form
    {
        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        static extern IntPtr CreateFile(string fileName, uint desiredAccess, uint shareMode, uint securityAttributes, uint creationDisposition, uint flagsAndAttributes, uint templateFile);

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern int ReadFile(IntPtr hFile, byte[] lpBuffer, uint nNumberOfBytesToRead, out uint lpNumberOfBytesRead, ref OVERLAPPED lpOverlapped);

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern int WriteFile(IntPtr hFile, byte[] lpBuffer, uint nNumberOfBytesToWrite, out uint lpNumberOfBytesWritten, ref OVERLAPPED lpOverlapped);

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern int CloseHandle(IntPtr hObject);

        readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);

        static class DESIREDACCESS
        {
            public const uint GENERIC_READ = 0x80000000;
            public const uint GENERIC_WRITE = 0x40000000;
            public const uint GENERIC_EXECUTE = 0x20000000;
            public const uint GENERIC_ALL = 0x10000000;
        }
        /// <summary>
        /// Sharing mode of the file or object
        ///</summary>
        static class SHAREMODE
        {
            public const uint FILE_SHARE_READ = 0x00000001;
            public const uint FILE_SHARE_WRITE = 0x00000002;
            public const uint FILE_SHARE_DELETE = 0x00000004;
        }
        /// <summary>
        /// Action to take on files that exist, and which action to take when files do not exist.
        /// </summary>
        static class CREATIONDISPOSITION
        {
            public const uint CREATE_NEW = 1;
            public const uint CREATE_ALWAYS = 2;
            public const uint OPEN_EXISTING = 3;
            public const uint OPEN_ALWAYS = 4;
            public const uint TRUNCATE_EXISTING = 5;
        }
        /// <summary>
        /// File attributes and flags for the file.
        /// </summary>
        static class FLAGSANDATTRIBUTES
        {
            public const uint FILE_FLAG_WRITE_THROUGH = 0x80000000;
            public const uint FILE_FLAG_OVERLAPPED = 0x40000000;
            public const uint FILE_FLAG_NO_BUFFERING = 0x20000000;
            public const uint FILE_FLAG_RANDOM_ACCESS = 0x10000000;
            public const uint FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000;
            public const uint FILE_FLAG_DELETE_ON_CLOSE = 0x04000000;
            public const uint FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
            public const uint FILE_FLAG_POSIX_SEMANTICS = 0x01000000;
            public const uint FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000;
            public const uint FILE_FLAG_OPEN_NO_RECALL = 0x00100000;
            public const uint FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000;
        }

        struct OVERLAPPED
        {
            public uint Internal;
            public uint InternalHigh;
            public uint Offset;
            public uint OffsetHigh;
            public uint hEvent;
        }

        uint Status = 0, NumStatus = 0;
        uint SubStatus = 0, NumSubStatus = 0;

        public Form1()
        {
            InitializeComponent();
        }

        IntPtr CreateForRead(byte number)
        {
            IntPtr handle = CreateFile("\\\\.\\PHYSICALDRIVE" + number.ToString(),
               DESIREDACCESS.GENERIC_READ,
               SHAREMODE.FILE_SHARE_READ | SHAREMODE.FILE_SHARE_WRITE,
               0,
               CREATIONDISPOSITION.OPEN_EXISTING,
               0,
               0);

            if (handle == INVALID_HANDLE_VALUE)
                throw new Exception();

            return handle;
        }

        byte[] ReadSectors(IntPtr handle, uint offsetSector, ushort numSectors)
        {
            if (numSectors > 1024)
                throw new Exception();

            uint size = 512u * numSectors;
            byte[] buffer = new byte[size];

            uint _size;

            ulong offset = 512 * (ulong)offsetSector;
            OVERLAPPED over = new OVERLAPPED();
            over.Offset = (uint)(offset & 0xFFFFFFFF);
            over.OffsetHigh = (uint)((offset & 0xFFFFFFFF00000000) >> 32);

            if (ReadFile(handle, buffer, size, out _size, ref over) == 0)
            {
                CloseHandle(handle);
                throw new Exception();
            }

            return buffer;
        }

        IntPtr CreateForWrite(byte number)
        {
            IntPtr handle = CreateFile("\\\\.\\PHYSICALDRIVE" + number.ToString(),
                DESIREDACCESS.GENERIC_WRITE,
                SHAREMODE.FILE_SHARE_WRITE,
                0,
                CREATIONDISPOSITION.OPEN_EXISTING,
                0,
                0);

            if (handle == INVALID_HANDLE_VALUE)
                throw new Exception();

            return handle;
        }

        void WriteSectors(IntPtr handle, uint offsetSector, ushort numSectors, byte[] buffer)
        {
            if (numSectors > 1024)
                throw new Exception();

            uint size = 512u * numSectors;
            if (buffer.Length != size)
                throw new Exception();

            uint _size;

            ulong offset = 512 * (ulong)offsetSector;
            OVERLAPPED over = new OVERLAPPED();
            over.Offset = (uint)(offset & 0xFFFFFFFF);
            over.OffsetHigh = (uint)((offset & 0xFFFFFFFF00000000) >> 32);

            if (WriteFile(handle, buffer, size, out _size, ref over) == 0)
            {
                CloseHandle(handle);
                throw new Exception();
            }
        }

        class SubFile
        {
            public string FileName;
            public uint FileID;
        }

        class DirNode
        {
            public string DirName;
            public LinkedList<DirNode> SubDirs;
            public LinkedList<SubFile> SubFiles;
        }

        void MyWriteSizedString(BinaryWriter w, string str)
        {
            if (str.Length > UInt16.MaxValue)
                throw new Exception();

            w.Write((UInt16)str.Length);
            if (str.Length > 0)
                w.Write((char[])str.ToCharArray());
        }

        string MyReadSizedString(BinaryReader r)
        {
            ushort size = r.ReadUInt16();
            return size == 0 ? "" : new string(r.ReadChars(size));
        }

        void OutputDirStream(DirNode node, BinaryWriter w)
        {
            if (w.BaseStream is MemoryStream == false)
                throw new Exception();

            MyWriteSizedString(w, node.DirName);

            if (node.SubDirs.Count > UInt16.MaxValue)
                throw new Exception();
            w.Write((UInt16)node.SubDirs.Count);
            if (node.SubDirs.Count > 0)
            {
                foreach (DirNode d in node.SubDirs)
                {
                    OutputDirStream(d, w);
                }
            }

            if (node.SubFiles.Count > UInt16.MaxValue)
                throw new Exception();
            w.Write((UInt16)node.SubFiles.Count);
            if (node.SubFiles.Count > 0)
            {
                foreach (SubFile f in node.SubFiles)
                {
                    MyWriteSizedString(w, f.FileName);
                    w.Write((UInt32)f.FileID);
                }
            }
        }

        void InputDirStream(BinaryReader r, DirNode node)
        {
            if (r.BaseStream is MemoryStream == false)
                throw new Exception();

            node.DirName = MyReadSizedString(r);

            UInt16 numSubDirs = r.ReadUInt16();
            node.SubDirs = new LinkedList<DirNode>();
            if (numSubDirs > 0)
            {
                for (UInt16 i = 0; i < numSubDirs; i++)
                {
                    DirNode tmp = new DirNode();
                    node.SubDirs.AddLast(tmp);
                    InputDirStream(r, tmp);
                }
            }

            UInt16 numSubFiles = r.ReadUInt16();
            node.SubFiles = new LinkedList<SubFile>();
            if (numSubFiles > 0)
            {
                for (UInt16 i = 0; i < numSubFiles; i++)
                {
                    SubFile tmp = new SubFile();
                    node.SubFiles.AddLast(tmp);
                    tmp.FileName = MyReadSizedString(r);
                    tmp.FileID = r.ReadUInt32();
                }
            }
        }

        byte[] ReadDirStreamFromDisk(IntPtr handle, uint offsetSector)
        {
            byte[] bufLen = ReadSectors(handle, offsetSector, 1);
            uint len = BitConverter.ToUInt32(bufLen, 0);

            uint numAllSectors = (uint)len % (uint)512u == 0 ? (uint)len / (uint)512u : (uint)len / (uint)512 + 1;
            List<byte> bytes = new List<byte>((int)numAllSectors * 512);

            NumSubStatus = NumStatus = numAllSectors;
            SubStatus = Status = 0;

            for (uint i = 0; i < numAllSectors; i += 1024)
            {
                SubStatus = Status = i;

                if (numAllSectors - i >= 1024)
                {
                    bytes.AddRange(ReadSectors(handle, offsetSector + 1 + i, 1024));
                }
                else
                {
                    bytes.AddRange(ReadSectors(handle, offsetSector + 1 + i, (ushort)(numAllSectors - i)));
                }
            }

            NumSubStatus = NumStatus = 0;
            SubStatus = Status = 0;

            byte[] _bytes = new byte[len];
            bytes.CopyTo(0, _bytes, 0, (int)len);

            return _bytes;
        }

        void WriteDirStreamToDisk(IntPtr handle, uint offsetSector, byte[] bytes)
        {
            byte[] bufLen = new byte[512];
            BitConverter.GetBytes((UInt32)bytes.Length).CopyTo(bufLen, 0);

            WriteSectors(handle, offsetSector, 1, bufLen);

            List<byte[]> _bytes = new List<byte[]>();

            for (int i = 0; i < bytes.Length; i += 512 * 1024)
            {
                if (bytes.Length - i >= 512 * 1024)
                {
                    byte[] tmp = new byte[512 * 1024];
                    Array.Copy(bytes, i, tmp, 0, 512 * 1024);
                    _bytes.Add(tmp);
                }
                else
                {
                    int tSize = bytes.Length - i;
                    int _tSize = (int)tSize % (int)512 == 0 ? (int)tSize / (int)512 : ((int)tSize / (int)512) * 512 + 512;
                    byte[] tmp = new byte[_tSize];
                    Array.Copy(bytes, bytes.Length - tSize, tmp, 0, tSize);
                    _bytes.Add(tmp);
                }
            }

            NumSubStatus = NumStatus = (uint)_bytes.Count;
            SubStatus = Status = 0;

            for (int i = 0; i < _bytes.Count; i++)
            {
                SubStatus = Status = (uint)i;

                WriteSectors(handle, offsetSector + 1 + (uint)(i * 1024), (ushort)(_bytes[i].Length / 512), _bytes[i]);
            }

            NumSubStatus = NumStatus = 0;
            SubStatus = Status = 0;
        }

        void CreateTree(DirectoryInfo mainDirInfo, out DirNode root, out List<string> files)
        {
            root = new DirNode();
            root.DirName = "";

            files = new List<string>();

            root.SubDirs = new LinkedList<DirNode>();
            DirectoryInfo[] dirInfos = mainDirInfo.GetDirectories();
            if (dirInfos.Length > 0)
            {
                foreach (DirectoryInfo d in dirInfos)
                {
                    DirNode tmp = new DirNode();
                    root.SubDirs.AddLast(tmp);
                    CreateTreeRec(d, tmp, files);
                }
            }

            root.SubFiles = new LinkedList<SubFile>();
            FileInfo[] fileInfos = mainDirInfo.GetFiles();
            if (fileInfos.Length > 0)
            {
                foreach (FileInfo f in fileInfos)
                {
                    SubFile tmp = new SubFile();
                    root.SubFiles.AddLast(tmp);
                    tmp.FileName = f.Name;
                    files.Add(f.FullName);
                    tmp.FileID = (uint)(files.Count - 1);
                }
            }
        }

        void CreateTreeRec(DirectoryInfo dirInfo, DirNode node, List<string> files)
        {
            node.DirName = dirInfo.Name;

            node.SubDirs = new LinkedList<DirNode>();
            DirectoryInfo[] dirInfos = dirInfo.GetDirectories();
            if (dirInfos.Length > 0)
            {
                foreach (DirectoryInfo d in dirInfos)
                {
                    DirNode tmp = new DirNode();
                    node.SubDirs.AddLast(tmp);
                    CreateTreeRec(d, tmp, files);
                }
            }

            node.SubFiles = new LinkedList<SubFile>();
            FileInfo[] fileInfos = dirInfo.GetFiles();
            if (fileInfos.Length > 0)
            {
                foreach (FileInfo f in fileInfos)
                {
                    SubFile tmp = new SubFile();
                    node.SubFiles.AddLast(tmp);
                    tmp.FileName = f.Name;
                    files.Add(f.FullName);
                    tmp.FileID = (uint)(files.Count - 1);
                }
            }
        }

        struct FileDesc
        {
            public uint OffsetSector;
            public uint NumSectors;
            public ushort SizeLastSector;
        }

        void MakeAll(IntPtr handle, List<string> files, byte[] dirStream)
        {
            uint numFiles = (uint)files.Count;

            uint offsetSectorFileCount = 2;
            uint offsetSectorOfOffsetSectorDirStream = offsetSectorFileCount + 1;
            uint offsetSectorFileTable = offsetSectorOfOffsetSectorDirStream + 1;
            uint offsetSectorFiles = offsetSectorFileTable + numFiles;

            FileDesc[] fileTable = new FileDesc[numFiles];

            FileInfo _fileInfo = new FileInfo(files[0]);

            fileTable[0].OffsetSector = offsetSectorFiles;
            fileTable[0].SizeLastSector = (ushort)(_fileInfo.Length % 512 == 0 ? 512 : (_fileInfo.Length % 512));
            fileTable[0].NumSectors = (uint)(_fileInfo.Length / 512 + (fileTable[0].SizeLastSector == 512 ? 0 : 1));

            for (int i = 1; i < numFiles; i++)
            {
                FileInfo fileInfo = new FileInfo(files[i]);

                fileTable[i].OffsetSector = fileTable[i - 1].OffsetSector + fileTable[i - 1].NumSectors;
                fileTable[i].SizeLastSector = (ushort)(fileInfo.Length % 512 == 0 ? 512 : (fileInfo.Length % 512));
                fileTable[i].NumSectors = (uint)(fileInfo.Length / 512 + (fileTable[i].SizeLastSector == 512 ? 0 : 1));
            }

            uint offsetSectorDirStream = fileTable[numFiles - 1].OffsetSector + fileTable[numFiles - 1].NumSectors;

            List<byte[]> bytes = new List<byte[]>();

            byte[] bytesFileCount = new byte[512];
            BitConverter.GetBytes(numFiles).CopyTo(bytesFileCount, 0);
            bytes.Add(bytesFileCount);

            byte[] bytesOffsetSectorDirStream = new byte[512];
            BitConverter.GetBytes(offsetSectorDirStream).CopyTo(bytesOffsetSectorDirStream, 0);
            bytes.Add(bytesOffsetSectorDirStream);

            for (int i = 0; i < numFiles; i++)
            {
                byte[] bytesFileDesc = new byte[512];
                BitConverter.GetBytes((UInt32)fileTable[i].OffsetSector).CopyTo(bytesFileDesc, 0);
                BitConverter.GetBytes((UInt32)fileTable[i].NumSectors).CopyTo(bytesFileDesc, 4);
                BitConverter.GetBytes((UInt16)fileTable[i].SizeLastSector).CopyTo(bytesFileDesc, 8);
                bytes.Add(bytesFileDesc);
            }

            List<byte[]> _bytes = new List<byte[]>();

            for (int i = 0; i < bytes.Count; i += 1024)
            {
                if (bytes.Count - i >= 1024)
                {
                    byte[] tmp = new byte[512 * 1024];
                    for (int j = 0; j < 1024; j++)
                        bytes[i + j].CopyTo(tmp, j * 512);
                    _bytes.Add(tmp);
                }
                else
                {
                    byte[] tmp = new byte[512 * (bytes.Count - i)];
                    for (int j = 0; j < bytes.Count - i; j++)
                        bytes[i + j].CopyTo(tmp, j * 512);
                    _bytes.Add(tmp);
                }
            }

            NumStatus = 1 + numFiles;
            Status = 0;

            NumSubStatus = (uint)_bytes.Count;
            SubStatus = 0;

            for (int i = 0; i < _bytes.Count; i++)
            {
                SubStatus = (uint)i;

                WriteSectors(handle, offsetSectorFileCount + (uint)(i * 1024), (ushort)(_bytes[i].Length / 512), _bytes[i]);
            }

            for (int i = 0; i < numFiles; i++)
            {
                Status = (uint)(1 + i);

                FileStream fs = new FileStream(files[i], FileMode.Open, FileAccess.Read, FileShare.Read);
                BinaryReader r = new BinaryReader(fs);

                NumSubStatus = fileTable[i].NumSectors;
                SubStatus = 0;

                for (int j = 0; j < fileTable[i].NumSectors; j += 1024)
                {
                    SubStatus = (uint)j;

                    if (fileTable[i].NumSectors - j > 1024)
                    {
                        byte[] buffer = r.ReadBytes(512 * 1024);
                        WriteSectors(handle, fileTable[i].OffsetSector + (uint)j, 1024, buffer);
                    }
                    else if (fileTable[i].NumSectors - j == 1024)
                    {
                        byte[] _buffer = r.ReadBytes(512 * 1023 + fileTable[i].SizeLastSector);
                        byte[] buffer = new byte[512 * 1024];
                        _buffer.CopyTo(buffer, 0);
                        WriteSectors(handle, fileTable[i].OffsetSector + (uint)j, 1024, buffer);
                    }
                    else
                    {
                        byte[] _buffer = r.ReadBytes((int)((fileTable[i].NumSectors - j - 1) * 512 + fileTable[i].SizeLastSector));
                        if (fs.Position != fs.Length)
                            throw new Exception();
                        byte[] buffer = new byte[(fileTable[i].NumSectors - j) * 512];
                        _buffer.CopyTo(buffer, 0);
                        WriteSectors(handle, fileTable[i].OffsetSector + (uint)j, (ushort)(buffer.Length / 512), buffer);
                    }
                }

                r.Close();
            }

            NumSubStatus = NumStatus = 0;
            SubStatus = Status = 0;

            WriteDirStreamToDisk(handle, offsetSectorDirStream, dirStream);
        }

        uint GetOffsetSectorDirStream(IntPtr handle)
        {
            uint offsetSectorFileCount = 2;
            uint offsetSectorOfOffsetSectorDirStream = offsetSectorFileCount + 1;
            //uint offsetSectorFileTable = offsetSectorOfOffsetSectorDirStream + 1;

            byte[] bytes = ReadSectors(handle, offsetSectorOfOffsetSectorDirStream, 1);

            for (int i = 4; i < bytes.Length; i++)
                if (bytes[i] != 0)
                    throw new Exception();

            return BitConverter.ToUInt32(bytes, 0);
        }

        void GetFile(IntPtr handle, uint fileID, DirectoryInfo dirInfoSaveTo, string fileNameSaveTo, bool overwrite)
        {
            uint offsetSectorFileCount = 2;
            uint offsetSectorOfOffsetSectorDirStream = offsetSectorFileCount + 1;
            uint offsetSectorFileTable = offsetSectorOfOffsetSectorDirStream + 1;

            byte[] bytes = ReadSectors(handle, offsetSectorFileTable + fileID, 1);

            for (int i = 12; i < bytes.Length; i++)
                if (bytes[i] != 0)
                    throw new Exception();

            FileDesc fileDesc = new FileDesc();
            fileDesc.OffsetSector = BitConverter.ToUInt32(bytes, 0);
            fileDesc.NumSectors = BitConverter.ToUInt32(bytes, 4);
            fileDesc.SizeLastSector = BitConverter.ToUInt16(bytes, 8);

            FileStream fs = new FileStream(dirInfoSaveTo.FullName + '\\' + fileNameSaveTo, overwrite ? FileMode.Create : FileMode.CreateNew, FileAccess.Write, FileShare.None);
            BinaryWriter w = new BinaryWriter(fs);

            NumSubStatus = NumStatus = fileDesc.NumSectors;
            SubStatus = Status = 0;

            for (int i = 0; i < fileDesc.NumSectors; i += 1024)
            {
                SubStatus = Status = (uint)i;

                if (fileDesc.NumSectors - i > 1024)
                {
                    byte[] buffer = ReadSectors(handle, fileDesc.OffsetSector + (uint)i, 1024);
                    w.Write(buffer);
                }
                else if (fileDesc.NumSectors - i == 1024)
                {
                    byte[] buffer = ReadSectors(handle, fileDesc.OffsetSector + (uint)i, 1024);
                    w.Write(buffer, 0, 1023 * 512 + fileDesc.SizeLastSector);
                }
                else
                {
                    byte[] buffer = ReadSectors(handle, fileDesc.OffsetSector + (uint)i, (ushort)(fileDesc.NumSectors - i));
                    w.Write(buffer, 0, buffer.Length - 512 + fileDesc.SizeLastSector);
                }
            }

            NumSubStatus = NumStatus = 0;
            SubStatus = Status = 0;

            w.Close();
        }

        void FormatQuick(IntPtr handle)
        {
            byte[] bytes = new byte[512 * 2];
            for (int i = 0; i < bytes.Length; i++)
                bytes[i] = 0x88;

            WriteSectors(handle, 0, 2, bytes);
        }

        bool CheckFormat(IntPtr handle)
        {
            byte[] bytes = ReadSectors(handle, 0, 2);

            foreach (byte b in bytes)
                if (b != 0x88)
                    return false;

            return true;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            byte number;
            try
            {
                number = byte.Parse(textBox3.Text);
            }
            catch (Exception)
            {
                MessageBox.Show("Invalid HDD number!");
                return;
            }

            DirectoryInfo path;
            try
            {
                path = new DirectoryInfo(textBox1.Text);
            }
            catch (Exception)
            {
                MessageBox.Show("Path is not found!");
                return;
            }

            IntPtr handle_;
            try
            {
                handle_ = CreateForRead(number);
            }
            catch (Exception)
            {
                MessageBox.Show("HDD is not found!");
                return;
            }

            bool b = CheckFormat(handle_);
            CloseHandle(handle_);

            if (!b)
            {
                MessageBox.Show("Unsupported HDD format!");
                return;
            }

            MemoryStream ms = new MemoryStream();
            BinaryWriter w = new BinaryWriter(ms);

            DirNode root;
            List<string> files;
            CreateTree(path, out root, out files);

            OutputDirStream(root, w);

            byte[] bytes = ms.ToArray();
            ms.Close();

            IntPtr handle = CreateForWrite(number);

            button1.Enabled = button2.Enabled = button3.Enabled = button4.Enabled = false;
            bool flag = false;
            Thread thread = new Thread(delegate()
            {
                try
                {
                    MakeAll(handle, files, bytes);
                    flag = true;
                }
                catch (Exception)
                {
                    flag = false;
                }
            });
            thread.Start();
            while (thread.ThreadState == ThreadState.Running)
            {
                Application.DoEvents();

                progressBar1.Minimum = 0;
                progressBar1.Maximum = NumStatus == 0 ? 0 : (int)(NumStatus - 1);
                progressBar1.Value = (int)Status;

                progressBar2.Minimum = 0;
                progressBar2.Maximum = NumSubStatus == 0 ? 0 : (int)(NumSubStatus - 1);
                progressBar2.Value = (int)SubStatus;
            }
            button1.Enabled = button2.Enabled = button3.Enabled = button4.Enabled = true;
            
            CloseHandle(handle);

            MessageBox.Show(flag ? "Done!" : "Failed!");
        }

        void ShowDirs(DirNode node, TreeNodeCollection viewNodes)
        {
            if (node.SubDirs.Count > 0)
            {
                foreach (DirNode d in node.SubDirs)
                {
                    TreeNode tmp = new TreeNode();
                    tmp.Text = d.DirName + "    <DIR>";
                    tmp.Tag = null;
                    viewNodes.Add(tmp);

                    ShowDirs(d, tmp.Nodes);
                }
            }
            
            if (node.SubFiles.Count > 0)
            {
                foreach (SubFile f in node.SubFiles)
                {
                    TreeNode tmp = new TreeNode();
                    tmp.Text = f.FileName;
                    tmp.Tag = f.FileID;
                    viewNodes.Add(tmp);
                }
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            byte number;
            try
            {
                number = byte.Parse(textBox4.Text);
            }
            catch (Exception)
            {
                MessageBox.Show("Invalid HDD number!");
                return;
            }

            IntPtr handle_;
            try
            {
                handle_ = CreateForRead(number);
            }
            catch (Exception)
            {
                MessageBox.Show("HDD is not found!");
                return;
            }

            bool b = CheckFormat(handle_);
            CloseHandle(handle_);

            if (!b)
            {
                MessageBox.Show("Unsupported HDD format!");
                return;
            }

            IntPtr handle = CreateForRead(number);
            DirNode root = new DirNode();
            InputDirStream(new BinaryReader(new MemoryStream(ReadDirStreamFromDisk(handle, GetOffsetSectorDirStream(handle)))), root);
            CloseHandle(handle);

            treeView1.Nodes.Clear();
            ShowDirs(root, treeView1.Nodes);

            treeView1.Tag = number;

            MessageBox.Show("Done!");
        }

        private void button3_Click(object sender, EventArgs e)
        {
            if (treeView1.SelectedNode == null || treeView1.SelectedNode.Tag == null)
            {
                MessageBox.Show("No file is selected!");
                return;
            }

            byte number = (byte)treeView1.Tag;
            textBox4.Text = number.ToString();

            DirectoryInfo path;
            try
            {
                path = new DirectoryInfo(textBox2.Text);
            }
            catch (Exception)
            {
                MessageBox.Show("Path is not found!");
                return;
            }

            IntPtr handle_;
            try
            {
                handle_ = CreateForRead(number);
            }
            catch (Exception)
            {
                MessageBox.Show("HDD is not found!");
                return;
            }

            bool b = CheckFormat(handle_);
            CloseHandle(handle_);

            if (!b)
            {
                MessageBox.Show("Unsupported HDD format!");
                return;
            }

            IntPtr handle = CreateForRead(number);

            button1.Enabled = button2.Enabled = button3.Enabled = button4.Enabled = false;
            uint fileID = (uint)treeView1.SelectedNode.Tag;
            string fileNameSaveTo = treeView1.SelectedNode.Text;
            bool overwrite = checkBox1.Checked;
            bool flag = false;
            Thread thread = new Thread(delegate()
            {
                try
                {
                    GetFile(handle, fileID, path, fileNameSaveTo, overwrite);
                    flag = true;
                }
                catch (Exception)
                {
                    flag = false;
                }
            });
            thread.Start();
            while (thread.ThreadState == ThreadState.Running)
            {
                Application.DoEvents();

                progressBar1.Minimum = 0;
                progressBar1.Maximum = NumStatus == 0 ? 0 : (int)(NumStatus - 1);
                progressBar1.Value = (int)Status;

                progressBar2.Minimum = 0;
                progressBar2.Maximum = NumSubStatus == 0 ? 0 : (int)(NumSubStatus - 1);
                progressBar2.Value = (int)SubStatus;
            }
            button1.Enabled = button2.Enabled = button3.Enabled = button4.Enabled = true;

            CloseHandle(handle);

            MessageBox.Show(flag ? "Done!" : "Failed!");
        }

        private void button4_Click(object sender, EventArgs e)
        {
            byte number;
            try
            {
                number = byte.Parse(textBox5.Text);
            }
            catch (Exception)
            {
                MessageBox.Show("Invalid HDD number!");
                return;
            }

            IntPtr handle_;
            try
            {
                handle_ = CreateForRead(number);
            }
            catch (Exception)
            {
                MessageBox.Show("HDD is not found!");
                return;
            }

            bool b = CheckFormat(handle_);
            CloseHandle(handle_);

            if (b)
            {
                MessageBox.Show("Already formatted!");
                return;
            }
            else
            {
                if (MessageBox.Show("Not formatted, format now?", "Format", MessageBoxButtons.OKCancel) == DialogResult.OK)
                {
                    IntPtr handle = CreateForWrite(number);
                    FormatQuick(handle);
                    CloseHandle(handle);

                    MessageBox.Show("Done!");
                }
            }
        }
    }
}