正确获取硬盘序列号源码

参考：http://www.winsim.com/diskid32/diskid32.cpp

 

//  diskid32.cpp 

//  for displaying the details of hard drives in a command window 

//  06/11/00  Lynn McGuire  written with many contributions from others, 

//                            IDE drives only under Windows NT/2K and 9X, 

//                            maybe SCSI drives later 

//  11/20/03  Lynn McGuire  added ReadPhysicalDriveInNTWithZeroRights 

//  10/26/05  Lynn McGuire  fix the flipAndCodeBytes function 

//  12/8/06   Chunlin Deng  update the string function to security version. 

//  Testing Passed with Visul Studio 2005. 



#include "stdafx.h"

#include <stdlib.h> 

#include <stdio.h> 

#include <stddef.h> 

#include <string.h> 

#include "diskid.h"

#include <WinIoCtl.h>





//  Required to ensure correct PhysicalDrive IOCTL structure setup 

#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 



   //  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; 



   // Define global buffers. 

BYTE IdOutCmd [sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1]; 



char *ConvertToString (DWORD diskdata [256], int firstIndex, int lastIndex); 

void PrintIdeInfo(int drive, DWORD diskdata [256],char *sDest,int nLen); 

BOOL DoIDENTIFY (HANDLE, PSENDCMDINPARAMS, PSENDCMDOUTPARAMS, BYTE, BYTE, PDWORD); 



//  Max number of drives assuming primary/secondary, master/slave topology 

#define  MAX_IDE_DRIVES  16 



int ReadPhysicalDriveInNTWithAdminRights(char *sBuff,int nLen)

{ 

    int done = FALSE; 

    HANDLE hPhysicalDriveIOCTL = 0; 

    TCHAR driveName[MAX_PATH]; 



    for ( int drive = 0; drive < MAX_IDE_DRIVES; drive++ ){ 

        //  Try to get a handle to PhysicalDrive IOCTL, report failure 

        //  and exit if can''t. 

        _stprintf_s (driveName, _T("\\\\.\\PhysicalDrive%d"), drive); 

        //  Windows NT, Windows 2000, must have admin rights 

        hPhysicalDriveIOCTL = CreateFile (driveName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE , NULL, OPEN_EXISTING, 0, NULL); 

        

        // if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE) 

        //    printf ("Unable to open physical drive %d, error code: 0x%lX\n", 

        //            drive, GetLastError ()); 

        

        if ( hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE ){ 

            GETVERSIONOUTPARAMS VersionParams; 

            DWORD               cbBytesReturned = 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), &cbBytesReturned, NULL) ){          

                // printf ("DFP_GET_VERSION failed for drive %d\n", i); 

                // continue; 

            } 

            

            // If there is a IDE device at number "i" issue commands 

            // to the device 

            if ( VersionParams.bIDEDeviceMap > 0 ){ 

                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 >> drive & 0x10) ? IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY; 

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

                memset (IdOutCmd, 0, sizeof(IdOutCmd)); 

                if ( DoIDENTIFY(hPhysicalDriveIOCTL,&scip,(PSENDCMDOUTPARAMS)&IdOutCmd, (BYTE)bIDCmd, (BYTE)drive, &cbBytesReturned) ){ 

                    DWORD diskdata [256]; 

                    int ijk = 0; 

                    USHORT *pIdSector = (USHORT *)((PSENDCMDOUTPARAMS) IdOutCmd) -> bBuffer; 

                    for (ijk = 0; ijk < 256; ijk++) {

                        diskdata [ijk] = pIdSector [ijk]; 

                    }

                    PrintIdeInfo (drive, diskdata,sBuff,nLen); 

                    done = TRUE; 

                } 

            } 



            CloseHandle(hPhysicalDriveIOCTL); 

        } 

    }//end for

    return done; 

} 



//  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. 

// 



#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) 



 //  function to decode the serial numbers of IDE hard drives 

 //  using the IOCTL_STORAGE_QUERY_PROPERTY command  

