using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Management;
using System.Linq;
using System.Text;
using System.Collections;
using System.Windows.Forms;
 
namespace SmartView
{
    #region ReadSmartResult Enum
    public enum ReadSmartResult
    {
        DRIVE_DOES_NOT_EXIST = 0,
        ACCESS_DENIED = 1,
        NO_SMART_AVAILABLE = 2,
        SUCCEEDED = 3
    }
    #endregion
 
    #region Attributes Enum
    public enum Attributes
    {
        // Invalid attribute identifier
        SMART_ATTRIB_Invalid = 0,
        // Frequency of errors while reading raw data
        SMART_ATTRIB_RAW_READ_ERROR_RATE = 1,
        // Average efficiency of a hard disk
        SMART_ATTRIB_THROUGHPUT_PERFORMANCE = 2,
        // needed to spin up
        SMART_ATTRIB_SPIN_UP_TIME = 3,
        // Number of spindle start/stop cycles
        SMART_ATTRIB_START_STOP_COUNT = 4,
        // Quantity of remapped sectors
        SMART_ATTRIB_REALLOCATION_SECTOR_COUNT = 5,
        // Reserve of channel while reading
        SMART_ATTRIB_Read_Channel_Margin = 6,
        // Frequency of errors while positioning
        SMART_ATTRIB_SEEK_ERROR_RATE = 7,
        // Average efficiency of operations while positioning
        SMART_ATTRIB_Seek_TimerPerformance = 8,
        // Number of hours elapsed in the power-on state
        SMART_ATTRIB_POWER_ON_HOURS_COUNT = 9,
        // Number of retry attempts to spin up
        SMART_ATTRIB_SPIN_RETRY_COUNT = 10,
        // count Number of attempts to calibrate the device
        SMART_ATTRIB_RECALIBRATION_RETRIES = 11,
        // Number of power-on events
        SMART_ATTRIB_DEVICE_POWER_CYCLE_COUNT = 12,
        // Frequency of ‘program’ errors while reading from a disk
        SMART_ATTRIB_SOFT_READ_ERROR_RATE = 13,
        // Fequency of mistakes as a result of impact loads
        SMART_ATTRIB_AIRFLOW_TEMPERATURE = 190,
        // Fequency of mistakes as a result of impact loads
        SMART_ATTRIB_G_Sense_Error_Rate = 191,
        // Number of power-off or emergency retract cycles
        SMART_ATTRIB_Power_Off_Retract_Count = 192,
        // Number of cycles into landing zone position
        SMART_ATTRIB_LOAD_UNLOAD_CYCLE_COUNT = 193,
        // Temperature of a hard disk assembly
        SMART_ATTRIB_HDA_TEMPERATURE = 194,
        // Number of ECC on-the-fly errors
        SMART_ATTRIB_Hardware_ECC_Recovered = 195,
        // Number of remapping operations
        SMART_ATTRIB_REALLOCATION_COUNT = 196,
        // Number of unstable sectors (waiting for remapping)
        SMART_ATTRIB_CURRENT_PENDING_SECTOR_COUNT = 197,
        // Number of uncorrected errors
        SMART_ATTRIB_UNCORRECTABLE_SECTOR_COUNT = 198,
        // Number of CRC errors during UDMA mode
        SMART_ATTRIB_ULTRA_DMA_CRC_ERROR_COUNT = 199,
        // Number of errors while writing to disk (or) multi-zone 
        // error rate (or) flying height
        SMART_ATTRIB_WRITE_ERROR_RATE = 200,
        // Number of off-track errors
        SMART_ATTRIB_Soft_Read_Error_Count = 201,
        // Number of Data Address Mark (DAM) errors (or) vendor-specific
        SMART_ATTRIB_Data_Address_Mark_Errors = 202,
        // Number of ECC errors
        SMART_ATTRIB_Run_Out_Cancel = 203,
        // Number of errors corrected by software ECC
        SMART_ATTRIB_Soft_ECC_Correction = 204,
        // Number of thermal asperity errors
        SMART_ATTRIB_Thermal_Asperity_Rate = 205,
        // Height of heads above the disk surface
        SMART_ATTRIB_Flying_Height = 206,
        // Amount of high current used to spin up the drive
        SMART_ATTRIB_Spin_High_Current = 207,
        // Number of buzz routines to spin up the drive
        SMART_ATTRIB_Spin_Buzz = 208,
        // Drive’s seek performance during offline operations
        SMART_ATTRIB_Offline_Seek_Performance = 209,
        // Shift of disk is possible as a result of strong shock loading 
        // in the store, as a result of falling (or) temperature
        SMART_ATTRIB_Disk_Shift = 220,
        // Number of errors as a result of impact loads as detected 
        // by a shock sensor
        SMART_ATTRIB_G_SENSE_ERROR_Count = 221,
        // Number of hours in general operational state
        SMART_ATTRIB_Loaded_Hours = 222,
        // Loading on drive caused by numerous recurrences of operations, 
        // like reading, recording, positioning of heads, etc.
        SMART_ATTRIB_Load_Unload_Retry_Count = 223,
        // Load on drive caused by friction in mechanical parts of the store
        SMART_ATTRIB_Load_Friction = 224,
        // Total number of load cycles
        SMART_ATTRIB_Load_Unload_Cycle_Count1 = 225,
        // General time for loading in a drive
        SMART_ATTRIB_Load_In_Time = 226,
        // Quantity efforts of the rotating moment of a drive
        SMART_ATTRIB_Torque_Amplification_Count = 227,
        // Number of power-off retract events.
        SMART_ATTRIB_POWER_OFF_RETRACT_COUNT1 = 228,
        // Amplitude of heads trembling (GMR-head) in running mode
        SMART_ATTRIB_GMR_Head_Amplitude = 230,
        // Temperature of a drive
        SMART_ATTRIB_Drive_Temperature = 231,
        // Time while head is positioning
        SMART_ATTRIB_Head_Flying_Hours = 240,
        // Number of errors while reading from a disk
        SMART_ATTRIB_Read_Error_Retry_Rate = 250
    }
    #endregion
 
