windows平台c++获取硬盘序列号（msys环境）

windows平台c++获取硬盘序列号（msys环境）

vmware虚拟机环境有时候获取不到硬盘序列号，设置后可以，参见：https://jingyan.baidu.com/article/cbcede07d345db43f40b4d88.html

本文参考：https://blog.csdn.net/yanchenyu365/article/details/85061879

1.makefile文件

app : HardDrive.cpp HardDriveSerialNumer.cpp
    g++ -w -o $@ $^

2.main函数文件:HardDrive.cpp

#include "HardDriveSerialNumer.hpp"
#include <iostream>
#include <string.h>

int main()
{
    char SerialNumber[1024] = {""};
    memset(&SerialNumber, 0, sizeof(SerialNumber));

    MasterHardDiskSerial a;
    int ret = a.GetSerialNo(SerialNumber);

    if (ret == 0)
    {
        std::cout << "SN " << SerialNumber << std::endl;
    }
    else
    {
        std::cout << "can't get sn" << std::endl;
    }
}

3.头文件:HardDriveSerialNumer.hpp

#ifndef _HDD_SERIAL_INFO_H_
#define _HDD_SERIAL_INFO_H_

#include <stdio.h>
#include <string.h>
#include <tchar.h>
#include <vector>
#include <windows.h>
#include <winioctl.h>

#pragma pack(1)

#define IDENTIFY_BUFFER_SIZE 512

//  IOCTL commands
#define DFP_GET_VERSION 0x00074080
#define DFP_SEND_DRIVE_COMMAND 0x0007c084
#define DFP_RECEIVE_DRIVE_DATA 0x0007c088

#define FILE_DEVICE_SCSI 0x0000001b
#define IOCTL_SCSI_MINIPORT_IDENTIFY ((FILE_DEVICE_SCSI << 16) + 0x0501)
#define IOCTL_SCSI_MINIPORT 0x0004D008 //  see NTDDSCSI.H for definition

#define SMART_GET_VERSION CTL_CODE(IOCTL_DISK_BASE, 0x0020, METHOD_BUFFERED, FILE_READ_ACCESS)
#define SMART_SEND_DRIVE_COMMAND CTL_CODE(IOCTL_DISK_BASE, 0x0021, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define SMART_RCV_DRIVE_DATA CTL_CODE(IOCTL_DISK_BASE, 0x0022, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)

//  GETVERSIONOUTPARAMS contains the data returned from the
//  Get Driver Version function.
typedef struct _GETVERSIONOUTPARAMS
{
    BYTE bVersion;       // Binary driver version.
    BYTE bRevision;      // Binary driver revision.
    BYTE bReserved;      // Not used.
    BYTE bIDEDeviceMap;  // Bit map of IDE devices.
    DWORD fCapabilities; // Bit mask of driver capabilities.
    DWORD dwReserved[4]; // For future use.
} GETVERSIONOUTPARAMS, *PGETVERSIONOUTPARAMS, *LPGETVERSIONOUTPARAMS;

//  Bits returned in the fCapabilities member of GETVERSIONOUTPARAMS
#define CAP_IDE_ID_FUNCTION 1            // ATA ID command supported
#define CAP_IDE_ATAPI_ID 2               // ATAPI ID command supported
#define CAP_IDE_EXECUTE_SMART_FUNCTION 4 // SMART commannds supported

//  Valid values for the bCommandReg member of IDEREGS.
#define IDE_ATAPI_IDENTIFY 0xA1 //  Returns ID sector for ATAPI.
#define IDE_ATA_IDENTIFY 0xEC   //  Returns ID sector for ATA.

// The following struct defines the interesting part of the IDENTIFY
// buffer:
typedef struct _IDSECTOR
{
    USHORT wGenConfig;
    USHORT wNumCyls;
    USHORT wReserved;
    USHORT wNumHeads;
    USHORT wBytesPerTrack;
    USHORT wBytesPerSector;
    USHORT wSectorsPerTrack;
    USHORT wVendorUnique[3];
    CHAR sSerialNumber[20];
    USHORT wBufferType;
    USHORT wBufferSize;
    USHORT wECCSize;
    CHAR sFirmwareRev[8];
    CHAR sModelNumber[40];
    USHORT wMoreVendorUnique;
    USHORT wDoubleWordIO;
    USHORT wCapabilities;
    USHORT wReserved1;
    USHORT wPIOTiming;
    USHORT wDMATiming;
    USHORT wBS;
    USHORT wNumCurrentCyls;
    USHORT wNumCurrentHeads;
    USHORT wNumCurrentSectorsPerTrack;
    ULONG ulCurrentSectorCapacity;
    USHORT wMultSectorStuff;
    ULONG ulTotalAddressableSectors;
    USHORT wSingleWordDMA;
    USHORT wMultiWordDMA;
    BYTE bReserved[128];
} IDSECTOR, *PIDSECTOR;