char * flipAndCodeBytes (char * str) 

{ 

    static char flipped [1000]; 

    int i = 0; 

    int j = 0; 

    int k = 0; 

    int num = strlen (str); 

    strcpy_s (flipped,""); 

    for (i = 0; i < num; i += 4) 

    { 

        for (j = 1; j >= 0; j--) 

        { 

            int sum = 0; 

            for (k = 0; k < 2; k++) 

            { 

                sum *= 16; 

                switch (str [i + j * 2 + k]) 

                { 

                case '0':  sum += 0; break; 

                case '1':  sum += 1; break; 

                case '2':  sum += 2; break; 

                case '3':  sum += 3; break; 

                case '4':  sum += 4; break; 

                case '5':  sum += 5; break; 

                case '6':  sum += 6; break; 

                case '7':  sum += 7; break; 

                case '8':  sum += 8; break; 

                case '9':  sum += 9; break; 

                case 'a':  sum += 10; break; 

                case 'b':  sum += 11; break; 

                case 'c':  sum += 12; break; 

                case 'd':  sum += 13; break; 

                case 'e':  sum += 14; break; 

                case 'f':  sum += 15; break; 

                case 'A':  sum += 10; break; 

                case 'B':  sum += 11; break; 

                case 'C':  sum += 12; break; 

                case 'D':  sum += 13; break; 

                case 'E':  sum += 14; break; 

                case 'F':  sum += 15; break; 

                } 

            } 

            if (sum > 0)  

            { 

                char sub [2]; 

                sub [0] = (char) sum; 

                sub [1] = 0; 

                strcat_s (flipped, sub); 

            } 

        } 

    } 

    return flipped; 

} 



typedef struct _MEDIA_SERAL_NUMBER_DATA { 

  ULONG  SerialNumberLength;  

  ULONG  Result; 

  ULONG  Reserved[2]; 

  UCHAR  SerialNumberData[1]; 

} MEDIA_SERIAL_NUMBER_DATA, *PMEDIA_SERIAL_NUMBER_DATA; 



int ReadPhysicalDriveInNTWithZeroRights(char *sBuff,int nLen)