    public class Smart
    {
        public string[] Drives;
        public string[] Names;
        public STORAGE_PREDICT_FAILURE SmartData;
 
        #region Konstanten
        private const int IOCTL_STORAGE_PREDICT_FAILURE = 0x2D1100; // uint könnte probleme geben
        private const uint STATUS_INVALID_DEVICE_REQUEST = 0xC0000010;
 
        private const short FILE_SHARE_NONE = 0;
        private const short OPEN_EXISTING = 3;
        private const short INVALID_HANDLE_VALUE = -1;
        private const uint GENERIC_READ = 0x80000000; // fehler beim casten?
        private const int GENERIC_WRITE = 0x40000000;
        private const int FILE_SHARE_READ = 1;
        private const int FILE_SHARE_WRITE = 2;
        #endregion
 
        #region DLL Deklaration
        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern IntPtr CreateFile(string lpFileName,
                                                uint dwDesiredAccess,
                                                int dwShareMode,
                                                IntPtr lpSecurityAttributes,
                                                int dwCreationDisposition,
                                                int dwFlagsAndAttributes,
                                                IntPtr hTemplateFile);
 
        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern bool CloseHandle(IntPtr hObject);
 
        [DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int DeviceIoControl(IntPtr hDevice,
                                                  int dwioControlCode,
                                                  IntPtr lpInBuffer,
                                                  int nInBufferSize,
                                                  out STORAGE_PREDICT_FAILURE lpOutBuffer,
                                                  int nOutBufferSize,
                                                  ref int lpBytesReturned,
                                                  IntPtr lpOverlapped);
        #endregion
 
        #region Funktionen
        // Festplatten (und auch USB-Laufwerke) per WMI ermitteln
        public int GetPhysicalDrives()
        {
            ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive");
            Hashtable ht = new Hashtable();
            int i = 0;
 
            ManagementObjectCollection moc = searcher.Get();
            Drives = new string[moc.Count];
            Names = new string[moc.Count];
 
            try
            {
                foreach (ManagementObject wmi_HD in moc)
                {
                    ht.Add(wmi_HD.Properties["deviceid"].Value, wmi_HD.Properties["caption"].Value);
 
                    // Hier kommt die Exception
                    Drives[i] = wmi_HD.Properties["deviceid"].Value.ToString();
                    Names[i] = wmi_HD.Properties["caption"].Value.ToString();
                    i++;
                }
 
                return i;
            }
            catch (Exception ex)
            {
                return 0;
            }
            finally
            {
                ht = null;
            }
        }
 
        // Smart-Werte für angegebenes Laufwerk lesen
        // stehen danach in SmartData zur Verfügung
        public ReadSmartResult ReadSmart(string Drive)
        {
            IntPtr Device;
            bool Result;
            int ReturnedBytes = 0;
 
            this.SmartData = new STORAGE_PREDICT_FAILURE();
 
            IntPtr zeroPtr = new IntPtr(0);
 
            // Laufwerk öffnen
            Device = CreateFile(Drive,
                                GENERIC_READ,
                                FILE_SHARE_READ,
                                IntPtr.Zero,
                                OPEN_EXISTING,
                                0,
                                IntPtr.Zero);
 
            if (Device.ToInt32() == INVALID_HANDLE_VALUE)
            {
                if (Marshal.GetLastWin32Error() == 2)
                {
                    //Zugriff verweigert, wahrscheinlich fehlen Adminrechte
                    return ReadSmartResult.ACCESS_DENIED;
                }
                else
                {
                    // das angegebene Laufwerk existiert nicht
                    return ReadSmartResult.DRIVE_DOES_NOT_EXIST;
                }
            }
 
            // S.M.A.R.T. auslesen
            Result = Convert.ToBoolean(DeviceIoControl(Device,
                                                       IOCTL_STORAGE_PREDICT_FAILURE,
                                                       IntPtr.Zero,
                                                       0,
                                                       out SmartData,
                                                       Marshal.SizeOf(SmartData),
                                                       ref ReturnedBytes,
                                                       IntPtr.Zero));
 
            CloseHandle(Device);
 
            if (Result)
            {
                // erfolgreich
                return ReadSmartResult.SUCCEEDED;
            }
            else
            {
                // es konnten keine S.M.A.R.T. Eigenschaften gelesen werden
                return ReadSmartResult.NO_SMART_AVAILABLE;
            }
        }
 
        // Attributsnamen (falls vohanden) ausgeben
        public string GetAttribute(Attributes Index)
        {
            string outString;
 
            outString = Index.ToString();
            // Wenn outString noch numerisch ist, dann ist kein 
            // Beschreibungstext in der Definition angegeben, 
            // Ersatztext wird ausgegeben
            if (IsNumeric(outString))
                outString = "<Herstellerspezifisch>";
 
            return outString;
        }
 
        // Smart-Wert auswerten, 12Byte beginnend ab Offset
        // Offset = X * 12 + 2
        public void GetSmartValue(int Offset,
                                  ref int Attribut,
                                  ref long Value,
                                  ref long Worst,
                                  ref long Data)
        {
 
            // Der S.M.A.R.T.-Wert setzt sich aus 12Byte zusammen
            // 1. Byte - Attributesnamen
            Attribut = SmartData.VendorSpecific[Offset];
            // 2./3. Byte - Herstellerspezifisch
            // interessant ist hier das 1. Bit, falls der Wert dieses 
            // Smartwertes unter dem Grenzwert liegt, gibt dieses bit an, 
            // ob die Festplatte innerhalb der nächsten 24h ausfallen wird!
            // 4. Byte - Wert
            Value = SmartData.VendorSpecific[Offset + 3];
            // 5.-12. Byte - RAW-Value (herstellerspezifisch)
            Worst = SmartData.VendorSpecific[Offset + 4];
            string str = "";
 
            for (int i = 11; i <= 5; i--)
            {
                str += Convert.ToString((SmartData.VendorSpecific[Offset + i]), 16);
            }
 
            Data = Convert.ToInt64(str, 16);
        }
        #endregion
 
        // Werte aus SmartData in Listview eintragen
        public void AddSmartToListView(ListView lv, int Index)
        {
            int Attribut = 0;
            long Value = 0, Worst = 0, Data = 0;
 
            for (int i = 0; i <= 29; i++)
            {
                GetSmartValue(i * 12 + 2, ref Attribut, ref Value, ref Worst, ref Data);
                // 0 ist kein gültiger Wert, d.h. dieser Speicherblock enthält
                // kein Attribut
                if (!Attribut.Equals(Attributes.SMART_ATTRIB_Invalid))
                {
                    // ins Listview eintragen
                    ListViewItem lvi = new ListViewItem();
 
                    //Attributes at = new Attributes();
                    //string att = Enum.GetName(typeof(Attributes), Attribut);
 
                    Attributes at = (Attributes)Enum.Parse(typeof(Attributes), Convert.ToString(Attribut));
 
                    //string attributeName = Enum.GetName(typeof(Attributes), Convert.ToString(1));
                    //Attributes attr = (Attributes) Enum.Parse(typeof(Attributes), attributeName);
 
                    lvi.Text = Attribut + " - " + GetAttribute(at);
                    lvi.SubItems.Add(Value.ToString());
                    lvi.SubItems.Add(Worst.ToString());
                    lvi.SubItems.Add(Data.ToString());
 
                    for (int j = 0; j <= lv.Groups.Count - 1; i++)
                    {
                        if (lv.Groups[j].Name == "LW" + Index)
                            lvi.Group = lv.Groups[j];
                    }
 
                    lv.Items.Add(lvi);
                }
            }
        }
 
        #region Hilfsklasse zur Zwischenspeicherung
        [StructLayout(LayoutKind.Sequential)]
        public class STORAGE_PREDICT_FAILURE
        {
 
            public int PredictFailure;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 512)]
 