typedef struct _SRB_IO_CONTROL
{
    ULONG HeaderLength;
    UCHAR Signature[8];
    ULONG Timeout;
    ULONG ControlCode;
    ULONG ReturnCode;
    ULONG Length;
} SRB_IO_CONTROL, *PSRB_IO_CONTROL;

//  Max number of drives assuming primary/secondary, master/slave topology
//    Modified to read only the master serial
#define MAX_IDE_DRIVES 1

//
// IDENTIFY data (from ATAPI driver source)
//

#pragma pack(1)

typedef struct _IDENTIFY_DATA
{
    USHORT GeneralConfiguration;       // 00 00
    USHORT NumberOfCylinders;          // 02  1
    USHORT Reserved1;                  // 04  2
    USHORT NumberOfHeads;              // 06  3
    USHORT UnformattedBytesPerTrack;   // 08  4
    USHORT UnformattedBytesPerSector;  // 0A  5
    USHORT SectorsPerTrack;            // 0C  6
    USHORT VendorUnique1[3];           // 0E  7-9
    USHORT SerialNumber[10];           // 14  10-19
    USHORT BufferType;                 // 28  20
    USHORT BufferSectorSize;           // 2A  21
    USHORT NumberOfEccBytes;           // 2C  22
    USHORT FirmwareRevision[4];        // 2E  23-26
    USHORT ModelNumber[20];            // 36  27-46
    UCHAR MaximumBlockTransfer;        // 5E  47
    UCHAR VendorUnique2;               // 5F
    USHORT DoubleWordIo;               // 60  48
    USHORT Capabilities;               // 62  49
    USHORT Reserved2;                  // 64  50
    UCHAR VendorUnique3;               // 66  51
    UCHAR PioCycleTimingMode;          // 67
    UCHAR VendorUnique4;               // 68  52
    UCHAR DmaCycleTimingMode;          // 69
    USHORT TranslationFieldsValid : 1; // 6A  53
    USHORT Reserved3 : 15;
    USHORT NumberOfCurrentCylinders;  // 6C  54
    USHORT NumberOfCurrentHeads;      // 6E  55
    USHORT CurrentSectorsPerTrack;    // 70  56
    ULONG CurrentSectorCapacity;      // 72  57-58
    USHORT CurrentMultiSectorSetting; //     59
    ULONG UserAddressableSectors;     //     60-61
    USHORT SingleWordDMASupport : 8;  //     62
    USHORT SingleWordDMAActive : 8;
    USHORT MultiWordDMASupport : 8; //     63
    USHORT MultiWordDMAActive : 8;
    USHORT AdvancedPIOModes : 8; //     64
    USHORT Reserved4 : 8;
    USHORT MinimumMWXferCycleTime;     //     65
    USHORT RecommendedMWXferCycleTime; //     66
    USHORT MinimumPIOCycleTime;        //     67
    USHORT MinimumPIOCycleTimeIORDY;   //     68
    USHORT Reserved5[2];               //     69-70
    USHORT ReleaseTimeOverlapped;      //     71
    USHORT ReleaseTimeServiceCommand;  //     72
    USHORT MajorRevision;              //     73
    USHORT MinorRevision;              //     74
    USHORT Reserved6[50];              //     75-126
    USHORT SpecialFunctionsEnabled;    //     127
    USHORT Reserved7[128];             //     128-255
} IDENTIFY_DATA, *PIDENTIFY_DATA;

#pragma pack()

//  Required to ensure correct PhysicalDrive IOCTL structure setup
#pragma pack(4)

//
// IOCTL_STORAGE_QUERY_PROPERTY
//
// Input Buffer:
//      a STORAGE_PROPERTY_QUERY structure which describes what type of query
//      is being done, what property is being queried for, and any additional
//      parameters which a particular property query requires.
//
//  Output Buffer:
//      Contains a buffer to place the results of the query into.  Since all
//      property descriptors can be cast into a STORAGE_DESCRIPTOR_HEADER,
//      the IOCTL can be called once with a small buffer then again using
//      a buffer as large as the header reports is necessary.
//

//
// Types of queries
//

//
// define some initial property id's
//

//
// Query structure - additional parameters for specific queries can follow
// the header
//

#define IOCTL_STORAGE_QUERY_PROPERTY CTL_CODE(IOCTL_STORAGE_BASE, 0x0500, METHOD_BUFFERED, FILE_ANY_ACCESS)

//
// Device property descriptor - this is really just a rehash of the inquiry
// data retrieved from a scsi device
//
// This may only be retrieved from a target device.  Sending this to the bus
// will result in an error
//

#pragma pack(4)

// (* Output Bbuffer for the VxD (rt_IdeDinfo record) *)
typedef struct _rt_IdeDInfo_
{
    BYTE IDEExists[4];
    BYTE DiskExists[8];
    WORD DisksRawInfo[8 * 256];
} rt_IdeDInfo, *pt_IdeDInfo;