{ 

    int done = FALSE; 

    HANDLE hPhysicalDriveIOCTL = 0; 

    TCHAR driveName [MAX_PATH]; 



    for (int drive = 0; drive < MAX_IDE_DRIVES; drive++){ 

        //  Try to get a handle to PhysicalDrive IOCTL, report failure 

        //  and exit if can''t. 

        _stprintf_s (driveName, _T("\\\\.\\PhysicalDrive%d"), drive); 

        //  Windows NT, Windows 2000, Windows XP - admin rights not required 

        hPhysicalDriveIOCTL = CreateFile (driveName, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); 

        // if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE) 

        //    printf ("Unable to open physical drive %d, error code: 0x%lX\n", 

        //            drive, GetLastError ()); 

        

        if ( hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE ) { 

            STORAGE_PROPERTY_QUERY query; 

            DWORD cbBytesReturned = 0; 

            char buffer [10000]; 



            memset ((void *) & query, 0, sizeof (query)); 

            query.PropertyId = StorageDeviceProperty; 

            query.QueryType = PropertyStandardQuery; 

            memset (buffer, 0, sizeof (buffer)); 

            if ( DeviceIoControl (hPhysicalDriveIOCTL, IOCTL_STORAGE_QUERY_PROPERTY, & query, sizeof(query), &buffer, sizeof(buffer), &cbBytesReturned, NULL) ){          

                STORAGE_DEVICE_DESCRIPTOR * descrip = (STORAGE_DEVICE_DESCRIPTOR *) & buffer; 

                char serialNumber [1000]; 

                char modelNumber [1000]; 



                strcpy_s (serialNumber,  

                flipAndCodeBytes ( & buffer [descrip -> SerialNumberOffset])); 

                strcpy_s (modelNumber, & buffer [descrip -> ProductIdOffset]); 

                if ( 0 == sBuff [0] && 

                    //  serial number must be alphanumeric 

                            //  (but there can be leading spaces on IBM drives) 

                    (isalnum (serialNumber [0]) || isalnum (serialNumber [19])) ) { 

                    strcpy_s (sBuff, nLen, serialNumber); 

                    //strcpy_s (HardDriveModelNumber, modelNumber); 

                    done = TRUE; 

                }  

            }else{ 

                DWORD err = GetLastError(); 

                //printf ("\nDeviceIOControl IOCTL_STORAGE_QUERY_PROPERTY error = %d\n", err); 

            } 

            memset (buffer, 0, sizeof (buffer)); 

            if ( DeviceIoControl (hPhysicalDriveIOCTL, IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER, NULL, 0, &buffer, sizeof(buffer), &cbBytesReturned, NULL) ) {          

                MEDIA_SERIAL_NUMBER_DATA * mediaSerialNumber = (MEDIA_SERIAL_NUMBER_DATA *) & buffer; 

                char serialNumber [1000]; 

                // char modelNumber [1000]; 

                strcpy_s (serialNumber, (char *) mediaSerialNumber -> SerialNumberData); 

                // strcpy_s (modelNumber, & buffer [descrip -> ProductIdOffset]); 

                if ( 0 == sBuff[0] && 

                    //  serial number must be alphanumeric 

                            //  (but there can be leading spaces on IBM drives) 

                    (isalnum (serialNumber [0]) || isalnum (serialNumber [19])) ) { 

                    strcpy_s (sBuff, nLen, serialNumber); 

                    // strcpy_s (HardDriveModelNumber, modelNumber); 

                    done = TRUE; 

                } 

                //printf ("\n**** MEDIA_SERIAL_NUMBER_DATA for drive %d ****\nSerial Number = %s\n", drive, serialNumber); 

            }else{ 

                //DWORD err = GetLastError (); 

                //switch (err) 

                //{ 

                //case 1:  

                //    printf ("\nDeviceIOControl IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER error = \n" 

                //        "              The request is not valid for this device.\n\n"); 

                //    break; 

                //case 50: 

                //    printf ("\nDeviceIOControl IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER error = \n" 

                //        "              The request is not supported for this device.\n\n"); 

                //    break; 

                //default: 

                //    printf ("\nDeviceIOControl IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER error = %d\n\n", err); 

                //} 

            } 



            CloseHandle (hPhysicalDriveIOCTL); 

        } 

    }//end for

    return done; 

} 



// DoIDENTIFY 

// FUNCTION: Send an IDENTIFY command to the drive 

// bDriveNum = 0-3 

// bIDCmd = IDE_ATA_IDENTIFY or IDE_ATAPI_IDENTIFY 

BOOL 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 drive 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) ); 

} 



//  --------------------------------------------------- 

   // (* 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  m_cVxDFunctionIdesDInfo  1 



//////////////////////////////////////////////////////////////////////////



int ReadDrivePortsInWin9X(char *sBuff,int nLen)