            public byte[] VendorSpecific;
 
            public STORAGE_PREDICT_FAILURE()
            {
                VendorSpecific = new byte[511];
            }
        }
        #endregion
 
        #region IsNumeric Methode
        // IsNumeric Function
        static bool IsNumeric(object Expression)
        {
            // Variable to collect the Return value of the TryParse method.
            bool isNum;
 
            // Define variable to collect out parameter of the TryParse method. If the conversion fails, the out parameter is zero.
            double retNum;
 
            // The TryParse method converts a string in a specified style and culture-specific format to its double-precision floating point number equivalent.
            // The TryParse method does not generate an exception if the conversion fails. If the conversion passes, True is returned. If it does not, False is returned.
            isNum = Double.TryParse(Convert.ToString(Expression), System.Globalization.NumberStyles.Any, System.Globalization.NumberFormatInfo.InvariantInfo, out retNum);
            return isNum;
        }
        #endregion
    }
}

private void button1_Click(object sender, EventArgs e)
        { 
            Smart smart = new Smart();
            listView1.Items.Clear();
            listView1.Groups.Clear();
 
            // Laufwerke ermitteln
            int j = smart.GetPhysicalDrives() - 1;
 
            // S.M.A.R.T. Eigenschaften auslesen und ins Listview eintragen
            for(int i = 0; i <= j; i++) {
                switch(smart.ReadSmart(smart.Drives[i])) {
                    case ReadSmartResult.SUCCEEDED:
                        // S.M.A.R.T.-Werte wurden ausgelesen und werden 
                        // ins Listview eingetragen
                        listView1.Groups.Add("LW" + i, smart.Names[i] + "  (" + smart.Drives[i] + ")");
                        smart.AddSmartToListView(listView1, i);
                        break;
                    case ReadSmartResult.NO_SMART_AVAILABLE:
                        // S.M.A.R.T. ist für dieses Laufwerk nicht verfügbar
                        listView1.Groups.Add("LW" + i, smart.Names[i] + "  (" + smart.Drives[i] + ")");
                        ListViewItem lvi = new ListViewItem();
                        lvi.Text = "S.M.A.R.T. not available";
                        lvi.Group = listView1.Groups[i];
                        listView1.Items.Add(lvi);
                        break;
                    case ReadSmartResult.ACCESS_DENIED:
                        // Zugriff uafs Laufwerk verweigert, wahrscheinlich fehlen 
                        // Adminrechte (v.a. unter Vista)
                        listView1.Groups.Add("LW" + i, smart.Names[i] + "  (" + smart.Drives[i] + ")");
                        ListViewItem lvi2 = new ListViewItem();
                        lvi2.Text = "Zugriff verweigert, Administratorrechte benötigt!";
                        lvi2.Group = listView1.Groups[i];
                        listView1.Items.Add(lvi2);
                        break;
                    case ReadSmartResult.DRIVE_DOES_NOT_EXIST:
                        // Das angegebene Laufwerk existiert nicht
                        // nichts ausgeben
                        break;
                }
            }
        }