// (* IdeDinfo "data fields" *)
typedef struct _rt_DiskInfo_
{
    BOOL DiskExists;
    BOOL ATAdevice;
    BOOL RemovableDevice;
    WORD TotLogCyl;
    WORD TotLogHeads;
    WORD TotLogSPT;
    char SerialNumber[20];
    char FirmwareRevision[8];
    char ModelNumber[40];
    WORD CurLogCyl;
    WORD CurLogHeads;
    WORD CurLogSPT;
} rt_DiskInfo;

#define SENDIDLENGTH sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE
#define IOCTL_DISK_GET_DRIVE_GEOMETRY_EX CTL_CODE(IOCTL_DISK_BASE, 0x0028, METHOD_BUFFERED, FILE_ANY_ACCESS)

class MasterHardDiskSerial
{
public:
    MasterHardDiskSerial();
    ~MasterHardDiskSerial();
    //int GetSerialNo(std::vector<char> &serialNumber);
    int GetSerialNo(char *SerialNumber);
    int GetErrorMessage(TCHAR *_ptszErrorMessage = NULL);

private:
    char *ConvertToString(DWORD dwDiskdata[256], int iFirstIndex, int iLastIndex, char *pcBuf = NULL);
    BOOL DoIDENTIFY(HANDLE, PSENDCMDINPARAMS, PSENDCMDOUTPARAMS, BYTE, BYTE, PDWORD);
    int ReadPhysicalDriveInNTWithAdminRights(void);
    int ReadPhysicalDriveInNTUsingSmart(void);
    int ReadPhysicalDriveInNTWithZeroRights(void);
    int ReadIdeDriveAsScsiDriveInNT(void);
    char *flipAndCodeBytes(int iPos, int iFlip, const char *pcStr = NULL, char *pcBuf = NULL);
    void PrintIdeInfo(int iDrive, DWORD dwDiskdata[256]);
    long getHardDriveComputerID();

private:
    char m_cszHardDriveSerialNumber[1024];
    char m_cszHardDriveModelNumber[1024];
    char m_cszErrorMessage[256];
    BYTE byIdOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
};

#endif // _HDD_SERIAL_INFO_H_

4.实现文件:HardDriveSerialNumer.hpp

//#include "pch.h" //vs控制台项目自动生成
#include "HardDriveSerialNumer.hpp"
#include <iostream>

int MasterHardDiskSerial::ReadPhysicalDriveInNTWithAdminRights(void)
{
   int iDone = FALSE;
   int iDrive = 0;

   for (iDrive = 0; iDrive < MAX_IDE_DRIVES; iDrive++)
   {
      HANDLE hPhysicalDriveIOCTL = 0;

      //  Try to get a handle to PhysicalDrive IOCTL, report failure
      //  and exit if can't.
      char cszDriveName[256];

      sprintf_s(cszDriveName, 256, "\\.\PhysicalDrive%d", iDrive);

      //  Windows NT, Windows 2000, must have admin rights
      hPhysicalDriveIOCTL = CreateFileA(cszDriveName,
                                        GENERIC_READ | GENERIC_WRITE,
                                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                                        OPEN_EXISTING, 0, NULL);
      if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
      {
         SecureZeroMemory(m_cszErrorMessage, sizeof(m_cszErrorMessage));
         sprintf_s(m_cszErrorMessage, 256, "%d ReadPhysicalDriveInNTWithAdminRights ERROR ,CreateFileA(%s) returned INVALID_HANDLE_VALUE", __LINE__, cszDriveName);
      }
      else
      {
         GETVERSIONOUTPARAMS VersionParams;
         DWORD dwBytesReturned = 0;

         // Get the version, etc of PhysicalDrive IOCTL
         memset((void *)&VersionParams, 0, sizeof(VersionParams));

         if (!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                              NULL,
                              0,
                              &VersionParams,
                              sizeof(VersionParams),
                              &dwBytesReturned, NULL))
         {

            DWORD dwErr = GetLastError();
            SecureZeroMemory(m_cszErrorMessage, sizeof(m_cszErrorMessage));

            sprintf_s(m_cszErrorMessage, 256, "%d ReadPhysicalDriveInNTWithAdminRights ERROR DeviceIoControl() %ld, DFP_GET_VERSION) returned 0, error is %d
", __LINE__, (long long)hPhysicalDriveIOCTL, (int)dwErr);
         }

         // If there is a IDE device at number "iI" issue commands
         // to the device
         if (VersionParams.bIDEDeviceMap <= 0)
         {
            SecureZeroMemory(m_cszErrorMessage, sizeof(m_cszErrorMessage));
            sprintf_s(m_cszErrorMessage, 256, "%d ReadPhysicalDriveInNTWithAdminRights ERROR No device found at iPosition %d (%d)", __LINE__, (int)iDrive, (int)VersionParams.bIDEDeviceMap);
         }
         else
         {
            BYTE bIDCmd = 0; // IDE or ATAPI IDENTIFY cmd
            SENDCMDINPARAMS scip;
            //SENDCMDOUTPARAMS OutCmd;

            // Now, get the ID sector for all IDE devices in the system.
            // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
            // otherwise use the IDE_ATA_IDENTIFY command
            bIDCmd = (VersionParams.bIDEDeviceMap >> iDrive & 0x10) ? IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;

            memset(&scip, 0, sizeof(scip));
            memset(byIdOutCmd, 0, sizeof(byIdOutCmd));

            if (DoIDENTIFY(hPhysicalDriveIOCTL,
                           &scip,
                           (PSENDCMDOUTPARAMS)&byIdOutCmd,
                           (BYTE)bIDCmd,
                           (BYTE)iDrive,
                           &dwBytesReturned))
            {
               DWORD dwDiskData[256];
               int iIjk = 0;
               USHORT *punIdSector = (USHORT *)((PSENDCMDOUTPARAMS)byIdOutCmd)->bBuffer;

               for (iIjk = 0; iIjk < 256; iIjk++)
                  dwDiskData[iIjk] = punIdSector[iIjk];

               PrintIdeInfo(iDrive, dwDiskData);

               iDone = TRUE;
            }
         }

         CloseHandle(hPhysicalDriveIOCTL);
      }
   }

   return iDone;
}

