C++获取CPU和硬盘系列号的源代码

天云上人

代码框架，你所要做的仅是修改WQL语句，具体可看MSDN。以下代码为简介起见，一次返回所有的CPUID或硬盘厂商系列号

1. 
   
2. #include "StdAfx.h"
   + ^* a8 }# K* t7 X8 f
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   $ \3 U) y  F* i% ^( Z1 P
5. #include <iostream>
   ! y' j) G- x' N8 M! U
6. using namespace std;
   
7. #include <comdef.h>
   0 j4 Y8 `6 h# C
8. #include <Wbemidl.h>
   
9. 
     ~1 d7 x& @2 \; y+ Y
10. # pragma comment(lib, "wbemuuid.lib")
    
11. CpuIDDisk::CpuIDDisk(void)
    / U/ R0 f: A/ a( E
12. {
    % f4 g' {9 ~) C1 R3 v5 h
13.     GetInfomation();
    / H/ P# J# x5 U/ ?1 i
14. }
    5 O, f& W% f& i% {
15. 
    - B$ _; u0 \$ Y4 S% n5 y, F
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    ' j7 b0 T3 Z" i
18. }
    " t0 w- M) a( j
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    , v6 _2 m- ~2 h' B5 q1 @: |
21.     HRESULT hres;
    : A, L& c# _% s$ j, S& H
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    9 V4 z7 @* p# T( c. o* {# p
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    
25.     {
    * }& Z. D8 y/ D% t7 M" x
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    - J5 {5 W  L- `* o( d) h
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    
32.         -1,                          // COM authentication
    3 g+ |  I6 N( Z/ g# `+ p1 M5 k: p
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    # R2 q% N% ]4 M4 H; `' h
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    & o  |" H4 W7 k8 H% ~1 [
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    7 f! }% m6 Z& \4 w! c
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    0 H% Y$ s, l0 W5 X% b
39.         NULL                         // Reserved
    
40.         );
    
41.                      
    9 U) i9 i0 L3 z) Y
42.     if (FAILED(hres))
    8 Z, c9 B! |" n8 C
