Read/Write Disk のソースコードです (C# & win32)

Download source files:
http://www.jkofsp.net/files/

<Form1.cs>

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);
               try
               {
                   progressBar1.Value = (int)Status;
               }
               catch (Exception) { }

               progressBar2.Minimum = 0;
               progressBar2.Maximum = NumSubStatus == 0 ? 0 : (int)(NumSubStatus - 1);
               try
               {
                   progressBar2.Value = (int)SubStatus;
               }
               catch (Exception) { }
           }
           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);
               try
               {
                   progressBar1.Value = (int)Status;
               }
               catch (Exception) { }

               progressBar2.Minimum = 0;
               progressBar2.Maximum = NumSubStatus == 0 ? 0 : (int)(NumSubStatus - 1);
               try
               {
                   progressBar2.Value = (int)SubStatus;
               }
               catch (Exception) { }
           }
           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!");
               }
           }
       }
   }
}