{ 

    int done = FALSE; 

    HANDLE VxDHandle = 0; 

    pt_IdeDInfo pOutBufVxD = 0; 

    DWORD lpBytesReturned = 0; 

    //  set the thread priority high so that we get exclusive access to the disk 

    BOOL status = SetPriorityClass (GetCurrentProcess (), REALTIME_PRIORITY_CLASS); 

    if (0 == status){

        //printf ("\nERROR: Could not SetPriorityClass, LastError: %d\n", GetLastError ()); 

    }  

    // 1. Make an output buffer for the VxD 

    rt_IdeDInfo info; 

    pOutBufVxD = &info; 

    // ***************** 

    // KLUDGE WARNING!!! 

    // HAVE to zero out the buffer space for the IDE information! 

    // If this is NOT done then garbage could be in the memory 

    // locations indicating if a disk exists or not. 

    ZeroMemory (&info, sizeof(info)); 

    // 1. Try to load the VxD 

    //  must use the short file name path to open a VXD file 

    //char StartupDirectory [2048]; 

    //char shortFileNamePath [2048]; 

    //char *p = NULL; 

    //char vxd [2048]; 

    //  get the directory that the exe was started from 

    //GetModuleFileName (hInst, (LPSTR) StartupDirectory, sizeof (StartupDirectory)); 

    //  cut the exe name from string 

    //p = &(StartupDirectory [strlen (StartupDirectory) - 1]); 

    //while (p >= StartupDirectory && *p && ''\\'' != *p) p--; 

    //*p = ''\0'';    

    //GetShortPathName (StartupDirectory, shortFileNamePath, 2048); 

    //sprintf_s (vxd, "\\\\.\\%s\\IDE21201.VXD", shortFileNamePath); 

    //VxDHandle = CreateFile (vxd, 0, 0, 0, 

    //               0, FILE_FLAG_DELETE_ON_CLOSE, 0);    

    VxDHandle = CreateFile (_T("\\\\.\\IDE21201.VXD"), 0, 0, 0, 0, FILE_FLAG_DELETE_ON_CLOSE, 0); 

    if (VxDHandle != INVALID_HANDLE_VALUE) { 

        // 2. Run VxD function 

        DeviceIoControl (VxDHandle, m_cVxDFunctionIdesDInfo, 0, 0, pOutBufVxD, sizeof(pt_IdeDInfo), &lpBytesReturned, 0); 

        // 3. Unload VxD 

        CloseHandle (VxDHandle); 

    }else{

        //MessageBox (NULL, "ERROR: Could not open IDE21201.VXD file",TITLE, MB_ICONSTOP); 

    }

 

        // 4. Translate and store data 

    for (int i=0; i<8; i++) { 

        if((pOutBufVxD->DiskExists[i]) && (pOutBufVxD->IDEExists[i/2])) { 

            DWORD diskinfo [256]; 

            for (int j = 0; j < 256; j++)  

            diskinfo [j] = pOutBufVxD -> DisksRawInfo [i * 256 + j]; 

                    // process the information for this buffer 

            PrintIdeInfo (i, diskinfo,sBuff,nLen); 

            done = TRUE; 

        } 

    } 

    //  reset the thread priority back to normal 

    // SetThreadPriority (GetCurrentThread(), THREAD_PRIORITY_NORMAL); 

    SetPriorityClass (GetCurrentProcess (), NORMAL_PRIORITY_CLASS); 

    return done; 

} 



#define  SENDIDLENGTH  sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE 



int ReadIdeDriveAsScsiDriveInNT(char *sBuff,int nLen)