43.     {
    ; ?( l+ S3 C5 @& _: K$ S
44.         CoUninitialize();
    , p( S/ k5 r" [3 a$ F
45.         return 1;                    // Program has failed.
    
46.     }
    7 h% |9 K  p7 w  [  w( I
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    # c  J4 I4 N# |" |
51.     hres = CoCreateInstance(
    " k. f+ u9 k: A0 t+ E
52.         CLSID_WbemLocator,            
    : a( k" m, _9 r0 F0 K" k, G$ x5 u
53.         0,
    & y, f. b# S! n/ A
54.         CLSCTX_INPROC_SERVER,
    
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    ) M& q; S' O7 T% B% L
56. 
    
57.     if (FAILED(hres))
    
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    9 Y$ K0 w6 x+ n9 ]7 X% l+ f
61.     }
    
62. 
    * g/ t  V4 N9 ~$ o4 H, I, A
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    * c! y5 r' G1 y. y
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    : e" x) \' r) u: q/ Y# p
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    5 J: W' \$ F$ u0 y- m- M/ \3 g, U
73.          &pSvc                    // pointer to IWbemServices proxy
    " L# J) r/ ]& g
74.          );
    
75.    
    
76.     if (FAILED(hres))
    
77.     {
    ( ?/ Z0 Q2 V5 S$ i4 H! G( H
78.         pLoc->Release();     
    7 r; H4 c5 C# A# ?# ]9 ^& i% U6 M
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    / `9 C% Z' R* Q# r. c  F. ?
81.     }
    , O" ]) b3 Y: T
82.     // 步骤5： Set security levels on the proxy
    ( `) \2 ?4 V2 E/ T
83.     hres = CoSetProxyBlanket(
    . V$ o& V, S: Y! o7 y( k9 a; g
84.        pSvc,                        // Indicates the proxy to set
    
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    : [! E: w, k% S
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    * ]2 U; o, ], c6 k: J) p
87.        NULL,                        // Server principal name
    
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    3 i1 |  Q! |2 G  \2 a2 a& x: E
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    / D$ t4 H/ Y- F. i2 O+ X
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    
93. 
    9 Z0 j0 F* b. ~
94.     if (FAILED(hres))
    
95.     {
    ; A4 S" k! W( X/ t9 B/ g' o/ j5 }% B
96.         pSvc->Release();
    
97.         pLoc->Release();     
    , @* R8 I4 B/ ~- I* s4 e; }; f; @0 S! H
98.         CoUninitialize();
    
99.         return 1;
    
100.     }
     
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     ! k1 Q' p% C' S; `  W6 {, o: m
103.     IEnumWbemClassObject* pEnumerator = NULL;
     5 k: Q  j3 X5 D2 o! j
104.     //计算CPUID
     2 Y* U5 h' l/ Y) I& t
105.     hres = pSvc->ExecQuery(
     & F7 Y# }) E3 e/ g& Z
106.         bstr_t("WQL"),
     - D" I7 H0 r) b9 y& j7 R# x2 \# t$ Z
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     
110.         &pEnumerator);
     
111.    
     
112.     if (FAILED(hres))
     
113.     {
     ' k/ U- y6 G' W# ^% S, P
114.         pSvc->Release();
     + l2 g$ V. y( a" \# B
115.         pLoc->Release();
     0 c& ?# S1 U' I$ e* ~' f5 R2 W! F
116.         CoUninitialize();
     % u9 G# b+ z) t6 W3 z1 d
117.         return 1;
     
118.     }
     9 c7 W1 R  g8 w9 e) K: Z4 q
119.     // 步骤7：Get the data from the query
     ; o/ L( d$ s4 S1 S  _! `1 q
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     
123.     {
     0 [6 h: u+ P* [: t/ ?
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     
128.         {
     ; z. }; T$ l8 S$ Y; T% J
129.             break;
     
130.         }
     5 N# T) m! Q; I: b- r# g9 ^! _
131.         VARIANT vtProp;
     ( g+ a8 R2 ^5 N
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     0 W# W4 h) _+ x. [
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     7 ~$ U# @, m+ m
136. 
     
137.     //计算硬盘系列号
     7 m$ _' O. m2 i+ Q
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     $ C3 u$ ]5 \! G$ b9 p1 V  c' Q. w
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     4 E; {) w& I& r5 q! Y8 Q; ~
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     1 B$ j& C5 M4 O9 L1 B; W
142.         NULL,
     
143.         &pEnumerator);
     
144. 
     5 T' r' q0 ]4 D
145.     if (FAILED(hres))
     
146.     {
     ! c) m; s6 W' C" m
147.         pSvc->Release();
     
148.         pLoc->Release();
     & m) N7 W; T  T$ o  H& o
149.         CoUninitialize();
     0 O% T! |& t3 }: `# l" F
150.         return 1;
     6 Z& V) F3 y5 ?0 C
151.     }
     
152.     while (pEnumerator)
     ) ?$ z, }& p& F* }
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     ' L8 C2 w  r+ F! \4 z
155.             &pclsObj, &uReturn);
     
156. 
     
157.         if(0 == uReturn)
     
158.         {
     
159.             break;
     7 T1 b; @5 a# J! u) u, j# `9 ]3 w3 X
160.         }
     
161. 
     
162.         VARIANT vtProp;
     5 |$ F$ N6 v& _+ M/ |2 w
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     
167. 
     
168.     pSvc->Release();
     - J8 h0 \0 g8 U/ w8 g0 d
