获取硬盘序列号以及mac地址

1. //  diskid32.cpp
4. //  for displaying the details of hard drives in a command window
7. //  06/11/00  Lynn McGuire  written with many contributions from others,
8. //                            IDE drives only under Windows NT/2K and 9X,
9. //                            maybe SCSI drives later
10. //  11/20/03  Lynn McGuire  added ReadPhysicalDriveInNTWithZeroRights
11. //  10/26/05  Lynn McGuire  fix the flipAndCodeBytes function
12. //  01/22/08  Lynn McGuire  incorporate changes from Gonzalo Diethelm,
13. //                             remove media serial number code since does 
14. //                             not work on USB hard drives or thumb drives
15. //  01/29/08  Lynn McGuire  add ReadPhysicalDriveInNTUsingSmart
18. #define PRINTING_TO_CONSOLE_ALLOWED
21. #include <stdlib.h>
22. #include <stdio.h>
23. #include <stddef.h>
24. #include <string.h>
25. #include <windows.h>
26. #include <winioctl.h>
29.     //  special include from the MS DDK
30. //#include "c:/win2kddk/inc/ddk/ntddk.h"
31. //#include "c:/win2kddk/inc/ntddstor.h"
34. #define  TITLE   "DiskId32"
37. char HardDriveSerialNumber [1024];
38. char HardDriveModelNumber [1024];
39. int PRINT_DEBUG = false;
42. static void dump_buffer (const char* title,
43.             const unsigned char* buffer,
44.             int len);
47. void WriteConstantString (char *entry, char *string)
48. {
49. }
53.    //  Required to ensure correct PhysicalDrive IOCTL structure setup
54. #pragma pack(1)
57. #define  IDENTIFY_BUFFER_SIZE  512
60.    //  IOCTL commands
61. #define  DFP_GET_VERSION          0x00074080
62. #define  DFP_SEND_DRIVE_COMMAND   0x0007c084
63. #define  DFP_RECEIVE_DRIVE_DATA   0x0007c088
65. #define  FILE_DEVICE_SCSI              0x0000001b
66. #define  IOCTL_SCSI_MINIPORT_IDENTIFY  ((FILE_DEVICE_SCSI << 16) + 0x0501)
67. #define  IOCTL_SCSI_MINIPORT 0x0004D008  //  see NTDDSCSI.H for definition
69. #define SMART_GET_VERSION               CTL_CODE(IOCTL_DISK_BASE, 0x0020, METHOD_BUFFERED, FILE_READ_ACCESS)
70. #define SMART_SEND_DRIVE_COMMAND        CTL_CODE(IOCTL_DISK_BASE, 0x0021, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
71. #define SMART_RCV_DRIVE_DATA            CTL_CODE(IOCTL_DISK_BASE, 0x0022, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
74. typedef struct _GETVERSIONINPARAMS {
75.         UCHAR    bVersion;               // Binary driver version.
76.         UCHAR    bRevision;              // Binary driver revision.
77.         UCHAR    bReserved;              // Not used.
78.         UCHAR    bIDEDeviceMap;          // Bit map of IDE devices.
79.         ULONG   fCapabilities;          // Bit mask of driver capabilities.
80.         ULONG   dwReserved[4];          // For future use.
81. } GETVERSIONINPARAMS, *PGETVERSIONINPARAMS, *LPGETVERSIONINPARAMS;
84.    //  GETVERSIONOUTPARAMS contains the data returned from the 
85.    //  Get Driver Version function.
86. typedef struct _GETVERSIONOUTPARAMS
87. {
88.    BYTE bVersion;      // Binary driver version.
89.    BYTE bRevision;     // Binary driver revision.
90.    BYTE bReserved;     // Not used.
91.    BYTE bIDEDeviceMap; // Bit map of IDE devices.
92.    DWORD fCapabilities; // Bit mask of driver capabilities.
93.    DWORD dwReserved[4]; // For future use.
94. } GETVERSIONOUTPARAMS, *PGETVERSIONOUTPARAMS, *LPGETVERSIONOUTPARAMS;
97.    //  Bits returned in the fCapabilities member of GETVERSIONOUTPARAMS 
98. #define  CAP_IDE_ID_FUNCTION             1  // ATA ID command supported
99. #define  CAP_IDE_ATAPI_ID                2  // ATAPI ID command supported
100. #define  CAP_IDE_EXECUTE_SMART_FUNCTION  4  // SMART commannds supported
103.    //  IDE registers
104. typedef struct _IDEREGS
105. {
106.    BYTE bFeaturesReg;       // Used for specifying SMART "commands".
107.    BYTE bSectorCountReg;    // IDE sector count register
108.    BYTE bSectorNumberReg;   // IDE sector number register
109.    BYTE bCylLowReg;         // IDE low order cylinder value
110.    BYTE bCylHighReg;        // IDE high order cylinder value
111.    BYTE bDriveHeadReg;      // IDE drive/head register
112.    BYTE bCommandReg;        // Actual IDE command.
113.    BYTE bReserved;          // reserved for future use.  Must be zero.
114. } IDEREGS, *PIDEREGS, *LPIDEREGS;
117.    //  SENDCMDINPARAMS contains the input parameters for the 
118.    //  Send Command to Drive function.
119. typedef struct _SENDCMDINPARAMS
120. {
121.    DWORD     cBufferSize;   //  Buffer size in bytes
122.    IDEREGS   irDriveRegs;   //  Structure with drive register values.
123.    BYTE bDriveNumber;       //  Physical drive number to send 
124.                             //  command to (0,1,2,3).
125.    BYTE bReserved[3];       //  Reserved for future expansion.
126.    DWORD     dwReserved[4]; //  For future use.
127.    BYTE      bBuffer[1];    //  Input buffer.
128. } SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS;
131.    //  Valid values for the bCommandReg member of IDEREGS.
132. #define  IDE_ATAPI_IDENTIFY  0xA1  //  Returns ID sector for ATAPI.
133. #define  IDE_ATA_IDENTIFY    0xEC  //  Returns ID sector for ATA.
136.    // Status returned from driver
137. typedef struct _DRIVERSTATUS
138. {
139.    BYTE  bDriverError;  //  Error code from driver, or 0 if no error.
140.    BYTE  bIDEStatus;    //  Contents of IDE Error register.
141.                         //  Only valid when bDriverError is SMART_IDE_ERROR.
142.    BYTE  bReserved[2];  //  Reserved for future expansion.
143.    DWORD  dwReserved[2];  //  Reserved for future expansion.
144. } DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS;
147.    // Structure returned by PhysicalDrive IOCTL for several commands
148. typedef struct _SENDCMDOUTPARAMS
149. {
150.    DWORD         cBufferSize;   //  Size of bBuffer in bytes
151.    DRIVERSTATUS  DriverStatus;  //  Driver status structure.
152.    BYTE          bBuffer[1];    //  Buffer of arbitrary length in which to store the data read from the                                                       // drive.
153. } SENDCMDOUTPARAMS, *PSENDCMDOUTPARAMS, *LPSENDCMDOUTPARAMS;
156.    // The following struct defines the interesting part of the IDENTIFY
157.    // buffer:
158. typedef struct _IDSECTOR
159. {
160.    USHORT  wGenConfig;
161.    USHORT  wNumCyls;
162.    USHORT  wReserved;
163.    USHORT  wNumHeads;
164.    USHORT  wBytesPerTrack;
165.    USHORT  wBytesPerSector;
166.    USHORT  wSectorsPerTrack;
167.    USHORT  wVendorUnique[3];
168.    CHAR    sSerialNumber[20];
169.    USHORT  wBufferType;
170.    USHORT  wBufferSize;
171.    USHORT  wECCSize;
172.    CHAR    sFirmwareRev[8];
173.    CHAR    sModelNumber[40];
174.    USHORT  wMoreVendorUnique;
175.    USHORT  wDoubleWordIO;
176.    USHORT  wCapabilities;
177.    USHORT  wReserved1;
178.    USHORT  wPIOTiming;
179.    USHORT  wDMATiming;
180.    USHORT  wBS;
181.    USHORT  wNumCurrentCyls;
182.    USHORT  wNumCurrentHeads;
183.    USHORT  wNumCurrentSectorsPerTrack;
184.    ULONG   ulCurrentSectorCapacity;
185.    USHORT  wMultSectorStuff;
186.    ULONG   ulTotalAddressableSectors;
187.    USHORT  wSingleWordDMA;
188.    USHORT  wMultiWordDMA;
189.    BYTE    bReserved[128];
190. } IDSECTOR, *PIDSECTOR;
193. typedef struct _SRB_IO_CONTROL
194. {
195.    ULONG HeaderLength;
196.    UCHAR Signature[8];
197.    ULONG Timeout;
198.    ULONG ControlCode;
199.    ULONG ReturnCode;
200.    ULONG Length;
201. } SRB_IO_CONTROL, *PSRB_IO_CONTROL;
204.    // Define global buffers.
205. BYTE IdOutCmd [sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
208. char *ConvertToString (DWORD diskdata [256],
209.                int firstIndex,
210.                int lastIndex,
211.                char* buf);
212. void PrintIdeInfo (int drive, DWORD diskdata [256]);
213. BOOL DoIDENTIFY (HANDLE, PSENDCMDINPARAMS, PSENDCMDOUTPARAMS, BYTE, BYTE,
214.                  PDWORD);
217.    //  Max number of drives assuming primary/secondary, master/slave topology
218. #define  MAX_IDE_DRIVES  16
221. int ReadPhysicalDriveInNTWithAdminRights (void)
222. {
223.    int done = FALSE;
224.    int drive = 0;
226.    for (drive = 0; drive < MAX_IDE_DRIVES; drive++)
227.    {
228.       HANDLE hPhysicalDriveIOCTL = 0;
230.          //  Try to get a handle to PhysicalDrive IOCTL, report failure
231.          //  and exit if can't.
232.       char driveName [256];
234.       sprintf (driveName, ".//PhysicalDrive%d", drive);
236.          //  Windows NT, Windows 2000, must have admin rights
237.       hPhysicalDriveIOCTL = CreateFile (driveName,
238.                                GENERIC_READ | GENERIC_WRITE, 
239.                                FILE_SHARE_READ | FILE_SHARE_WRITE , NULL,
240.                                OPEN_EXISTING, 0, NULL);
241.       // if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
242.       //    printf ("Unable to open physical drive %d, error code: 0x%lX/n",
243.       //            drive, GetLastError ());
245.       if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
246.       {
247. #ifdef PRINTING_TO_CONSOLE_ALLOWED
248.          if (PRINT_DEBUG) 
249.              printf ("/n%d ReadPhysicalDriveInNTWithAdminRights ERROR"
250.                      "/nCreateFile(%s) returned INVALID_HANDLE_VALUE/n",
251.                      __LINE__, driveName);
252. #endif
253.       }
254.       else
255.       {
256.          GETVERSIONOUTPARAMS VersionParams;
257.          DWORD               cbBytesReturned = 0;
259.             // Get the version, etc of PhysicalDrive IOCTL
260.          memset ((void*) &VersionParams, 0, sizeof(VersionParams));
262.          if ( ! DeviceIoControl (hPhysicalDriveIOCTL, DFP_GET_VERSION,
263.                    NULL, 
264.                    0,
265.                    &VersionParams,
266.                    sizeof(VersionParams),
267.                    &cbBytesReturned, NULL) )
268.          {         
269. #ifdef PRINTING_TO_CONSOLE_ALLOWED
270.             if (PRINT_DEBUG)
271.             {
272.                DWORD err = GetLastError ();
273.                printf ("/n%d ReadPhysicalDriveInNTWithAdminRights ERROR"
274.                        "/nDeviceIoControl(%d, DFP_GET_VERSION) returned 0, error is %d/n",
275.                        __LINE__, (int) hPhysicalDriveIOCTL, (int) err);
276.             }
277. #endif
278.          }
280.             // If there is a IDE device at number "i" issue commands
281.             // to the device
282.          if (VersionParams.bIDEDeviceMap <= 0)
283.          {
284. #ifdef PRINTING_TO_CONSOLE_ALLOWED
285.             if (PRINT_DEBUG)
286.                 printf ("/n%d ReadPhysicalDriveInNTWithAdminRights ERROR"
287.                         "/nNo device found at position %d (%d)/n",
288.                         __LINE__, (int) drive, (int) VersionParams.bIDEDeviceMap);
289. #endif
290.          }
291.          else
292.          {
293.             BYTE             bIDCmd = 0;   // IDE or ATAPI IDENTIFY cmd
294.             SENDCMDINPARAMS  scip;
295.             //SENDCMDOUTPARAMS OutCmd;
297.                // Now, get the ID sector for all IDE devices in the system.
298.                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
299.                // otherwise use the IDE_ATA_IDENTIFY command
300.             bIDCmd = (VersionParams.bIDEDeviceMap >> drive & 0x10) ? /
301.                       IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
303.             memset (&scip, 0, sizeof(scip));
304.             memset (IdOutCmd, 0, sizeof(IdOutCmd));
306.             if ( DoIDENTIFY (hPhysicalDriveIOCTL, 
307.                        &scip, 
308.                        (PSENDCMDOUTPARAMS)&IdOutCmd, 
309.                        (BYTE) bIDCmd,
310.                        (BYTE) drive,
311.                        &cbBytesReturned))
312.             {
313.                DWORD diskdata [256];
314.                int ijk = 0;
315.                USHORT *pIdSector = (USHORT *)
316.                              ((PSENDCMDOUTPARAMS) IdOutCmd) -> bBuffer;
318.                for (ijk = 0; ijk < 256; ijk++)
319.                   diskdata [ijk] = pIdSector [ijk];
321.                PrintIdeInfo (drive, diskdata);
323.                done = TRUE;
324.             }
325.         }
327.          CloseHandle (hPhysicalDriveIOCTL);
328.       }
329.    }
331.    return done;
332. }
336. //
337. // IDENTIFY data (from ATAPI driver source)
338. //
340. #pragma pack(1)
342. typedef struct _IDENTIFY_DATA {
343.     USHORT GeneralConfiguration;            // 00 00
344.     USHORT NumberOfCylinders;               // 02  1
345.     USHORT Reserved1;                       // 04  2
346.     USHORT NumberOfHeads;                   // 06  3
347.     USHORT UnformattedBytesPerTrack;        // 08  4
348.     USHORT UnformattedBytesPerSector;       // 0A  5
349.     USHORT SectorsPerTrack;                 // 0C  6
350.     USHORT VendorUnique1[3];                // 0E  7-9
351.     USHORT SerialNumber[10];                // 14  10-19
352.     USHORT BufferType;                      // 28  20
353.     USHORT BufferSectorSize;                // 2A  21
354.     USHORT NumberOfEccBytes;                // 2C  22
355.     USHORT FirmwareRevision[4];             // 2E  23-26
356.     USHORT ModelNumber[20];                 // 36  27-46
357.     UCHAR  MaximumBlockTransfer;            // 5E  47
358.     UCHAR  VendorUnique2;                   // 5F
359.     USHORT DoubleWordIo;                    // 60  48
360.     USHORT Capabilities;                    // 62  49
361.     USHORT Reserved2;                       // 64  50
362.     UCHAR  VendorUnique3;                   // 66  51
363.     UCHAR  PioCycleTimingMode;              // 67
364.     UCHAR  VendorUnique4;                   // 68  52
365.     UCHAR  DmaCycleTimingMode;              // 69
366.     USHORT TranslationFieldsValid:1;        // 6A  53
367.     USHORT Reserved3:15;
368.     USHORT NumberOfCurrentCylinders;        // 6C  54
369.     USHORT NumberOfCurrentHeads;            // 6E  55
370.     USHORT CurrentSectorsPerTrack;          // 70  56
371.     ULONG  CurrentSectorCapacity;           // 72  57-58
372.     USHORT CurrentMultiSectorSetting;       //     59
373.     ULONG  UserAddressableSectors;          //     60-61
374.     USHORT SingleWordDMASupport : 8;        //     62
375.     USHORT SingleWordDMAActive : 8;
376.     USHORT MultiWordDMASupport : 8;         //     63
377.     USHORT MultiWordDMAActive : 8;
378.     USHORT AdvancedPIOModes : 8;            //     64
379.     USHORT Reserved4 : 8;
380.     USHORT MinimumMWXferCycleTime;          //     65
381.     USHORT RecommendedMWXferCycleTime;      //     66
382.     USHORT MinimumPIOCycleTime;             //     67
383.     USHORT MinimumPIOCycleTimeIORDY;        //     68
384.     USHORT Reserved5[2];                    //     69-70
385.     USHORT ReleaseTimeOverlapped;           //     71
386.     USHORT ReleaseTimeServiceCommand;       //     72
387.     USHORT MajorRevision;                   //     73
388.     USHORT MinorRevision;                   //     74
389.     USHORT Reserved6[50];                   //     75-126
390.     USHORT SpecialFunctionsEnabled;         //     127
391.     USHORT Reserved7[128];                  //     128-255
392. } IDENTIFY_DATA, *PIDENTIFY_DATA;
394. #pragma pack()
398. int ReadPhysicalDriveInNTUsingSmart (void)
399. {
400.    int done = FALSE;
401.    int drive = 0;
403.    for (drive = 0; drive < MAX_IDE_DRIVES; drive++)
404.    {
405.       HANDLE hPhysicalDriveIOCTL = 0;
407.          //  Try to get a handle to PhysicalDrive IOCTL, report failure
408.          //  and exit if can't.
409.       char driveName [256];
411.       sprintf (driveName, ".//PhysicalDrive%d", drive);
413.          //  Windows NT, Windows 2000, Windows Server 2003, Vista
414.       hPhysicalDriveIOCTL = CreateFile (driveName,
415.                                GENERIC_READ | GENERIC_WRITE, 
416.                                FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 
417.                                NULL, OPEN_EXISTING, 0, NULL);
418.       // if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
419.       //    printf ("Unable to open physical drive %d, error code: 0x%lX/n",
420.       //            drive, GetLastError ());
422.       if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
423.       {
424. #ifdef PRINTING_TO_CONSOLE_ALLOWED
425.          if (PRINT_DEBUG) 
426.              printf ("/n%d ReadPhysicalDriveInNTUsingSmart ERROR"
427.                      "/nCreateFile(%s) returned INVALID_HANDLE_VALUE/n"
428.                      "Error Code %d/n",
429.                      __LINE__, driveName, GetLastError ());
430. #endif
431.       }
432.       else
433.       {
434.          GETVERSIONINPARAMS GetVersionParams;
435.          DWORD cbBytesReturned = 0;
437.             // Get the version, etc of PhysicalDrive IOCTL
438.          memset ((void*) & GetVersionParams, 0, sizeof(GetVersionParams));
440.          if ( ! DeviceIoControl (hPhysicalDriveIOCTL, SMART_GET_VERSION,
441.                    NULL, 
442.                    0,
443.                    &GetVersionParams, sizeof (GETVERSIONINPARAMS),
444.                    &cbBytesReturned, NULL) )
445.          {         
446. #ifdef PRINTING_TO_CONSOLE_ALLOWED
447.             if (PRINT_DEBUG)
448.             {
449.                DWORD err = GetLastError ();
450.                printf ("/n%d ReadPhysicalDriveInNTUsingSmart ERROR"
451.                        "/nDeviceIoControl(%d, SMART_GET_VERSION) returned 0, error is %d/n",
452.                        __LINE__, (int) hPhysicalDriveIOCTL, (int) err);
453.             }
454. #endif
455.          }
456.          else
457.          {
458.                 // Print the SMART version
459.             // PrintVersion (& GetVersionParams);
460.                // Allocate the command buffer
461.             ULONG CommandSize = sizeof(SENDCMDINPARAMS) + IDENTIFY_BUFFER_SIZE;
462.             PSENDCMDINPARAMS Command = (PSENDCMDINPARAMS) malloc (CommandSize);
463.                // Retrieve the IDENTIFY data
464.                // Prepare the command
465. #define ID_CMD          0xEC            // Returns ID sector for ATA
466.             Command -> irDriveRegs.bCommandReg = ID_CMD;
467.             DWORD BytesReturned = 0;
468.             if ( ! DeviceIoControl (hPhysicalDriveIOCTL, 
469.                                     SMART_RCV_DRIVE_DATA, Command, sizeof(SENDCMDINPARAMS),
470.                                     Command, CommandSize,
471.                                     &BytesReturned, NULL) )
472.             {
473.                    // Print the error
474.                 //PrintError ("SMART_RCV_DRIVE_DATA IOCTL", GetLastError());
475.             } 
476.             else
477.             {
478.                    // Print the IDENTIFY data
479.                 DWORD diskdata [256];
480.                 USHORT *pIdSector = (USHORT *)
481.                              (PIDENTIFY_DATA) ((PSENDCMDOUTPARAMS) Command) -> bBuffer;
483.                 for (int ijk = 0; ijk < 256; ijk++)
484.                    diskdata [ijk] = pIdSector [ijk];
486.                 PrintIdeInfo (drive, diskdata);
487.                 done = TRUE;
488.             }
489.                // Done
490.             CloseHandle (hPhysicalDriveIOCTL);
491.             free (Command);
492.          }
493.       }
494.    }
496.    return done;
497. }
501. //  Required to ensure correct PhysicalDrive IOCTL structure setup
502. #pragma pack(4)
505. //
506. // IOCTL_STORAGE_QUERY_PROPERTY
507. //
508. // Input Buffer:
509. //      a STORAGE_PROPERTY_QUERY structure which describes what type of query
510. //      is being done, what property is being queried for, and any additional
511. //      parameters which a particular property query requires.
512. //
513. //  Output Buffer:
514. //      Contains a buffer to place the results of the query into.  Since all
515. //      property descriptors can be cast into a STORAGE_DESCRIPTOR_HEADER,
516. //      the IOCTL can be called once with a small buffer then again using
517. //      a buffer as large as the header reports is necessary.
518. //
521. //
522. // Types of queries
523. //
525. typedef enum _STORAGE_QUERY_TYPE {
526.     PropertyStandardQuery = 0,          // Retrieves the descriptor
527.     PropertyExistsQuery,                // Used to test whether the descriptor is supported
528.     PropertyMaskQuery,                  // Used to retrieve a mask of writeable fields in the descriptor
529.     PropertyQueryMaxDefined     // use to validate the value
530. } STORAGE_QUERY_TYPE, *PSTORAGE_QUERY_TYPE;
532. //
533. // define some initial property id's
534. //
536. typedef enum _STORAGE_PROPERTY_ID {
537.     StorageDeviceProperty = 0,
538.     StorageAdapterProperty
539. } STORAGE_PROPERTY_ID, *PSTORAGE_PROPERTY_ID;
541. //
542. // Query structure - additional parameters for specific queries can follow
543. // the header
544. //
546. typedef struct _STORAGE_PROPERTY_QUERY {
548.     //
549.     // ID of the property being retrieved
550.     //
552.     STORAGE_PROPERTY_ID PropertyId;
554.     //
555.     // Flags indicating the type of query being performed
556.     //
558.     STORAGE_QUERY_TYPE QueryType;
560.     //
561.     // Space for additional parameters if necessary
562.     //
564.     UCHAR AdditionalParameters[1];
566. } STORAGE_PROPERTY_QUERY, *PSTORAGE_PROPERTY_QUERY;
569. #define IOCTL_STORAGE_QUERY_PROPERTY   CTL_CODE(IOCTL_STORAGE_BASE, 0x0500, METHOD_BUFFERED, FILE_ANY_ACCESS)
572. //
573. // Device property descriptor - this is really just a rehash of the inquiry
574. // data retrieved from a scsi device
575. //
576. // This may only be retrieved from a target device.  Sending this to the bus
577. // will result in an error
578. //
580. #pragma pack(4)
582. typedef struct _STORAGE_DEVICE_DESCRIPTOR {
584.     //
585.     // Sizeof(STORAGE_DEVICE_DESCRIPTOR)
586.     //
588.     ULONG Version;
590.     //
591.     // Total size of the descriptor, including the space for additional
592.     // data and id strings
593.     //
595.     ULONG Size;
597.     //
598.     // The SCSI-2 device type
599.     //
601.     UCHAR DeviceType;
603.     //
604.     // The SCSI-2 device type modifier (if any) - this may be zero
605.     //
607.     UCHAR DeviceTypeModifier;
609.     //
610.     // Flag indicating whether the device's media (if any) is removable.  This
611.     // field should be ignored for media-less devices
612.     //
614.     BOOLEAN RemovableMedia;
616.     //
617.     // Flag indicating whether the device can support mulitple outstanding
618.     // commands.  The actual synchronization in this case is the responsibility
619.     // of the port driver.
620.     //
622.     BOOLEAN CommandQueueing;
624.     //
625.     // Byte offset to the zero-terminated ascii string containing the device's
626.     // vendor id string.  For devices with no such ID this will be zero
627.     //
629.     ULONG VendorIdOffset;
631.     //
632.     // Byte offset to the zero-terminated ascii string containing the device's
633.     // product id string.  For devices with no such ID this will be zero
634.     //
636.     ULONG ProductIdOffset;
638.     //
639.     // Byte offset to the zero-terminated ascii string containing the device's
640.     // product revision string.  For devices with no such string this will be
641.     // zero
642.     //
644.     ULONG ProductRevisionOffset;
646.     //
647.     // Byte offset to the zero-terminated ascii string containing the device's
648.     // serial number.  For devices with no serial number this will be zero
649.     //
651.     ULONG SerialNumberOffset;
653.     //
654.     // Contains the bus type (as defined above) of the device.  It should be
655.     // used to interpret the raw device properties at the end of this structure
656.     // (if any)
657.     //
659.     STORAGE_BUS_TYPE BusType;
661.     //
662.     // The number of bytes of bus-specific data which have been appended to
663.     // this descriptor
664.     //
666.     ULONG RawPropertiesLength;
668.     //
669.     // Place holder for the first byte of the bus specific property data
670.     //
672.     UCHAR RawDeviceProperties[1];
674. } STORAGE_DEVICE_DESCRIPTOR, *PSTORAGE_DEVICE_DESCRIPTOR;
677.     //  function to decode the serial numbers of IDE hard drives
678.     //  using the IOCTL_STORAGE_QUERY_PROPERTY command 
679. char * flipAndCodeBytes (const char * str,
680.              int pos,
681.              int flip,
682.              char * buf)
683. {
684.    int i;
685.    int j = 0;
686.    int k = 0;
688.    buf [0] = '/0';
689.    if (pos <= 0)
690.       return buf;
692.    if ( ! j)
693.    {
694.       char p = 0;
696.       // First try to gather all characters representing hex digits only.
697.       j = 1;
698.       k = 0;
699.       buf[k] = 0;
700.       for (i = pos; j && str[i] != '/0'; ++i)
701.       {
702.      char c = tolower(str[i]);
704.      if (isspace(c))
705.         c = '0';
707.      ++p;
708.      buf[k] <<= 4;
710.      if (c >= '0' && c <= '9')
711.         buf[k] |= (unsigned char) (c - '0');
712.      else if (c >= 'a' && c <= 'f')
713.         buf[k] |= (unsigned char) (c - 'a' + 10);
714.      else
715.      {
716.         j = 0;
717.         break;
718.      }
720.      if (p == 2)
721.      {
722.         if (buf[k] != '/0' && ! isprint(buf[k]))
723.         {
724.            j = 0;
725.            break;
726.         }
727.         ++k;
728.         p = 0;
729.         buf[k] = 0;
730.      }
732.       }
733.    }
735.    if ( ! j)
736.    {
737.       // There are non-digit characters, gather them as is.
738.       j = 1;
739.       k = 0;
740.       for (i = pos; j && str[i] != '/0'; ++i)
741.       {
742.          char c = str[i];
744.          if ( ! isprint(c))
745.          {
746.             j = 0;
747.             break;
748.          }
750.          buf[k++] = c;
751.       }
752.    }
754.    if ( ! j)
755.    {
756.       // The characters are not there or are not printable.
757.       k = 0;
758.    }
760.    buf[k] = '/0';
762.    if (flip)
763.       // Flip adjacent characters
764.       for (j = 0; j < k; j += 2)
765.       {
766.          char t = buf[j];
767.          buf[j] = buf[j + 1];
768.          buf[j + 1] = t;
769.       }
771.    // Trim any beginning and end space
772.    i = j = -1;
773.    for (k = 0; buf[k] != '/0'; ++k)
774.    {
775.       if (! isspace(buf[k]))
776.       {
777.          if (i < 0)
778.             i = k;
779.          j = k;
780.       }
781.    }
783.    if ((i >= 0) && (j >= 0))
784.    {
785.       for (k = i; (k <= j) && (buf[k] != '/0'); ++k)
786.          buf[k - i] = buf[k];
787.       buf[k - i] = '/0';
788.    }
790.    return buf;
791. }
795. #define IOCTL_DISK_GET_DRIVE_GEOMETRY_EX CTL_CODE(IOCTL_DISK_BASE, 0x0028, METHOD_BUFFERED, FILE_ANY_ACCESS)
797. typedef struct _DISK_GEOMETRY_EX {
798.   DISK_GEOMETRY  Geometry;
799.   LARGE_INTEGER  DiskSize;
800.   UCHAR  Data[1];
801. } DISK_GEOMETRY_EX, *PDISK_GEOMETRY_EX;
805. int ReadPhysicalDriveInNTWithZeroRights (void)
806. {
807.    int done = FALSE;
808.    int drive = 0;
810.    for (drive = 0; drive < MAX_IDE_DRIVES; drive++)
811.    {
812.       HANDLE hPhysicalDriveIOCTL = 0;
814.          //  Try to get a handle to PhysicalDrive IOCTL, report failure
815.          //  and exit if can't.
816.       char driveName [256];
818.       sprintf (driveName, ".//PhysicalDrive%d", drive);
820.          //  Windows NT, Windows 2000, Windows XP - admin rights not required
821.       hPhysicalDriveIOCTL = CreateFile (driveName, 0,
822.                                FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
823.                                OPEN_EXISTING, 0, NULL);
824.       if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
825.       {
826. #ifdef PRINTING_TO_CONSOLE_ALLOWED
827.          if (PRINT_DEBUG)
828.              printf ("/n%d ReadPhysicalDriveInNTWithZeroRights ERROR"
829.                      "/nCreateFile(%s) returned INVALID_HANDLE_VALUE/n",
830.                      __LINE__, driveName);
831. #endif
832.       }
833.       else
834.       {
835.          STORAGE_PROPERTY_QUERY query;
836.          DWORD cbBytesReturned = 0;
837.          char buffer [10000];
839.          memset ((void *) & query, 0, sizeof (query));
840.          query.PropertyId = StorageDeviceProperty;
841.          query.QueryType = PropertyStandardQuery;
843.          memset (buffer, 0, sizeof (buffer));
845.          if ( DeviceIoControl (hPhysicalDriveIOCTL, IOCTL_STORAGE_QUERY_PROPERTY,
846.                    & query,
847.                    sizeof (query),
848.                    & buffer,
849.                    sizeof (buffer),
850.                    & cbBytesReturned, NULL) )
851.          {         
852.              STORAGE_DEVICE_DESCRIPTOR * descrip = (STORAGE_DEVICE_DESCRIPTOR *) & buffer;
853.              char serialNumber [1000];
854.              char modelNumber [1000];
855.              char vendorId [1000];
856.              char productRevision [1000];
858. #ifdef PRINTING_TO_CONSOLE_ALLOWED
859.              if (PRINT_DEBUG)
860.              {
861.                  printf ("/n%d STORAGE_DEVICE_DESCRIPTOR contents for drive %d/n"
862.                          "                Version: %ld/n"
863.                          "                   Size: %ld/n"
864.                          "             DeviceType: %02x/n"
865.                          "     DeviceTypeModifier: %02x/n"
866.                          "         RemovableMedia: %d/n"
867.                          "        CommandQueueing: %d/n"
868.                          "         VendorIdOffset: %4ld (0x%02lx)/n"
869.                          "        ProductIdOffset: %4ld (0x%02lx)/n"
870.                          "  ProductRevisionOffset: %4ld (0x%02lx)/n"
871.                          "     SerialNumberOffset: %4ld (0x%02lx)/n"
872.                          "                BusType: %d/n"
873.                          "    RawPropertiesLength: %ld/n",
874.                          __LINE__, drive,
875.                          (unsigned long) descrip->Version,
876.                          (unsigned long) descrip->Size,
877.                          (int) descrip->DeviceType,
878.                          (int) descrip->DeviceTypeModifier,
879.                          (int) descrip->RemovableMedia,
880.                          (int) descrip->CommandQueueing,
881.                          (unsigned long) descrip->VendorIdOffset,
882.                          (unsigned long) descrip->VendorIdOffset,
883.                          (unsigned long) descrip->ProductIdOffset,
884.                          (unsigned long) descrip->ProductIdOffset,
885.                          (unsigned long) descrip->ProductRevisionOffset,
886.                          (unsigned long) descrip->ProductRevisionOffset,
887.                          (unsigned long) descrip->SerialNumberOffset,
888.                          (unsigned long) descrip->SerialNumberOffset,
889.                          (int) descrip->BusType,
890.                          (unsigned long) descrip->RawPropertiesLength);
892.                 dump_buffer ("Contents of RawDeviceProperties",
893.                              (unsigned char*) descrip->RawDeviceProperties,
894.                              descrip->RawPropertiesLength);
896.                 dump_buffer ("Contents of first 256 bytes in buffer",
897.                              (unsigned char*) buffer, 256);
898.              }
899. #endif
900.              flipAndCodeBytes (buffer,
901.                                descrip -> VendorIdOffset,
902.                                0, vendorId );
903.              flipAndCodeBytes (buffer,
904.                                descrip -> ProductIdOffset,
905.                                0, modelNumber );
906.              flipAndCodeBytes (buffer,
907.                                descrip -> ProductRevisionOffset,
908.                                0, productRevision );
909.              flipAndCodeBytes (buffer,
910.                                descrip -> SerialNumberOffset,
911.                                1, serialNumber );
913.              if (0 == HardDriveSerialNumber [0] &
914.                         //  serial number must be alphanumeric
915.                         //  (but there can be leading spaces on IBM drives)
916.                    (isalnum (serialNumber [0]) || isalnum (serialNumber [19])))
917.              {
918.                 strcpy (HardDriveSerialNumber, serialNumber);
919.                 strcpy (HardDriveModelNumber, modelNumber);
920.                 done = TRUE;
921.              }
922. #ifdef PRINTING_TO_CONSOLE_ALLOWED
923.              printf ("/n**** STORAGE_DEVICE_DESCRIPTOR for drive %d ****/n"
924.                      "Vendor Id = [%s]/n"
925.                      "Product Id = [%s]/n"
926.                      "Product Revision = [%s]/n"
927.                      "Serial Number = [%s]/n",
928.                      drive,
929.                      vendorId,
930.                      modelNumber,
931.                      productRevision,
932.                      serialNumber);
933. #endif
934.                // Get the disk drive geometry.
935.              memset (buffer, 0, sizeof(buffer));
936.              if ( ! DeviceIoControl (hPhysicalDriveIOCTL,
937.                       IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
938.                       NULL,
939.                       0,
940.                       &buffer,
941.                       sizeof(buffer),
942.                       &cbBytesReturned,
943.                       NULL))
944.              {
945. #ifdef PRINTING_TO_CONSOLE_ALLOWED
946.                 if (PRINT_DEBUG)
947.                    printf ("/n%d ReadPhysicalDriveInNTWithZeroRights ERROR"
948.                            "|nDeviceIoControl(%s, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX) returned 0",
949.                            driveName);
950. #endif
951.              }
952.              else
953.              {         
954.                 DISK_GEOMETRY_EX* geom = (DISK_GEOMETRY_EX*) &buffer;
955.                 int fixed = (geom->Geometry.MediaType == FixedMedia);
956.                 __int64 size = geom->DiskSize.QuadPart;
957.                      
958. #ifdef PRINTING_TO_CONSOLE_ALLOWED
959.                 printf ("/n**** DISK_GEOMETRY_EX for drive %d ****/n"
960.                         "Disk is%s fixed/n"
961.                         "DiskSize = %I64d/n",
962.                         drive,
963.                         fixed ? "" : " NOT",
964.                         size);
965. #endif
966.             }
967.          }
968.          else
969.          {
970.              DWORD err = GetLastError ();
971. #ifdef PRINTING_TO_CONSOLE_ALLOWED
972.              printf ("/nDeviceIOControl IOCTL_STORAGE_QUERY_PROPERTY error = %d/n", err);
973. #endif
974.          }
976.          CloseHandle (hPhysicalDriveIOCTL);
977.       }
978.    }
980.    return done;
981. }
984.    // DoIDENTIFY
985.    // FUNCTION: Send an IDENTIFY command to the drive
986.    // bDriveNum = 0-3
987.    // bIDCmd = IDE_ATA_IDENTIFY or IDE_ATAPI_IDENTIFY
988. BOOL DoIDENTIFY (HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
989.                  PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum,
990.                  PDWORD lpcbBytesReturned)
991. {
992.       // Set up data structures for IDENTIFY command.
993.    pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE;
994.    pSCIP -> irDriveRegs.bFeaturesReg = 0;
995.    pSCIP -> irDriveRegs.bSectorCountReg = 1;
996.    //pSCIP -> irDriveRegs.bSectorNumberReg = 1;
997.    pSCIP -> irDriveRegs.bCylLowReg = 0;
998.    pSCIP -> irDriveRegs.bCylHighReg = 0;
1000.       // Compute the drive number.
1001.    pSCIP -> irDriveRegs.bDriveHeadReg = 0xA0 | ((bDriveNum & 1) << 4);
1003.       // The command can either be IDE identify or ATAPI identify.
1004.    pSCIP -> irDriveRegs.bCommandReg = bIDCmd;
1005.    pSCIP -> bDriveNumber = bDriveNum;
1006.    pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE;
1008.    return ( DeviceIoControl (hPhysicalDriveIOCTL, DFP_RECEIVE_DRIVE_DATA,
1009.                (LPVOID) pSCIP,
1010.                sizeof(SENDCMDINPARAMS) - 1,
1011.                (LPVOID) pSCOP,
1012.                sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
1013.                lpcbBytesReturned, NULL) );
1014. }
1017. //  ---------------------------------------------------
1019.    // (* Output Bbuffer for the VxD (rt_IdeDinfo record) *)
1020. typedef struct _rt_IdeDInfo_
1021. {
1022.     BYTE IDEExists[4];
1023.     BYTE DiskExists[8];
1024.     WORD DisksRawInfo[8*256];
1025. } rt_IdeDInfo, *pt_IdeDInfo;
1028.    // (* IdeDinfo "data fields" *)
1029. typedef struct _rt_DiskInfo_
1030. {
1031.    BOOL DiskExists;
1032.    BOOL ATAdevice;
1033.    BOOL RemovableDevice;
1034.    WORD TotLogCyl;
1035.    WORD TotLogHeads;
1036.    WORD TotLogSPT;
1037.    char SerialNumber[20];
1038.    char FirmwareRevision[8];
1039.    char ModelNumber[40];
1040.    WORD CurLogCyl;
1041.    WORD CurLogHeads;
1042.    WORD CurLogSPT;
1043. } rt_DiskInfo;
1046. #define  m_cVxDFunctionIdesDInfo  1
1049. //  ---------------------------------------------------
1052. int ReadDrivePortsInWin9X (void)
1053. {
1054.    int done = FALSE;
1055.    unsigned long int i = 0;
1057.    HANDLE VxDHandle = 0;
1058.    pt_IdeDInfo pOutBufVxD = 0;
1059.    DWORD lpBytesReturned = 0;
1061.         //  set the thread priority high so that we get exclusive access to the disk
1062.    BOOL status =
1063.         // SetThreadPriority (GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
1064.         SetPriorityClass (GetCurrentProcess (), REALTIME_PRIORITY_CLASS);
1065.         // SetPriorityClass (GetCurrentProcess (), HIGH_PRIORITY_CLASS);
1067. #ifdef PRINTING_TO_CONSOLE_ALLOWED
1069.    if (0 == status) 
1070.        // printf ("/nERROR: Could not SetThreadPriority, LastError: %d/n", GetLastError ());
1071.        printf ("/nERROR: Could not SetPriorityClass, LastError: %d/n", GetLastError ());
1073. #endif
1075.       // 1. Make an output buffer for the VxD
1076.    rt_IdeDInfo info;
1077.    pOutBufVxD = &info;
1079.       // *****************
1080.       // KLUDGE WARNING!!!
1081.       // HAVE to zero out the buffer space for the IDE information!
1082.       // If this is NOT done then garbage could be in the memory
1083.       // locations indicating if a disk exists or not.
1084.    ZeroMemory (&info, sizeof(info));
1086.       // 1. Try to load the VxD
1087.        //  must use the short file name path to open a VXD file
1088.    //char StartupDirectory [2048];
1089.    //char shortFileNamePath [2048];
1090.    //char *p = NULL;
1091.    //char vxd [2048];
1092.       //  get the directory that the exe was started from
1093.    //GetModuleFileName (hInst, (LPSTR) StartupDirectory, sizeof (StartupDirectory));
1094.       //  cut the exe name from string
1095.    //p = &(StartupDirectory [strlen (StartupDirectory) - 1]);
1096.    //while (p >= StartupDirectory && *p && '//' != *p) p--;
1097.    //*p = '/0';   
1098.    //GetShortPathName (StartupDirectory, shortFileNamePath, 2048);
1099.    //sprintf (vxd, ".//%s//IDE21201.VXD", shortFileNamePath);
1100.    //VxDHandle = CreateFile (vxd, 0, 0, 0,
1101.    //               0, FILE_FLAG_DELETE_ON_CLOSE, 0);   
1102.    VxDHandle = CreateFile (".//IDE21201.VXD", 0, 0, 0,
1103.                             0, FILE_FLAG_DELETE_ON_CLOSE, 0);
1105.    if (VxDHandle != INVALID_HANDLE_VALUE)
1106.    {
1107.          // 2. Run VxD function
1108.       DeviceIoControl (VxDHandle, m_cVxDFunctionIdesDInfo,
1109.                     0, 0, pOutBufVxD, sizeof(pt_IdeDInfo), &lpBytesReturned, 0);
1111.          // 3. Unload VxD
1112.       CloseHandle (VxDHandle);
1113.    }
1114.    else
1115.         MessageBox (NULL, "ERROR: Could not open IDE21201.VXD file", 
1116.                     TITLE, MB_ICONSTOP);
1118.       // 4. Translate and store data
1119.    for (i=0; i<8; i++)
1120.    {
1121.       if((pOutBufVxD->DiskExists[i]) && (pOutBufVxD->IDEExists[i/2]))
1122.       {
1123.             DWORD diskinfo [256];
1124.             for (int j = 0; j < 256; j++) 
1125.                 diskinfo [j] = pOutBufVxD -> DisksRawInfo [i * 256 + j];
1127.             // process the information for this buffer
1128.            PrintIdeInfo (i, diskinfo);
1129.             done = TRUE;
1130.       }
1131.    }
1133.         //  reset the thread priority back to normal
1134.    // SetThreadPriority (GetCurrentThread(), THREAD_PRIORITY_NORMAL);
1135.    SetPriorityClass (GetCurrentProcess (), NORMAL_PRIORITY_CLASS);
1137.    return done;
1138. }
1141. #define  SENDIDLENGTH  sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE
1144. int ReadIdeDriveAsScsiDriveInNT (void)
1145. {
1146.    int done = FALSE;
1147.    int controller = 0;
1149.    for (controller = 0; controller < 16; controller++)
1150.    {
1151.       HANDLE hScsiDriveIOCTL = 0;
1152.       char   driveName [256];
1154.          //  Try to get a handle to PhysicalDrive IOCTL, report failure
1155.          //  and exit if can't.
1156.       sprintf (driveName, ".//Scsi%d:", controller);
1158.          //  Windows NT, Windows 2000, any rights should do
1159.       hScsiDriveIOCTL = CreateFile (driveName,
1160.                                GENERIC_READ | GENERIC_WRITE, 
1161.                                FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1162.                                OPEN_EXISTING, 0, NULL);
1163.       // if (hScsiDriveIOCTL == INVALID_HANDLE_VALUE)
1164.       //    printf ("Unable to open SCSI controller %d, error code: 0x%lX/n",
1165.       //            controller, GetLastError ());
1167.       if (hScsiDriveIOCTL != INVALID_HANDLE_VALUE)
1168.       {
1169.          int drive = 0;
1171.          for (drive = 0; drive < 2; drive++)
1172.          {
1173.             char buffer [sizeof (SRB_IO_CONTROL) + SENDIDLENGTH];
1174.             SRB_IO_CONTROL *p = (SRB_IO_CONTROL *) buffer;
1175.             SENDCMDINPARAMS *pin =
1176.                    (SENDCMDINPARAMS *) (buffer + sizeof (SRB_IO_CONTROL));
1177.             DWORD dummy;
1178.    
1179.             memset (buffer, 0, sizeof (buffer));
1180.             p -> HeaderLength = sizeof (SRB_IO_CONTROL);
1181.             p -> Timeout = 10000;
1182.             p -> Length = SENDIDLENGTH;
1183.             p -> ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;
1184.             strncpy ((char *) p -> Signature, "SCSIDISK", 8);
1185.   
1186.             pin -> irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY;
1187.             pin -> bDriveNumber = drive;
1189.             if (DeviceIoControl (hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT, 
1190.                                  buffer,
1191.                                  sizeof (SRB_IO_CONTROL) +
1192.                                          sizeof (SENDCMDINPARAMS) - 1,
1193.                                  buffer,
1194.                                  sizeof (SRB_IO_CONTROL) + SENDIDLENGTH,
1195.                                  &dummy, NULL))
1196.             {
1197.                SENDCMDOUTPARAMS *pOut =
1198.                     (SENDCMDOUTPARAMS *) (buffer + sizeof (SRB_IO_CONTROL));
1199.                IDSECTOR *pId = (IDSECTOR *) (pOut -> bBuffer);
1200.                if (pId -> sModelNumber [0])
1201.                {
1202.                   DWORD diskdata [256];
1203.                   int ijk = 0;
1204.                   USHORT *pIdSector = (USHORT *) pId;
1205.           
1206.                   for (ijk = 0; ijk < 256; ijk++)
1207.                      diskdata [ijk] = pIdSector [ijk];
1209.                   PrintIdeInfo (controller * 2 + drive, diskdata);
1211.                   done = TRUE;
1212.                }
1213.             }
1214.          }
1215.          CloseHandle (hScsiDriveIOCTL);
1216.       }
1217.    }
1219.    return done;
1220. }
1223. void PrintIdeInfo (int drive, DWORD diskdata [256])
1224. {
1225.    char serialNumber [1024];
1226.    char modelNumber [1024];
1227.    char revisionNumber [1024];
1228.    char bufferSize [32];
1230.    __int64 sectors = 0;
1231.    __int64 bytes = 0;
1233.       //  copy the hard drive serial number to the buffer
1234.    ConvertToString (diskdata, 10, 19, serialNumber);
1235.    ConvertToString (diskdata, 27, 46, modelNumber);
1236.    ConvertToString (diskdata, 23, 26, revisionNumber);
1237.    sprintf (bufferSize, "%u", diskdata [21] * 512);
1239.    if (0 == HardDriveSerialNumber [0] &
1240.        //  serial number must be alphanumeric
1241.        //  (but there can be leading spaces on IBM drives)
1242.        (isalnum (serialNumber [0]) || isalnum (serialNumber [19])))
1243.    {
1244.       strcpy (HardDriveSerialNumber, serialNumber);
1245.       strcpy (HardDriveModelNumber, modelNumber);
1246.    }
1248. #ifdef PRINTING_TO_CONSOLE_ALLOWED
1250.    printf ("/nDrive %d - ", drive);
1252.    switch (drive / 2)
1253.    {
1254.       case 0: printf ("Primary Controller - ");
1255.               break;
1256.       case 1: printf ("Secondary Controller - ");
1257.               break;
1258.       case 2: printf ("Tertiary Controller - ");
1259.               break;
1260.       case 3: printf ("Quaternary Controller - ");
1261.               break;
1262.    }
1264.    switch (drive % 2)
1265.    {
1266.       case 0: printf (" - Master drive/n/n");
1267.               break;
1268.       case 1: printf (" - Slave drive/n/n");
1269.               break;
1270.    }
1272.    printf ("Drive Model Number________________: [%s]/n",
1273.            modelNumber);
1274.    printf ("Drive Serial Number_______________: [%s]/n",
1275.            serialNumber);
1276.    printf ("Drive Controller Revision Number__: [%s]/n",
1277.            revisionNumber);
1279.    printf ("Controller Buffer Size on Drive___: %s bytes/n",
1280.            bufferSize);
1282.    printf ("Drive Type________________________: ");
1283.    if (diskdata [0] & 0x0080)
1284.       printf ("Removable/n");
1285.    else if (diskdata [0] & 0x0040)
1286.       printf ("Fixed/n");
1287.    else printf ("Unknown/n");
1288.            
1289.         //  calculate size based on 28 bit or 48 bit addressing
1290.         //  48 bit addressing is reflected by bit 10 of word 83
1291.     if (diskdata [83] & 0x400) 
1292.         sectors = diskdata [103] * 65536I64 * 65536I64 * 65536I64 + 
1293.                     diskdata [102] * 65536I64 * 65536I64 + 
1294.                     diskdata [101] * 65536I64 + 
1295.                     diskdata [100];
1296.     else
1297.         sectors = diskdata [61] * 65536 + diskdata [60];
1298.         //  there are 512 bytes in a sector
1299.     bytes = sectors * 512;
1300.     printf ("Drive Size________________________: %I64d bytes/n",
1301.             bytes);
1303. #endif  // PRINTING_TO_CONSOLE_ALLOWED
1305.    char string1 [1000];
1306.    sprintf (string1, "Drive%dModelNumber", drive);
1307.    WriteConstantString (string1, modelNumber);
1309.    sprintf (string1, "Drive%dSerialNumber", drive);
1310.    WriteConstantString (string1, serialNumber);
1312.    sprintf (string1, "Drive%dControllerRevisionNumber", drive);
1313.    WriteConstantString (string1, revisionNumber);
1315.    sprintf (string1, "Drive%dControllerBufferSize", drive);
1316.    WriteConstantString (string1, bufferSize);
1318.    sprintf (string1, "Drive%dType", drive);
1319.    if (diskdata [0] & 0x0080)
1320.       WriteConstantString (string1, "Removable");
1321.    else if (diskdata [0] & 0x0040)
1322.       WriteConstantString (string1, "Fixed");
1323.    else
1324.       WriteConstantString (string1, "Unknown");
1325. }
1329. char *ConvertToString (DWORD diskdata [256],
1330.                int firstIndex,
1331.                int lastIndex,
1332.                char* buf)
1333. {
1334.    int index = 0;
1335.    int position = 0;
1337.       //  each integer has two characters stored in it backwards
1338.    for (index = firstIndex; index <= lastIndex; index++)
1339.    {
1340.          //  get high byte for 1st character
1341.       buf [position++] = (char) (diskdata [index] / 256);
1343.          //  get low byte for 2nd character
1344.       buf [position++] = (char) (diskdata [index] % 256);
1345.    }
1347.       //  end the string 
1348.    buf[position] = '/0';
1350.       //  cut off the trailing blanks
1351.    for (index = position - 1; index > 0 && isspace(buf [index]); index--)
1352.       buf [index] = '/0';
1354.    return buf;
1355. }
1359. long getHardDriveComputerID ()
1360. {
1361.    int done = FALSE;
1362.    // char string [1024];
1363.    __int64 id = 0;
1364.    OSVERSIONINFO version;
1366.    strcpy (HardDriveSerialNumber, "");
1368.    memset (&version, 0, sizeof (version));
1369.    version.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
1370.    GetVersionEx (&version);
1371.    if (version.dwPlatformId == VER_PLATFORM_WIN32_NT)
1372.     {
1373.           //  this works under WinNT4 or Win2K if you have admin rights
1374. #ifdef PRINTING_TO_CONSOLE_ALLOWED
1375.         printf ("/nTrying to read the drive IDs using physical access with admin rights/n");
1376. #endif
1377.         done = ReadPhysicalDriveInNTWithAdminRights ();
1379.             //  this should work in WinNT or Win2K if previous did not work
1380.             //  this is kind of a backdoor via the SCSI mini port driver into
1381.             //     the IDE drives
1382. #ifdef PRINTING_TO_CONSOLE_ALLOWED
1383.         printf ("/nTrying to read the drive IDs using the SCSI back door/n");
1384. #endif
1385.         // if ( ! done) 
1386.             done = ReadIdeDriveAsScsiDriveInNT ();
1388.           //  this works under WinNT4 or Win2K or WinXP if you have any rights
1389. #ifdef PRINTING_TO_CONSOLE_ALLOWED
1390.         printf ("/nTrying to read the drive IDs using physical access with zero rights/n");
1391. #endif
1392.         //if ( ! done)
1393.             done = ReadPhysicalDriveInNTWithZeroRights ();
1395.           //  this works under WinNT4 or Win2K or WinXP or Windows Server 2003 or Vista if you have any rights
1396. #ifdef PRINTING_TO_CONSOLE_ALLOWED
1397.         printf ("/nTrying to read the drive IDs using Smart/n");
1398. #endif
1399.         //if ( ! done)
1400.             done = ReadPhysicalDriveInNTUsingSmart ();
1401.    }
1402.    else
1403.    {
1404.          //  this works under Win9X and calls a VXD
1405.       int attempt = 0;
1407.          //  try this up to 10 times to get a hard drive serial number
1408.       for (attempt = 0;
1409.            attempt < 10 && ! done && 0 == HardDriveSerialNumber [0];
1410.            attempt++)
1411.          done = ReadDrivePortsInWin9X ();
1412.    }
1414.    if (HardDriveSerialNumber [0] > 0)
1415.    {
1416.       char *p = HardDriveSerialNumber;
1418.       WriteConstantString ("HardDriveSerialNumber", HardDriveSerialNumber);
1420.          //  ignore first 5 characters from western digital hard drives if
1421.          //  the first four characters are WD-W
1422.       if ( ! strncmp (HardDriveSerialNumber, "WD-W", 4)) 
1423.          p += 5;
1424.       for ( ; p && *p; p++)
1425.       {
1426.          if ('-' == *p) 
1427.             continue;
1428.          id *= 10;
1429.          switch (*p)
1430.          {
1431.             case '0': id += 0; break;
1432.             case '1': id += 1; break;
1433.             case '2': id += 2; break;
1434.             case '3': id += 3; break;
1435.             case '4': id += 4; break;
1436.             case '5': id += 5; break;
1437.             case '6': id += 6; break;
1438.             case '7': id += 7; break;
1439.             case '8': id += 8; break;
1440.             case '9': id += 9; break;
1441.             case 'a': case 'A': id += 10; break;
1442.             case 'b': case 'B': id += 11; break;
1443.             case 'c': case 'C': id += 12; break;
1444.             case 'd': case 'D': id += 13; break;
1445.             case 'e': case 'E': id += 14; break;
1446.             case 'f': case 'F': id += 15; break;
1447.             case 'g': case 'G': id += 16; break;
1448.             case 'h': case 'H': id += 17; break;
1449.             case 'i': case 'I': id += 18; break;
1450.             case 'j': case 'J': id += 19; break;
1451.             case 'k': case 'K': id += 20; break;
1452.             case 'l': case 'L': id += 21; break;
1453.             case 'm': case 'M': id += 22; break;
1454.             case 'n': case 'N': id += 23; break;
1455.             case 'o': case 'O': id += 24; break;
1456.             case 'p': case 'P': id += 25; break;
1457.             case 'q': case 'Q': id += 26; break;
1458.             case 'r': case 'R': id += 27; break;
1459.             case 's': case 'S': id += 28; break;
1460.             case 't': case 'T': id += 29; break;
1461.             case 'u': case 'U': id += 30; break;
1462.             case 'v': case 'V': id += 31; break;
1463.             case 'w': case 'W': id += 32; break;
1464.             case 'x': case 'X': id += 33; break;
1465.             case 'y': case 'Y': id += 34; break;
1466.             case 'z': case 'Z': id += 35; break;
1467.          }                            
1468.       }
1469.    }
1471.    id %= 100000000;
1472.    if (strstr (HardDriveModelNumber, "IBM-"))
1473.       id += 300000000;
1474.    else if (strstr (HardDriveModelNumber, "MAXTOR") ||
1475.             strstr (HardDriveModelNumber, "Maxtor"))
1476.       id += 400000000;
1477.    else if (strstr (HardDriveModelNumber, "WDC "))
1478.       id += 500000000;
1479.    else
1480.       id += 600000000;
1482. #ifdef PRINTING_TO_CONSOLE_ALLOWED
1484.    printf ("/nHard Drive Serial Number__________: %s/n", 
1485.            HardDriveSerialNumber);
1486.    printf ("/nHard Drive Model Number___________: %s/n", 
1487.            HardDriveModelNumber);
1488.    printf ("/nComputer ID_______________________: %I64d/n", id);
1490. #endif
1492.    return (long) id;
1493. }
1497. // GetMACAdapters.cpp : Defines the entry point for the console application.
1498. //
1499. // Author:  Khalid Shaikh [Shake@ShakeNet.com]
1500. // Date:    April 5th, 2002
1501. //
1502. // This program fetches the MAC address of the localhost by fetching the 
1503. // information through GetAdapatersInfo.  It does not rely on the NETBIOS
1504. // protocol and the ethernet adapter need not be connect to a network.
1505. //
1506. // Supported in Windows NT/2000/XP
1507. // Supported in Windows 95/98/Me
1508. //
1509. // Supports multiple NIC cards on a PC.
1511. #include <Iphlpapi.h>
1512. #include <Assert.h>
1513. #pragma comment(lib, "iphlpapi.lib")
1517. // Prints the MAC address stored in a 6 byte array to stdout
1518. static void PrintMACaddress(unsigned char MACData[])
1519. {
1521. #ifdef PRINTING_TO_CONSOLE_ALLOWED
1523.     printf("/nMAC Address: %02X-%02X-%02X-%02X-%02X-%02X/n", 
1524.         MACData[0], MACData[1], MACData[2], MACData[3], MACData[4], MACData[5]);
1526. #endif
1528.    char string [256];
1529.    sprintf (string, "%02X-%02X-%02X-%02X-%02X-%02X", MACData[0], MACData[1], 
1530.                MACData[2], MACData[3], MACData[4], MACData[5]);
1531.    WriteConstantString ("MACaddress", string);
1532. }
1536. // Fetches the MAC address and prints it
1537. DWORD GetMACaddress(void)
1538. {
1539.   DWORD MACaddress = 0;
1540.   IP_ADAPTER_INFO AdapterInfo[16];       // Allocate information
1541.                                          // for up to 16 NICs
1542.   DWORD dwBufLen = sizeof(AdapterInfo);  // Save memory size of buffer
1544.   DWORD dwStatus = GetAdaptersInfo(      // Call GetAdapterInfo
1545.             AdapterInfo,                 // [out] buffer to receive data
1546.             &dwBufLen);                  // [in] size of receive data buffer
1547.   assert(dwStatus == ERROR_SUCCESS);  // Verify return value is
1548.                                       // valid, no buffer overflow
1550.   PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo; // Contains pointer to
1551.                                                // current adapter info
1552.   do {
1553.     if (MACaddress == 0)
1554.         MACaddress = pAdapterInfo->Address [5] + pAdapterInfo->Address [4] * 256 + 
1555.                     pAdapterInfo->Address [3] * 256 * 256 + 
1556.                     pAdapterInfo->Address [2] * 256 * 256 * 256;
1557.     PrintMACaddress(pAdapterInfo->Address); // Print MAC address
1558.     pAdapterInfo = pAdapterInfo->Next;    // Progress through linked list
1559.   }
1560.   while(pAdapterInfo);                    // Terminate if last adapter
1561.   
1562.   return MACaddress;
1563. }
1567. static void dump_buffer (const char* title,
1568.             const unsigned char* buffer,
1569.             int len)
1570. {
1571.    int i = 0;
1572.    int j;
1574.    printf ("/n-- %s --/n", title);
1575.    if (len > 0)
1576.    {
1577.       printf ("%8.8s ", " ");
1578.       for (j = 0; j < 16; ++j)
1579.       {
1580.         printf (" %2X", j);
1581.       }
1582.       printf ("  ");
1583.       for (j = 0; j < 16; ++j)
1584.       {
1585.         printf ("%1X", j);
1586.       }
1587.       printf ("/n");
1588.    }
1589.    while (i < len)
1590.    {
1591.       printf("%08x ", i);
1592.       for (j = 0; j < 16; ++j)
1593.       {
1594.      if ((i + j) < len)
1595.         printf (" %02x", (int) buffer[i +j]);
1596.      else
1597.         printf ("   ");
1598.       }
1599.       printf ("  ");
1600.       for (j = 0; j < 16; ++j)
1601.       {
1602.      if ((i + j) < len)
1603.         printf ("%c", isprint (buffer[i + j]) ? buffer [i + j] : '.');
1604.      else
1605.         printf (" ");
1606.       }
1607.       printf ("/n");
1608.       i += 16;
1609.    }
1610.    printf ("-- DONE --/n");
1611. }
1615. int main (int argc, char * argv [])
1616. {
1617.    printf ("To get all details use /"diskid32 /d/"/n");
1619.    if (argc > 1 && strstr (argv [1], "/d"))
1620.       PRINT_DEBUG = true;
1621.    else
1622.       PRINT_DEBUG = false;
1623.       
1624.    long id = getHardDriveComputerID ();
1626.    GetMACaddress ();
1628.    return 0;
1629. }