{ 

   int done = FALSE; 

   int controller = 0; 

   for (controller = 0; controller < 16; controller++) 

   { 

      HANDLE hScsiDriveIOCTL = 0; 

      TCHAR  driveName [MAX_PATH]; 

         //  Try to get a handle to PhysicalDrive IOCTL, report failure 

         //  and exit if can''t. 

      _stprintf_s (driveName, _T("\\\\.\\Scsi%d:"), controller); 

         //  Windows NT, Windows 2000, any rights should do 

      hScsiDriveIOCTL = CreateFile (driveName, 

                               GENERIC_READ | GENERIC_WRITE,  

                               FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 

                               OPEN_EXISTING, 0, NULL); 

      // if (hScsiDriveIOCTL == INVALID_HANDLE_VALUE) 

      //    printf ("Unable to open SCSI controller %d, error code: 0x%lX\n", 

      //            controller, GetLastError ()); 

      if (hScsiDriveIOCTL != INVALID_HANDLE_VALUE) 

      { 

         int drive = 0; 

         for (drive = 0; drive < 2; drive++) 

         { 

            char buffer [sizeof (SRB_IO_CONTROL) + SENDIDLENGTH]; 

            SRB_IO_CONTROL *p = (SRB_IO_CONTROL *) buffer; 

            SENDCMDINPARAMS *pin = 

                   (SENDCMDINPARAMS *) (buffer + sizeof (SRB_IO_CONTROL)); 

            DWORD dummy; 

    

            memset (buffer, 0, sizeof (buffer)); 

            p -> HeaderLength = sizeof (SRB_IO_CONTROL); 

            p -> Timeout = 10000; 

            p -> Length = SENDIDLENGTH; 

            p -> ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY; 

            strncpy_s ((char *) p -> Signature,9,"SCSIDISK", 8); 

              

            pin -> irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY; 

            pin -> bDriveNumber = drive; 

            if (DeviceIoControl (hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT,  

                                 buffer, 

                                 sizeof (SRB_IO_CONTROL) + 

                                         sizeof (SENDCMDINPARAMS) - 1, 

                                 buffer, 

                                 sizeof (SRB_IO_CONTROL) + SENDIDLENGTH, 

                                 &dummy, NULL)) 

            { 

               SENDCMDOUTPARAMS *pOut = 

                    (SENDCMDOUTPARAMS *) (buffer + sizeof (SRB_IO_CONTROL)); 

               IDSECTOR *pId = (IDSECTOR *) (pOut -> bBuffer); 

               if (pId -> sModelNumber [0]) 

               { 

                  DWORD diskdata [256]; 

                  int ijk = 0; 

                  USHORT *pIdSector = (USHORT *) pId; 

           

                  for (ijk = 0; ijk < 256; ijk++) 

                     diskdata [ijk] = pIdSector [ijk]; 

                  PrintIdeInfo (controller * 2 + drive, diskdata,sBuff,nLen); 

                  done = TRUE; 

               } 

            } 

         } 

         CloseHandle (hScsiDriveIOCTL); 

      } 

   } 

   return done; 

} 





//////////////////////////////////////////////////////////////////////////





//

// 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()





int ReadPhysicalDriveInNTUsingSmart(char *sBuff,int nLen)

{

    int done = FALSE;

    int drive = 0;



    for (drive = 0; drive < MAX_IDE_DRIVES; drive++)

    {

        HANDLE hPhysicalDriveIOCTL = 0;



        //  Try to get a handle to PhysicalDrive IOCTL, report failure

        //  and exit if can't.

        TCHAR driveName [MAX_PATH];



        _stprintf (driveName, _T("\\\\.\\PhysicalDrive%d"), drive);



        //  Windows NT, Windows 2000, Windows Server 2003, Vista

        hPhysicalDriveIOCTL = CreateFile (driveName, 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 drive %d, error code: 0x%lX\n",

        //            drive, GetLastError ());



        if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE){

            //if (PRINT_DEBUG) 

            //    printf ("\n%d ReadPhysicalDriveInNTUsingSmart ERROR"

            //    "\nCreateFile(%s) returned INVALID_HANDLE_VALUE\n"

            //    "Error Code %d\n",

            //    __LINE__, driveName, GetLastError ());

        }else{

            GETVERSIONINPARAMS GetVersionParams;

            DWORD cbBytesReturned = 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), &cbBytesReturned, NULL) ){         

                //if (PRINT_DEBUG)

                //{

                //    DWORD err = GetLastError ();

                //    printf ("\n%d ReadPhysicalDriveInNTUsingSmart ERROR"

                //        "\nDeviceIoControl(%d, SMART_GET_VERSION) returned 0, error is %d\n",

                //        __LINE__, (int) hPhysicalDriveIOCTL, (int) err);

                //}

            }else{

                // Print the SMART version

                // PrintVersion (& GetVersionParams);

                // Allocate the command buffer

                ULONG CommandSize = sizeof(SENDCMDINPARAMS) + IDENTIFY_BUFFER_SIZE;

                PSENDCMDINPARAMS Command = (PSENDCMDINPARAMS)new BYTE[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) ){

                    // Print the error

                    //PrintError ("SMART_RCV_DRIVE_DATA IOCTL", GetLastError());

                }else{

                    // Print the IDENTIFY data

                    DWORD diskdata [256];

                    USHORT *pIdSector = (USHORT *)(PIDENTIFY_DATA) ((PSENDCMDOUTPARAMS) Command) -> bBuffer;



                    for (int ijk = 0; ijk < 256; ijk++){

                        diskdata [ijk] = pIdSector [ijk];

                    }



                    PrintIdeInfo (drive, diskdata,sBuff,nLen); 

                    done = TRUE;

                }

                // Done

                CloseHandle (hPhysicalDriveIOCTL);

                delete []Command;

            }

        }

    }



    return done;

}