169.     pLoc->Release();
     1 `& x) [1 L) z. |) B/ I5 @
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     ; w% M& n0 _/ b8 D/ c* y
172.     CoUninitialize();
     
173. 
     ; ?8 |" q% M4 y
174.     return 0;   
     ; ]% N! l% g, O( M5 y; q
175. }
     ; y! q% {' ?: E- V' f! R

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
; S0 v, d  R( L5 c# H/ _: Z
8 i5 t* U5 Y. H) q' g#include <WinIOCtl.h>
) K5 x' i" }" A2 n) T4 [& F9 g% ~#include <stdio.h>

#pragma inline
//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
9 d1 b/ R- \: o* ]+ K2 K3 A7 L0 `#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
. q5 q/ i9 K1 w8 g; x% f#define DFP_GET_VERSION         SMART_GET_VERSION
: ?1 t: @5 y# p. h4 S, n#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
9 b* O4 v8 f: `2 ^4 T#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
# L+ ?: ?2 {# f; V* o7 v1 ^
const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
; r, Q# D3 x6 \9 u  L. R2 U, R
const int MAX_IDE_DRIVES = 4;
/ J4 `/ d, n" i3 t( V0 l2 v6 W
// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
% a; b: t$ A2 H9 V9 o' ?7 lconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
+ m3 T1 `- X2 X( l! T) Jconst DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
" |$ G( R6 L  c- \7 fconst DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
; g5 H. r6 y$ k3 R
; ^7 O9 ^6 F- h$ Ptypedef struct _SRB_IO_CONTROL
; |* u. Y7 `1 D( J{
4 p  ?  m% ~$ V8 Y2 g    ULONG HeaderLength;
    UCHAR Signature[8];
    ULONG Timeout;
    ULONG ControlCode;
    ULONG ReturnCode;
& H( E: p  r. y* q3 g( }- x6 @    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
: B( [2 A/ N: u+ J4 {  [
! m; v5 ]. d' {. _// 读取的主函数
6 s# J& \& I0 X% F; H! R# T0 q2 f+ dvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
1 N. H4 G$ Z5 s, \3 w0 J
// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
  @7 b* W# D9 X) Kvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
" L8 \) T) `9 c# _! x7 D/ j        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
: h; m% Q  X& b& G- A. Q        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
  p5 K- |, Y  m1 e  bvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

' `2 P% W" t2 d// SCSI读取函数(for NT/2000/XP)
6 Z6 G) Q. {( ^$ c; R$ GString __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
' g, h( q2 t8 V! ovoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
    switch(Win32Platform)
    {
, y$ l+ U$ s  D* s/ d        case VER_PLATFORM_WIN32_WINDOWS:
            ReadPhysicalDriveOnW9X(pSerList, pModeList);
* A6 F- E; Q/ Y- E- F            break;
        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
* f; w! Z9 X0 ~, S, ?            break;
8 l7 _; e1 [9 x        default:
            break;
4 g- m8 v. I* _/ R( e    }
' F. h3 @! a; X- g: L1 w}
& W( L" H0 u% ]  A5 A//---------------------------------------------------------------------------
/ Q' v3 O0 \0 i9 C# c: i// ConvertToString
( B' K" s8 `+ `char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
    static char szResBuf[1024];
    int nIndex = 0;
    int nPosition = 0;
. y# m+ l0 f. K( T
  M1 T/ @: C% v3 W* G" g% c    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
+ U+ f9 b/ Q3 a# L    {
6 c. P, m  ?& J+ h) f        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;

        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
    }
: o1 t. y) T7 F% R4 g* ^, J
* q7 ]" o- q' d& w5 B+ s    // End the string
    szResBuf[nPosition] = '\0';

5 h) b5 q; V) U) R    // Cut off the trailing blanks
3 a' Q6 V' f; r9 C3 p8 L. n    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';
5 H( m+ x1 {! }4 s) h; |
! H7 `& ]' n4 [6 Q    return szResBuf;
1 ~% }( q  B- a: h& u8 i4 k}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
4 `4 \, J6 c  u$ o# R$ b( G# S// ReadPhysicalDriveOnNT
: d+ {/ o! x  z/ E7 T! f# u* N7 vvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
0 }! ~+ Y9 e. K- }6 f{
1 S. X4 a9 T1 ]4 p' M/ R3 D    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
; S+ t" Q6 _, i; r% ~; O
! I4 {! M- h% l    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
4 I6 k1 V$ `! v9 t    {
( D' E  C' E9 m0 W5 K+ q: A        HANDLE hPhysicalDriveIOCTL;
9 e' S% v) Y, E% F% F7 a( s0 w        char szDriveName[32];
- Q! X2 s1 W' I0 W
4 Z4 f7 P- r$ q$ m) W) g  n        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
) l+ Y2 G% r6 s# ^8 M  i+ n                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
# }5 G5 d/ X' U. d  r, [8 ^                        OPEN_EXISTING, 0, NULL);

        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
2 t$ q+ ?. B. Y  L  L2 L& t3 w        {
- s" c4 k7 w" a( Y            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;

            // Get the version, etc of PhysicalDrive IOCTL
: u( }+ R' i4 k: f7 t            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
+ K# J9 E+ L1 ^' j8 r                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
/ S. h1 y/ X3 P2 G4 f                    &dwBytesReturned, NULL))
3 j9 Y1 C, f) \) O1 _            {
% G3 @. d, @" R0 y, T& V                continue;
            }

            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
                // IDE or ATAPI IDENTIFY cmd
                BYTE btIDCmd = 0;
; X. T7 m. Z9 G6 g: E% {, @                SENDCMDINPARAMS InParams;
6 H$ V0 d. ~& l& S9 t4 J                // Now, get the ID sector for all IDE devices in the system.
. {8 m7 y% L  L' ^. {& q# ?# s                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
3 u' j: u1 C- w: w$ `4 l                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
. Z: t6 @8 U5 q! f+ d- q- P                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
- O8 C. D/ l. b% r: C                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
4 |* {1 A: E' C7 j- M
                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
! R! ?7 h* i0 P8 O" M4 a# T; l5 y                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
- `4 T- {# A  p( C                {
                    DWORD dwDiskData[256];
8 j6 T1 W: R% C+ x0 T                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
1 B* N4 Y- p9 `" k$ K                    char szSerialNumber[21];
* C0 ^4 c& X& M1 L6 k* m                    char szModelNumber[41];
3 z9 U/ h9 J' D- i9 B- X/ m# N
5 k. G/ G6 s) Q5 m  O; P' L                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
- g. W7 _0 L9 k5 k, n; B! I                    // 取系列号
5 ?4 i! L( n" ]% {( B                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
/ P! S2 N9 E" S                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
  F4 t9 _. M: W2 c: Q5 P
! h, P5 l2 f0 M; F& E% N5 ~( N                    // 取模型号
2 x  p# M+ [/ w8 E3 [# I5 a) M8 @                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
9 l0 l8 M' B. p; t. ]. U/ h% h                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
; X# J% r. |. ~' Y5 T" k/ g9 c' @
                    pSerList->Add(szSerialNumber);
+ ]5 K" P+ r% `* J/ m. a) p                    pModeList->Add(szModelNumber);
                }
- ^1 m( h5 O9 e0 I/ b1 s8 y0 P2 C            }
/ ]/ o5 m& ^0 _1 O            CloseHandle (hPhysicalDriveIOCTL);
0 v3 P. E* J3 s- t# o        }
    }
}
//---------------------------------------------------------------------------
// DoIdentify
4 j$ i* W# X; R* I. T, Ubool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
/ w1 L" e# n. j              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
{
" q* \* g" ]) ]" h* B5 J    // Set up data structures for IDENTIFY command.
8 t4 V" l7 I( P; l) }4 v# Y    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
5 G& B1 |9 z9 P! G    pSCIP->irDriveRegs.bFeaturesReg = 0;
+ S. y& K& _8 o    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
/ K9 o3 M# L" I    pSCIP->irDriveRegs.bCylLowReg  = 0;
3 P( {5 W' L! T$ |6 ^7 C  W& F    pSCIP->irDriveRegs.bCylHighReg = 0;
9 {3 M1 ]# P2 G/ d7 r! S7 J
  x, W5 |( F7 S* [* o    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
" M) T8 g3 @3 S! ?9 V/ J    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

. e6 {+ V' n; [! L$ u. q    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
1 K0 f9 E% v" B- P- B
    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
0 R: W" g& Y7 q2 P% F8 _2 ]/ q# _           (LPVOID)pSCOP,
* [4 q) l$ t. Z+ l. ]7 G           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
) U# ^# L8 O* ^# u7 `( U- g: a           pdwBytesReturned, NULL);
' a! U& I6 `- ~0 L! q# f}
: k( S: O* T2 J4 ^" o//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
7 [6 n" A4 E: Q// ReadPhysicalDriveOnW9X
" `% Q; X  i: F& F0 V' q8 Lvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
8 K2 K* _3 F% N    WORD wOutData[256];
/ a$ E& ~% y% p) o    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
: `6 Z6 k8 U3 O
    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
6 z  z1 Y* ^5 s5 H    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
' @& E% u8 o- O- g2 I& H4 i4 h' D    // 避免蓝屏的出现。（期待高人能指出原因）
4 U; Q- `  _; G! J    for(int nDrive = 0; nDrive < 8; nDrive++)
& b& \9 p6 ?& t% C1 \0 _7 i    {
        WORD dwBaseAddress;
+ G$ t* V) R" f( @, N+ |        BYTE btMasterSlave;         // Master Or Slave
" K) t" c8 J( _3 O, w        bool bIsIDEExist;
% S+ i- l3 c0 y2 Z0 [: ], F        bool IsDiskExist;

5 r6 G* d! S+ n( m) _  U1 v        switch(nDrive / 2)
# u& w4 \: c3 u3 S        {
            case 0: dwBaseAddress = 0x01F0; break;
0 o% x; p# L7 T8 [            case 1: dwBaseAddress = 0x0170; break;
1 I. i2 s( t2 T1 m# z3 E            case 2: dwBaseAddress = 0x01E8; break;
( q/ ]' E) c4 `7 p- G            case 3: dwBaseAddress = 0x0168; break;
9 G1 Z$ X+ K5 Y5 I0 W& r6 M& O: I        }
- ]: e+ z) N: ^- Y0 |
$ O3 t: j/ A  `: e2 t. M        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

% B, T2 a( z2 a: Z; r        // 进入Ring0
* z" V& x$ U. }  R5 g. a+ H        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
    }

- j9 I9 [$ b7 L! q6 f# B! S) f    // 开始读取
  _6 C7 i5 z/ A/ m- C0 f6 ~% B    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
) x  J5 z$ C0 t& m% Z        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
5 o: E+ H9 i5 z- F, \& T  R6 g        bool bIsDiskExist;
$ F6 P7 O1 k6 M* M        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
! u$ X) I  j4 L1 b5 X2 r            case 1: dwBaseAddress = 0x0170; break;
3 {% `( f: s* M. ?$ y: }4 t            case 2: dwBaseAddress = 0x01E8; break;
- l5 N6 r8 o3 x            case 3: dwBaseAddress = 0x0168; break;
        }
2 }# a2 E9 Z. J: J5 D
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
& z% ?% P' h7 Y' v+ D
- z- ]7 Z# M! K+ ^        // 进入Ring0
7 c" A: L: C& e3 T* |        bIsIDEExist  = false;
4 r) P$ J$ V! O( U/ X7 b' E* O( r' _        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));
( j- m3 g/ @( {* X* K. u
2 w6 I4 j* J  b        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
% j$ B6 M  j+ g9 q3 w: ^                bIsIDEExist, bIsDiskExist, wOutData);
" `4 F6 z- D; G) p5 K! _* m
        if(bIsIDEExist && bIsDiskExist)
/ y9 u7 t; r9 ]$ Y# i        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
            char  szModelNumber[41];

            for(int k=0; k < 256; k++)
7 _6 ^# T* I0 \% E2 [% K, A                dwDiskData[k] = wOutData[k];
. U9 W2 ?9 `. z7 E# P
            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
! D. \& O, u3 ]: Q& u/ G! F            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
! g* r( K0 R. J
            // 取模型号
5 Z3 C5 K: B: U) H4 E( V3 u            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
" v5 S( }# o( r8 X+ u: F6 W
            pSerList->Add(szSerialNumber);
2 o5 h1 Q# d( E: `5 _2 k. E# ~            pModeList->Add(szModelNumber);
3 u8 ~% ~; G; d& M% o1 Z        }
: O1 h# J6 I6 ^& C1 Q+ a+ P9 w# K    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
. @( r5 @/ l* J/ s8 e}
% I8 X# C% \8 W. ]2 j# f# V* b4 q//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
/ G( P5 B0 H2 b//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
8 q' B, A+ ]' q8 f9 e  G// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
1 I9 i- V% ]% \! C6 P//---------------------------------------------------------------------------
( I: S* X; z( p5 evoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
+ c' I, G$ \: O" r( q; L: a' K{
    BYTE  btIDTR1[6];
+ b8 A1 L/ |% J. G' I    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;

3 P6 G/ @& S( u# {0 y9 T  F. {: i    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];
# I8 g$ g/ L& T- U4 f8 `
    BYTE  btIsFirst = (BYTE)bIsFirst;
7 i; C9 n1 h9 _# r# g& s
# a7 _' u9 G  H, {) P% ~1 A; G2 S    const BYTE btBit00 = 0x01;
5 h  _& ~( n+ {5 X5 P- u    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
% N8 H  T4 Z) |    // const BYTE btERR  = btBit00;
5 u$ \6 @) J' F) V" X) I* @% F    const BYTE btBusy = btBit07;
4 X' J# O8 K/ F9 T) T' d' I    const BYTE btAtaCmd   = 0xEC;
( s, q* M  D, q. H    const BYTE btAtapiCmd = 0xA1;

    __asm
8 j  N" u& V3 n! s5 J    {
        // 必须先执行这条语句
: m' v! ?3 Q( U8 n2 l8 n; ~9 h        JMP EnterRing0
7 K- v: A' Z) O8 l- M8 m! s( E
" f7 p( z% F  L: _8 t, R( S* \) ^        // 定义过程
" E, I- k6 R! o! N9 j        // 等待IDE设备直到其不为忙为止
5 }$ v  w% y) w, c  t: G        WaitWhileBusy proc
- N0 h/ S7 z- A) a; o
9 A( X7 j& a3 X' a- s; ?        MOV  EBX, 100000
  b, N+ t% _( c  G        MOV  DX, dwBaseAddress
5 B" W' b5 P2 L8 p6 l+ L9 b        ADD  DX, 7

        LoopWhileBusy:

) g, J" P# @7 Z7 B+ I        DEC  EBX
( @  Y" P; k# F5 v        CMP  EBX, 0
        JZ   Timeout
  ]6 z4 t* N, x5 _( A        in   AL, DX
2 q$ i- b# v8 V% p/ A/ R        TEST AL, btBusy
        JNZ  LoopWhileBusy
        JMP  DriveReady
1 Q8 {9 m  b8 n, X: S
        // 超时，直接退出
        Timeout:
- O- j& q7 a1 v        JMP  LeaveRing0
/ G" f7 D. i, B+ y. z( K        DriveReady:
        RET
# b2 J9 Y" g( }) A# G8 Z/ V" W        ENDP   // End of WaitWhileBusy Procedure
; }  T: f$ i' a7 c4 i" J* d9 q$ I
        // 设置主盘和从盘标志
        SelectDevice proc
3 l' k$ ]/ G* j8 }
5 v8 r% f1 X/ f        MOV  DX, dwBaseAddress
# q1 ]) |$ j- p% g8 _        ADD  DX, 6
        MOV  AL, btMasterSlave

        out  DX, AL
        RET
4 V8 X9 g% {  r/ U! X  b' N
3 E" `- z  M! ^3 A8 p: o        ENDP  // End of SelectDevice Procedure

7 Y! j0 A4 ?' [! F! x" g+ p        // 向IDE设备发送存取指令
        SendCmd proc

1 h2 y+ E; Q$ ~, y# T        MOV DX, dwBaseAddress
        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
+ P- B  Q& c1 A. x        out DX, AL
        RET
        ENDP  // End of SendCmd Procedure

        // Ring0代码
        Ring0Proc:
- {4 D9 l0 d0 B# h: N! L$ z2 v        PUSHAD
        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
9 n, Q0 ^. R& A& A        ADD DX, 7
        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
& A  ~& Z7 w0 h8 d) r/ e        CMP AL,0xFF
        JZ  LeaveRing0
        CMP AL, 0x7F
2 V2 v9 C- |( ~        JZ  LeaveRing0

        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1
( ?/ o/ O- b& r& \$ q
: D6 o+ Y' a6 z; Z" k$ O9 g8 t1 ]        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
% C, N! L+ [' M3 S4 O        CALL WaitWhileBusy
" y3 o/ ?# U, y: H        CALL SelectDevice
+ l5 Q- I6 i' j) j
        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
2 J& F0 ]4 E+ A" A        CMP  btIsFirst, 1
        JZ   LeaveRing0
4 v; w4 Z# n% G; e3 M2 K
* Y6 Y0 n4 O& r, s8 r        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
  O" l& J- M# W        CALL WaitWhileBusy

% F& c1 B& \; ]5 U& m  f' n        // AL的值等于cBit06时，不存在驱动器，直接返回
! `( F5 G  H. P8 r8 ~        TEST AL, btBit06
        JZ   LeaveRing0
  @9 P, L. y$ |# _* ~% G# A
" U+ |0 t9 A9 W- }; e; l) Q        // 设置驱动器存在标志
$ _( E9 O: A' K* r! A3 j        MOV  btIsDiskExist, 1

: z8 I4 B* v5 \5 G2 y        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
( U. P2 {' P* d0 t. `2 @7 M, n        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
9 y8 z( b7 g* @* Q5 a        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
, J* p! N6 O5 [$ @4 A; [        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
        CALL WaitWhileBusy
" t/ \: M( ~& H& x' E+ t
        // 检查是否出错
7 ?. ^- }+ g. ], U" y) Y        MOV  DX, dwBaseAddress
        ADD  DX, 7

5 }' U4 t# N8 R2 N) n. Y/ }* [' @        in   AL, DX
* E% a) l. {! N3 I  S3 {" N# v" E
        TEST AL, btBit00
3 u# A5 o( _/ p2 k/ c: Z) `        JZ   RetrieveInfo   // 没有错误时则读数据

1 N! H$ G; z. X* a" `* g, ~+ s        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
& R9 r, `" G' {/ M2 l9 i        CALL SelectDevice
        MOV  BL, btAtapiCmd
) r" K; ]* t! `5 t4 v        CALL SendCmd
        CALL WaitWhileBusy

        // 检查是否还出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
        in   AL, DX
# w7 s5 L- \1 b; u9 Q+ W        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回
3 Q# f6 L5 t. r& p
" d, X0 F% x- u  {5 X9 |8 H0 ~) j6 K        // 读取数据
        RetrieveInfo:
# {4 Y; e: i2 A# Q- t
        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
        MOV  DX, dwBaseAddress
) c$ F9 k; M/ i+ B% M        CLD

        REP  INSW
4 |/ I& p- U9 Q9 q  |& O
        // 退出Ring0代码
" f+ Y1 v4 }% z( ]' ^9 Y        LeaveRing0:
' {! c) ~. b& K" x
# f5 X" q" O1 t# _; X0 I2 P$ }$ U        POPAD
' l9 t/ e/ c6 f4 E/ P) W! }        IRETD
: R. c+ E- C/ K+ L( W
+ B& o; V/ o' D& E4 L: l2 `        // 激活Ring0代码
. I6 U( O: ]4 X" s        EnterRing0:

( [8 I6 K* n+ V8 D        // 修改中断门
* _# d: {8 \/ ]4 c( c+ Y' M$ P. T' I, a        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
/ o0 [& u% h- ^        CLI

        // 保存原异常处理例程入口
5 d" W- x: w# J: Z        MOV ECX, DWORD PTR [EAX]
; @9 ?5 h5 e& F0 g* A* I( o        MOV CX, WORD PTR [EAX-04h]
3 c! Q) ~7 J4 S, T        MOV dwOldExceptionHook, ECX
; |8 L9 L. Z) f& l8 G5 s
. u" _" ^2 G( m- Y  T* P        // 指定新入口
8 F) y: N6 k. r4 ]: r: D) q        LEA EBX, Ring0Proc
9 ?% z% E3 R: K+ U, ]- W" j. t% x' ]        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
3 U( I! I5 X5 Y6 V& S/ n& Y        MOV WORD PTR[EAX+02h], BX

& d6 i* Q8 D, `( U" M- ]' i        // 激活Ring0代码
' j. E- g3 i% _2 \: K3 r' y! @        INT nHookExceptionNo
# x3 ]( u. S+ |) |3 w, C
        // 复原入口
, X; X4 C" L% B/ w7 X6 K+ ~        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
2 }, O" C2 N5 J; o( h% d$ l        SHR ECX,10h
! ~, a: Z/ u/ h. u6 r$ c& v2 t        MOV WORD PTR[EAX+02h], CX
        STI
/ j8 }) q7 R5 t1 A2 e/ o. {    }
    if(!bIsFirst)
    {
        bIsIDEExist  = (bool)btIsIDEExist;
- _, n* j- G& {; }        bIsDiskExist = (bool)btIsDiskExist;
" ~+ H+ C9 T9 q* r) b7 l        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
}
3 C8 H% W0 \1 t2 {//---------------------------------------------------------------------------
// 调用方法：
1 n. h" W+ v( zvoid __fastcall TForm1::Button1Click(TObject *Sender)
{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}