int MasterHardDiskSerial::ReadPhysicalDriveInNTUsingSmart(void)
{
   int iDone = FALSE;
   int iDrive = 0;

   for (iDrive = 0; iDrive < MAX_IDE_DRIVES; iDrive++)
   {
      HANDLE hPhysicalDriveIOCTL = 0;

      //  Try to get a handle to PhysicalDrive IOCTL, report failure
      //  and exit if can't.
      char cszDriveName[256];

      sprintf_s(cszDriveName, 256, "\\.\PhysicalDrive%d", iDrive);

      //  Windows NT, Windows 2000, Windows Server 2003, Vista
      hPhysicalDriveIOCTL = CreateFileA(cszDriveName,
                                        GENERIC_READ | GENERIC_WRITE,
                                        FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
                                        NULL, OPEN_EXISTING, 0, NULL);
      // if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
      //    printf ("Unable to open physical iDrive %d, error code: 0x%lX
",
      //            iDrive, GetLastError ());

      if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
      {
         SecureZeroMemory(m_cszErrorMessage, sizeof(m_cszErrorMessage));
         sprintf_s(m_cszErrorMessage, 256, "%d ReadPhysicalDriveInNTUsingSmart ERROR, CreateFileA(%s) returned INVALID_HANDLE_VALUE Error Code %d", __LINE__, cszDriveName, GetLastError());
      }
      else
      {
         GETVERSIONINPARAMS GetVersionParams;
         DWORD dwBytesReturned = 0;

         // Get the version, etc of PhysicalDrive IOCTL
         memset((void *)&GetVersionParams, 0, sizeof(GetVersionParams));

         if (!DeviceIoControl(hPhysicalDriveIOCTL, SMART_GET_VERSION,
                              NULL,
                              0,
                              &GetVersionParams, sizeof(GETVERSIONINPARAMS),
                              &dwBytesReturned, NULL))
         {
            DWORD dwErr = GetLastError();
            SecureZeroMemory(m_cszErrorMessage, sizeof(m_cszErrorMessage));
            sprintf_s(m_cszErrorMessage, 256, "
%d ReadPhysicalDriveInNTUsingSmart ERROR DeviceIoControl(%ld, SMART_GET_VERSION) returned 0, error is %d", __LINE__, (long long)hPhysicalDriveIOCTL, (int)dwErr);
         }
         else
         {
            // Print the SMART version
            // PrintVersion (& GetVersionParams);
            // Allocate the command cszBuffer
            ULONG CommandSize = sizeof(SENDCMDINPARAMS) + IDENTIFY_BUFFER_SIZE;
            PSENDCMDINPARAMS Command = (PSENDCMDINPARAMS)malloc(CommandSize);
            // Retrieve the IDENTIFY data
            // Prepare the command
#define ID_CMD 0xEC // Returns ID sector for ATA
            Command->irDriveRegs.bCommandReg = ID_CMD;
            DWORD BytesReturned = 0;
            if (!DeviceIoControl(hPhysicalDriveIOCTL,
                                 SMART_RCV_DRIVE_DATA, Command, sizeof(SENDCMDINPARAMS),
                                 Command, CommandSize,
                                 &BytesReturned, NULL))
            {
               SecureZeroMemory(m_cszErrorMessage, sizeof(m_cszErrorMessage));
               sprintf_s(m_cszErrorMessage, 256, "SMART_RCV_DRIVE_DATA IOCTL");

               // Print the error
               //PrintError ("SMART_RCV_DRIVE_DATA IOCTL", GetLastError());
            }
            else
            {
               // Print the IDENTIFY data
               DWORD dwDiskData[256];
               USHORT *punIdSector = (USHORT *)(PIDENTIFY_DATA)((PSENDCMDOUTPARAMS)Command)->bBuffer;

               for (int iIjk = 0; iIjk < 256; iIjk++)
                  dwDiskData[iIjk] = punIdSector[iIjk];

               PrintIdeInfo(iDrive, dwDiskData);
               iDone = TRUE;
            }
            // Done
            CloseHandle(hPhysicalDriveIOCTL);
            free(Command);
         }
      }
   }

   return iDone;
}

char *MasterHardDiskSerial::flipAndCodeBytes(int iPos, int iFlip, const char *pcszStr, char *pcszBuf)
{
   int iI;
   int iJ = 0;
   int iK = 0;

   pcszBuf[0] = '';
   if (iPos <= 0)
      return pcszBuf;

   if (!iJ)
   {
      char cP = 0;
      // First try to gather all characters representing hex digits only.
      iJ = 1;
      iK = 0;
      pcszBuf[iK] = 0;
      for (iI = iPos; iJ && !(pcszStr[iI] == ''); ++iI)
      {
         char cC = tolower(pcszStr[iI]);
         if (isspace(cC))
            cC = '0';
         ++cP;
         pcszBuf[iK] <<= 4;

         if (cC >= '0' && cC <= '9')
            pcszBuf[iK] |= (char)(cC - '0');
         else if (cC >= 'a' && cC <= 'f')
            pcszBuf[iK] |= (char)(cC - 'a' + 10);
         else
         {
            iJ = 0;
            break;
         }

         if (cP == 2)
         {
            if ((pcszBuf[iK] != '') && !isprint(pcszBuf[iK]))
            {
               iJ = 0;
               break;
            }
            ++iK;
            cP = 0;
            pcszBuf[iK] = 0;
         }
      }
   }

   if (!iJ)
   {
      // There are non-digit characters, gather them as is.
      iJ = 1;
      iK = 0;
      for (iI = iPos; iJ && (pcszStr[iI] != ''); ++iI)
      {
         char cC = pcszStr[iI];

         if (!isprint(cC))
         {
            iJ = 0;
            break;
         }

         pcszBuf[iK++] = cC;
      }
   }

   if (!iJ)
   {
      // The characters are not there or are not printable.
      iK = 0;
   }

   pcszBuf[iK] = '';

   if (iFlip)
      // Flip adjacent characters
      for (iJ = 0; iJ < iK; iJ += 2)
      {
         char t = pcszBuf[iJ];
         pcszBuf[iJ] = pcszBuf[iJ + 1];
         pcszBuf[iJ + 1] = t;
      }

   // Trim any beginning and end space
   iI = iJ = -1;
   for (iK = 0; (pcszBuf[iK] != ''); ++iK)
   {
      if (!isspace(pcszBuf[iK]))
      {
         if (iI < 0)
            iI = iK;
         iJ = iK;
      }
   }

   if ((iI >= 0) && (iJ >= 0))
   {
      for (iK = iI; (iK <= iJ) && (pcszBuf[iK] != ''); ++iK)
         pcszBuf[iK - iI] = pcszBuf[iK];
      pcszBuf[iK - iI] = '';
   }

   return pcszBuf;
}

int MasterHardDiskSerial::ReadPhysicalDriveInNTWithZeroRights(void)
{
   int iDone = FALSE;
   int iDrive = 0;

   for (iDrive = 0; iDrive < MAX_IDE_DRIVES; iDrive++)
   {
      HANDLE hPhysicalDriveIOCTL = 0;

      //  Try to get a handle to PhysicalDrive IOCTL, report failure
      //  and exit if can't.
      char cszDriveName[256];

      sprintf_s(cszDriveName, 256, "\\.\PhysicalDrive%d", iDrive);

      //  Windows NT, Windows 2000, Windows XP - admin rights not required
      hPhysicalDriveIOCTL = CreateFileA(cszDriveName, 0,
                                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                                        OPEN_EXISTING, 0, NULL);
      if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
      {
         SecureZeroMemory(m_cszErrorMessage, sizeof(m_cszErrorMessage));
         sprintf_s(m_cszErrorMessage, 256, "%d ReadPhysicalDriveInNTWithZeroRights ERROR CreateFileA(%s) returned INVALID_HANDLE_VALUE", __LINE__, cszDriveName);
      }
      else
      {
         STORAGE_PROPERTY_QUERY query;
         DWORD dwBytesReturned = 0;
         char cszBuffer[10000];

         memset((void *)&query, 0, sizeof(query));
         query.PropertyId = StorageDeviceProperty;
         query.QueryType = PropertyStandardQuery;

         memset(cszBuffer, 0, sizeof(cszBuffer));

         if (DeviceIoControl(hPhysicalDriveIOCTL, IOCTL_STORAGE_QUERY_PROPERTY,
                             &query,
                             sizeof(query),
                             &cszBuffer,
                             sizeof(cszBuffer),
                             &dwBytesReturned, NULL))
         {
            STORAGE_DEVICE_DESCRIPTOR *descrip = (STORAGE_DEVICE_DESCRIPTOR *)&cszBuffer;
            char cszSerialNumber[1000];
            char cszModelNumber[1000];
            char cszVendorId[1000];
            char cszProductRevision[1000];

            flipAndCodeBytes(descrip->VendorIdOffset,
                             0, cszBuffer, cszVendorId);
            flipAndCodeBytes(descrip->ProductIdOffset,
                             0, cszBuffer, cszModelNumber);
            flipAndCodeBytes(descrip->ProductRevisionOffset,
                             0, cszBuffer, cszProductRevision);
            flipAndCodeBytes(descrip->SerialNumberOffset,
                             0, cszBuffer, cszSerialNumber);

            if (0 == m_cszHardDriveSerialNumber[0] &&
                //  serial number must be alphanumeric
                //  (but there can be leading spaces on IBM drives)
                (iswalnum(cszSerialNumber[0]) || iswalnum(cszSerialNumber[19])))
            {
               strcpy_s(m_cszHardDriveSerialNumber, 1024, cszSerialNumber);
               strcpy_s(m_cszHardDriveModelNumber, 1024, cszModelNumber);
               iDone = TRUE;
            }
            // Get the disk iDrive geometry.
            memset(cszBuffer, 0, sizeof(cszBuffer));
            if (!DeviceIoControl(hPhysicalDriveIOCTL,
                                 IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
                                 NULL,
                                 0,
                                 &cszBuffer,
                                 sizeof(cszBuffer),
                                 &dwBytesReturned,
                                 NULL))
            {
               SecureZeroMemory(m_cszErrorMessage, sizeof(m_cszErrorMessage));
               sprintf_s(m_cszErrorMessage, "%s ReadPhysicalDriveInNTWithZeroRights ERROR DeviceIoControl(), IOCTL_DISK_GET_DRIVE_GEOMETRY_EX) returned 0", cszDriveName);
            }
            else
            {
               DISK_GEOMETRY_EX *geom = (DISK_GEOMETRY_EX *)&cszBuffer;
               int iFixed = (geom->Geometry.MediaType == FixedMedia);
               __int64 i64Size = geom->DiskSize.QuadPart;
            }
         }
         else
         {
            DWORD dwErr = GetLastError();
            SecureZeroMemory(m_cszErrorMessage, sizeof(m_cszErrorMessage));
            sprintf_s(m_cszErrorMessage, "DeviceIOControl IOCTL_STORAGE_QUERY_PROPERTY error = %d
", dwErr);
         }

         CloseHandle(hPhysicalDriveIOCTL);
      }
   }

   return iDone;
}

BOOL MasterHardDiskSerial::DoIDENTIFY(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
                                      PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum,
                                      PDWORD lpcbBytesReturned)
{
   // Set up data structures for IDENTIFY command.
   pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
   pSCIP->irDriveRegs.bFeaturesReg = 0;
   pSCIP->irDriveRegs.bSectorCountReg = 1;
   //pSCIP -> irDriveRegs.bSectorNumberReg = 1;
   pSCIP->irDriveRegs.bCylLowReg = 0;
   pSCIP->irDriveRegs.bCylHighReg = 0;

   // Compute the iDrive number.
   pSCIP->irDriveRegs.bDriveHeadReg = 0xA0 | ((bDriveNum & 1) << 4);

   // The command can either be IDE identify or ATAPI identify.
   pSCIP->irDriveRegs.bCommandReg = bIDCmd;
   pSCIP->bDriveNumber = bDriveNum;
   pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

   return (DeviceIoControl(hPhysicalDriveIOCTL, DFP_RECEIVE_DRIVE_DATA,
                           (LPVOID)pSCIP,
                           sizeof(SENDCMDINPARAMS) - 1,
                           (LPVOID)pSCOP,
                           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
                           lpcbBytesReturned, NULL));
}

int MasterHardDiskSerial::ReadIdeDriveAsScsiDriveInNT(void)
{
   int iDone = FALSE;
   int iController = 0;

   for (iController = 0; iController < 2; iController++)
   {
      HANDLE hScsiDriveIOCTL = 0;
      char cszDriveName[256];

      //  Try to get a handle to PhysicalDrive IOCTL, report failure
      //  and exit if can't.
      sprintf_s(cszDriveName, "\\.\Scsi%d:", iController);

      //  Windows NT, Windows 2000, any rights should do
      hScsiDriveIOCTL = CreateFileA(cszDriveName,
                                    GENERIC_READ | GENERIC_WRITE,
                                    FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                                    OPEN_EXISTING, 0, NULL);

      if (hScsiDriveIOCTL != INVALID_HANDLE_VALUE)
      {
         int iDrive = 0;

         for (iDrive = 0; iDrive < 2; iDrive++)
         {
            char cszBuffer[sizeof(SRB_IO_CONTROL) + SENDIDLENGTH];
            SRB_IO_CONTROL *cP = (SRB_IO_CONTROL *)cszBuffer;
            SENDCMDINPARAMS *pin =
                (SENDCMDINPARAMS *)(cszBuffer + sizeof(SRB_IO_CONTROL));
            DWORD dwDummy;

            memset(cszBuffer, 0, sizeof(cszBuffer));
            cP->HeaderLength = sizeof(SRB_IO_CONTROL);
            cP->Timeout = 10000;
            cP->Length = SENDIDLENGTH;
            cP->ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;
            strncpy((char *)cP->Signature, "SCSIDISK", 8);

            pin->irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY;
            pin->bDriveNumber = iDrive;

            if (DeviceIoControl(hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT,
                                cszBuffer,
                                sizeof(SRB_IO_CONTROL) +
                                    sizeof(SENDCMDINPARAMS) - 1,
                                cszBuffer,
                                sizeof(SRB_IO_CONTROL) + SENDIDLENGTH,
                                &dwDummy, NULL))
            {
               SENDCMDOUTPARAMS *pOut =
                   (SENDCMDOUTPARAMS *)(cszBuffer + sizeof(SRB_IO_CONTROL));
               IDSECTOR *pId = (IDSECTOR *)(pOut->bBuffer);
               if (pId->sModelNumber[0])
               {
                  DWORD dwDiskData[256];
                  int iIjk = 0;
                  USHORT *punIdSector = (USHORT *)pId;

                  for (iIjk = 0; iIjk < 256; iIjk++)
                     dwDiskData[iIjk] = punIdSector[iIjk];

                  PrintIdeInfo(iController * 2 + iDrive, dwDiskData);

                  iDone = TRUE;
               }
            }
         }
         CloseHandle(hScsiDriveIOCTL);
      }
   }

   return iDone;
}

void MasterHardDiskSerial::PrintIdeInfo(int iDrive, DWORD dwDiskData[256])
{
   char cszSerialNumber[1024];
   char cszModelNumber[1024];
   char cszRevisionNumber[1024];
   char bufferSize[32];

   __int64 i64Sectors = 0;
   __int64 i64Byte = 0;

   //  copy the hard iDrive serial number to the cszBuffer
   ConvertToString(dwDiskData, 10, 19, cszSerialNumber);
   ConvertToString(dwDiskData, 27, 46, cszModelNumber);
   ConvertToString(dwDiskData, 23, 26, cszRevisionNumber);
   sprintf_s(bufferSize, 32, "%u", dwDiskData[21] * 512);

   if (0 == m_cszHardDriveSerialNumber[0] &&
       //  serial number must be alphanumeric
       //  (but there can be leading spaces on IBM drives)
       (isalnum(cszSerialNumber[0]) || isalnum(cszSerialNumber[19])))
   {
      strcpy_s(m_cszHardDriveSerialNumber, 1024, cszSerialNumber);
      strcpy_s(m_cszHardDriveModelNumber, 1024, cszModelNumber);
   }
}

long MasterHardDiskSerial::getHardDriveComputerID()
{
   int iDone = FALSE;
   // char string [1024];
   __int64 i64Id = 0;
   OSVERSIONINFO version;

   strcpy_s(m_cszHardDriveSerialNumber, 1024, "");

   memset(&version, 0, sizeof(version));
   version.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
   GetVersionEx(&version);
   if (version.dwPlatformId == VER_PLATFORM_WIN32_NT)
   {
      //  this works under WinNT4 or Win2K if you have admin rights
      iDone = ReadPhysicalDriveInNTWithAdminRights();

      //  this should work in WinNT or Win2K if previous did not work
      //  this is kind of a backdoor via the SCSI mini port driver into
      //     the IDE drives
      if (!iDone)
         iDone = ReadIdeDriveAsScsiDriveInNT();

      //  this works under WinNT4 or Win2K or WinXP if you have any rights
      if (!iDone)
         iDone = ReadPhysicalDriveInNTWithZeroRights();

      //  this works under WinNT4 or Win2K or WinXP or Windows Server 2003 or Vista if you have any rights
      if (!iDone)
         iDone = ReadPhysicalDriveInNTUsingSmart();
   }

   if (m_cszHardDriveSerialNumber[0] > 0)
   {
      char *cP = m_cszHardDriveSerialNumber;

      //  ignore first 5 characters from western digital hard drives if
      //  the first four characters are WD-W
      if (!strncmp(m_cszHardDriveSerialNumber, "WD-W", 4))
         cP += 5;
      for (; cP && *cP; cP++)
      {
         if ('-' == *cP)
            continue;
         i64Id *= 10;
         switch (*cP)
         {
         case '0':
            i64Id += 0;
            break;
         case '1':
            i64Id += 1;
            break;
         case '2':
            i64Id += 2;
            break;
         case '3':
            i64Id += 3;
            break;
         case '4':
            i64Id += 4;
            break;
         case '5':
            i64Id += 5;
            break;
         case '6':
            i64Id += 6;
            break;
         case '7':
            i64Id += 7;
            break;
         case '8':
            i64Id += 8;
            break;
         case '9':
            i64Id += 9;
            break;
         case 'a':
         case 'A':
            i64Id += 10;
            break;
         case 'b':
         case 'B':
            i64Id += 11;
            break;
         case 'c':
         case 'C':
            i64Id += 12;
            break;
         case 'd':
         case 'D':
            i64Id += 13;
            break;
         case 'e':
         case 'E':
            i64Id += 14;
            break;
         case 'f':
         case 'F':
            i64Id += 15;
            break;
         case 'g':
         case 'G':
            i64Id += 16;
            break;
         case 'h':
         case 'H':
            i64Id += 17;
            break;
         case 'i':
         case 'I':
            i64Id += 18;
            break;
         case 'j':
         case 'J':
            i64Id += 19;
            break;
         case 'k':
         case 'K':
            i64Id += 20;
            break;
         case 'l':
         case 'L':
            i64Id += 21;
            break;
         case 'm':
         case 'M':
            i64Id += 22;
            break;
         case 'n':
         case 'N':
            i64Id += 23;
            break;
         case 'o':
         case 'O':
            i64Id += 24;
            break;
         case 'p':
         case 'P':
            i64Id += 25;
            break;
         case 'q':
         case 'Q':
            i64Id += 26;
            break;
         case 'r':
         case 'R':
            i64Id += 27;
            break;
         case 's':
         case 'S':
            i64Id += 28;
            break;
         case 't':
         case 'T':
            i64Id += 29;
            break;
         case 'u':
         case 'U':
            i64Id += 30;
            break;
         case 'v':
         case 'V':
            i64Id += 31;
            break;
         case 'w':
         case 'W':
            i64Id += 32;
            break;
         case 'x':
         case 'X':
            i64Id += 33;
            break;
         case 'y':
         case 'Y':
            i64Id += 34;
            break;
         case 'z':
         case 'Z':
            i64Id += 35;
            break;
         }
      }
   }

   i64Id %= 100000000;
   if (strstr(m_cszHardDriveModelNumber, "IBM-"))
      i64Id += 300000000;
   else if (strstr(m_cszHardDriveModelNumber, "MAXTOR") ||
            strstr(m_cszHardDriveModelNumber, "Maxtor"))
      i64Id += 400000000;
   else if (strstr(m_cszHardDriveModelNumber, "WDC "))
      i64Id += 500000000;
   else
      i64Id += 600000000;

   return (long)i64Id;
}

//int MasterHardDiskSerial::GetSerialNo(std::vector<char> &serialNumber)
int MasterHardDiskSerial::GetSerialNo(char *SerialNumber)
{
   getHardDriveComputerID();
   size_t numberLength = strlen(m_cszHardDriveSerialNumber);
   if (numberLength == 0)
      return -1;
   //serialNumber.resize(numberLength);
   //std::cout << "size " << serialNumber.size() << std::endl;
   //memcpy(&serialNumber.front(), m_cszHardDriveSerialNumber, serialNumber.size()); //m_cszHardDriveSerialNumber;
   memcpy(SerialNumber, m_cszHardDriveSerialNumber, numberLength);
   return 0;
}

char *MasterHardDiskSerial::ConvertToString(DWORD dwDiskData[256],
                                            int iFirstIndex,
                                            int iLastIndex,
                                            char *pcszBuf)
{
   int iIndex = 0;
   int iPosition = 0;

   //  each integer has two characters stored in it backwards

   // Removes the spaces from the serial no
   for (iIndex = iFirstIndex; iIndex <= iLastIndex; iIndex++)
   {
      //  get high byte for 1st character
      char ctemp = (char)(dwDiskData[iIndex] / 256);
      char cszmyspace[] = " ";
      if (!(ctemp == *cszmyspace))
      {
         pcszBuf[iPosition++] = ctemp;
      }
      //  get low byte for 2nd character
      char ctemp1 = (char)(dwDiskData[iIndex] % 256);
      if (!(ctemp1 == *cszmyspace))
      {
         pcszBuf[iPosition++] = ctemp1;
      }
   }

   //  end the string
   pcszBuf[iPosition] = '';

   //  cut off the trailing blanks
   for (iIndex = iPosition - 1; iIndex > 0 && isspace(pcszBuf[iIndex]); iIndex--)
      pcszBuf[iIndex] = '';

   return pcszBuf;
}

int MasterHardDiskSerial::GetErrorMessage(TCHAR *tszErrorMessage)
{
   if (strlen(m_cszErrorMessage) != 0)
   {
      mbstowcs((wchar_t *)tszErrorMessage, m_cszErrorMessage, sizeof(m_cszErrorMessage));
      return 0;
   }
   else
      return -1;
}

MasterHardDiskSerial::MasterHardDiskSerial()
{
   SecureZeroMemory(m_cszErrorMessage, sizeof(m_cszErrorMessage));
   SecureZeroMemory(m_cszHardDriveModelNumber, sizeof(m_cszHardDriveModelNumber));
   SecureZeroMemory(m_cszHardDriveSerialNumber, sizeof(m_cszHardDriveSerialNumber));
}

MasterHardDiskSerial::~MasterHardDiskSerial()
{
}