void PrintIdeInfo(int drive, DWORD diskdata [256],char *sDest,int nLen) 

{ 

   char string1 [1024]; 

   __int64 sectors = 0; 

   __int64 bytes = 0; 

      //  copy the hard drive serial number to the buffer 

   strcpy_s (string1, ConvertToString (diskdata, 10, 19)); 

   if (0 == sDest[0] && 

            //  serial number must be alphanumeric 

            //  (but there can be leading spaces on IBM drives) 

       (isalnum (string1 [0]) || isalnum (string1 [19]))) 

   { 

      strcpy_s (sDest, nLen, string1); 

      //strcpy_s (HardDriveModelNumber, ConvertToString (diskdata, 27, 46)); 

   } 

} 



char *ConvertToString (DWORD diskdata [256], int firstIndex, int lastIndex) 

{ 

   static char string [1024]; 

   int position = 0; 

      //  each integer has two characters stored in it backwards 

   for (int index = firstIndex; index <= lastIndex; index++) 

   { 

         //  get high byte for 1st character 

      string [position] = (char) (diskdata [index] / 256); 

      position++; 

         //  get low byte for 2nd character 

      string [position] = (char) (diskdata [index] % 256); 

      position++; 

   } 

      //  end the string  

   string [position] = '\0'; 

      //  cut off the trailing blanks 

   for (int index = position - 1; index > 0 && ' ' == string [index]; index--) 

      string [index] = '\0'; 

   return string; 

} 



int GetHardDriveSerialNumber(char *sBuff,int nLen)

{

    int done = FALSE;

    // char string [1024];

    __int64 id = 0;

    OSVERSIONINFO version = {0};

    version.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);

    GetVersionEx (&version);



    memset(sBuff,0,nLen);



    if (version.dwPlatformId == VER_PLATFORM_WIN32_NT) {

        //  this works under WinNT4 or Win2K if you have admin rights

        //printf ("\nTrying to read the drive IDs using physical access with admin rights\n");

        done = ReadPhysicalDriveInNTWithAdminRights(sBuff,nLen);



        //  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

        //printf ("\nTrying to read the drive IDs using the SCSI back door\n");

        if ( ! done){ 

            done = ReadIdeDriveAsScsiDriveInNT(sBuff,nLen);

        }



        //  this works under WinNT4 or Win2K or WinXP if you have any rights

        //printf ("\nTrying to read the drive IDs using physical access with zero rights\n");

        if ( ! done){

            done = ReadPhysicalDriveInNTWithZeroRights(sBuff,nLen);

        }



        //  this works under WinNT4 or Win2K or WinXP or Windows Server 2003 or Vista if you have any rights

        //printf ("\nTrying to read the drive IDs using Smart\n");

        if ( ! done){

            done = ReadPhysicalDriveInNTUsingSmart(sBuff,nLen);

        }

    }else{

        //  this works under Win9X and calls a VXD

        //  try this up to 10 times to get a hard drive serial number

        for (int attempt = 0; attempt < 10 && ! done && 0 == sBuff[0]; attempt++) {

            done = ReadDrivePortsInWin9X(sBuff,nLen);

        }

    }



    return done;

}