public class NFZImporter {
  public static NFZ Import(FileStream source) {
    BinaryReader reader = new BinaryReader(source);
    NFZ nfz = new NFZ();
    String fileInfo = "";
    byte inByte;
 
    // Read file information
    while ((inByte = reader.ReadByte()) != '\x1A') { // 1A = Strg + Z, das durchs Dateiformat vorgegebene Terminatorsymbol an dieser Stelle
      fileInfo += inByte;
    }
    
    // Check identifier
    String identifier = "";
    identifier += reader.ReadByte() + reader.ReadByte() + reader.ReadByte();
 
    if (identifier != NFZ.IDENTIFIER) {
      Console.WriteLine(identifier);
      throw new NFZInvalidException("...");
    }
 
    return nfz;
  }
}

public class NFZ {
  ...
  public static readonly String IDENTIFIER = "FZ\xC7";
  ...
}

 
        private void InsertFile(...)
        {
            FileStream fileStream = null;
 
            try
            {
...
                fileStream = new FileStream(GetFileName(), FileMode.Open);
                ...
                fileStream.Seek(...);
                fileStream.Write(...);
                fileStream.Write(...);
                fileStream.Flush();
                
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                throw;
            }
            finally
            {
                if (fileStream != null)
                    fileStream.Close();
            }
        }

...
XmlAttribute a = doc.CreateAttribute("xsi", "http://");
XmlElement documentNode = doc.CreateElement("Document");
documentNode.Attributes.Append(a);
doc.AppendChild(documentNode);
...