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

天云上人

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

1. 
   
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   0 a+ f# {) n$ A. f8 f+ L
4. #define _WIN32_DCOM
   * h& X0 ]6 p5 o1 D& y
5. #include <iostream>
   0 m- G9 b- C5 l0 l5 x5 f4 c, L: i2 u: x2 |
6. using namespace std;
   " n6 i" o8 e0 j( E
7. #include <comdef.h>
   4 g+ j/ D8 b. N* W" a3 F1 W
8. #include <Wbemidl.h>
   3 W, o' E7 X+ `  g6 o. v
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    5 H) N* u) v. d
11. CpuIDDisk::CpuIDDisk(void)
    / h0 z! K# o6 P1 t5 H
12. {
    
13.     GetInfomation();
    . ]+ e) M% N# F8 B' n( U) ^
14. }
    7 i. k( t/ O9 w! z
15. 
    0 T! `, ~, [' v) H- p: K
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
      L2 E- e4 Z+ z
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    * T! {2 c& B. ~
20. {
    
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    + Q, M. `5 @7 \
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    7 A9 h  B& h" x. X
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    ; T, Q* H' q% _# _# ~
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    ) C$ E0 v. ?$ }/ r5 y2 I
31.         NULL,
    
32.         -1,                          // COM authentication
    4 |* p+ M- P% X; A0 R  f6 t3 L8 Z6 Y
33.         NULL,                        // Authentication services
    ! G! w2 P7 e" m! Q
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    7 B' R5 k8 J+ a) [& s
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    # @+ C6 d4 c! x. |  P0 M7 J9 H4 w
37.         NULL,                        // Authentication info
    7 W0 y3 N3 D3 H$ K
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    
40.         );
    ; Q: C8 ~& T3 l5 t. W7 v
41.                      
    0 v7 V7 |+ P6 l& n/ ]: z
42.     if (FAILED(hres))
    ; ^& [2 y6 [, Y) L% X- @
43.     {
    
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    * @- w. U3 o* C4 L+ p  B) K
46.     }
    7 I  ]6 {) e, r6 W2 p
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    1 s- I$ _5 G5 N) f& [- M
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    ( V0 c$ U% A" \+ o* @6 o3 C
52.         CLSID_WbemLocator,            
    
53.         0,
    " y0 S. U8 g% B% G, G( ^
54.         CLSCTX_INPROC_SERVER,
    
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    
57.     if (FAILED(hres))
    / B0 Y( S6 @. Y3 y" f# x" f6 M
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    . s$ C: L3 }" l
61.     }
    
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    ' B. t, K8 x( T8 E
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    ! N) k8 g  E5 @4 `" Z
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    * }; T: N) [* z
71.          0,                       // Authority (e.g. Kerberos)
    6 k3 Q+ Z, n! Z' M' ]. L- ~$ F
72.          0,                       // Context object
    " O6 N& Y9 _' A. @1 W8 m
73.          &pSvc                    // pointer to IWbemServices proxy
    % T) c) a- i8 f$ u; e) M& w: O, |
74.          );
    ! p& N. N: g" P0 a9 H6 E% c1 t
75.    
    8 j! V: J) L5 e$ [
76.     if (FAILED(hres))
    
77.     {
    
78.         pLoc->Release();     
    1 E; o/ X4 w5 D8 x# [
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    
81.     }
    + [9 j. x, Q4 T$ M
82.     // 步骤5： Set security levels on the proxy
    2 H" }/ ]% I9 G% ?' O# S4 \, w
83.     hres = CoSetProxyBlanket(
    8 N( _4 I; [2 i( a5 `
84.        pSvc,                        // Indicates the proxy to set
    
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    $ ?- B' X% _. Y9 h3 s" B
87.        NULL,                        // Server principal name
    
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    7 m( r6 g5 Y7 n6 u& Q# g4 {
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    
90.        NULL,                        // client identity
    . I5 M9 q, ~; J# h$ r
91.        EOAC_NONE                    // proxy capabilities
    + r9 |" B9 C" }2 W/ j
92.     );
    # h5 @5 l! z/ E9 X9 I; S' D
93. 
    9 }( j" W7 i- a9 b# v+ Z
94.     if (FAILED(hres))
    
95.     {
    
96.         pSvc->Release();
    
97.         pLoc->Release();     
    , |8 `( @) q$ ?( t
98.         CoUninitialize();
    
99.         return 1;
    
100.     }
     # ?1 [0 {# ^1 V
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     8 {& R9 W; a0 D  y& u; B( b
103.     IEnumWbemClassObject* pEnumerator = NULL;
     7 X. a, x1 N9 N8 A( I. T
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     - O" Z! X5 I; c: k$ m+ N* Z" a
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     & |4 @- d# w% L4 m) w" M& i! J* |
109.         NULL,
     8 s( c& d7 B2 T/ o% y
110.         &pEnumerator);
     * i+ O* G* W. H9 d) k
111.    
     $ A# k+ H7 M3 K: E* @  v
112.     if (FAILED(hres))
     + J9 @) n$ O5 f' e0 d3 v
113.     {
     # B7 A% M6 c+ L  h$ W8 {
114.         pSvc->Release();
     
115.         pLoc->Release();
     
116.         CoUninitialize();
     
117.         return 1;
     
118.     }
     
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     ; x3 U0 x( ?! A7 v! V
121.     ULONG uReturn = 0;
     9 s* ^- ^5 [% i7 S0 H7 K
122.     while (pEnumerator)
     
123.     {
     5 y9 {4 |* w% C- Y* t
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     2 m3 ^  \6 P/ y  t9 S
126. 
     
127.         if(0 == uReturn)
     : U5 b3 e/ V6 x1 b
128.         {
     0 M- q( u$ {, v* s
129.             break;
     3 |* h' C4 c  B/ I4 D9 u! R& b1 [+ E
130.         }
     9 H  Z! X6 l6 y( t3 ^/ D) `1 g5 M
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     $ V4 b: q0 y) c. O
136. 
     
137.     //计算硬盘系列号
     / g% E. |9 i5 O+ Z8 z& N2 _
138.     hres = pSvc->ExecQuery(
     4 L; z3 r; j/ d% a& u2 u  u% Q
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     5 U" k: p& M! ?( a4 k
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     ; Y- ?/ I- g! z% x# s7 |
143.         &pEnumerator);
     
144. 
     6 m! c5 R; p* V, [. o; E
145.     if (FAILED(hres))
     # Q+ V. ~( D: X' S0 w) `" I% L
146.     {
     
147.         pSvc->Release();
     
148.         pLoc->Release();
     
149.         CoUninitialize();
     
150.         return 1;
     ' x5 l: {% E) b3 F
151.     }
     - G9 c# `7 b& u" @+ O9 f$ a
152.     while (pEnumerator)
     0 B& s/ t8 [# J% n9 G7 h5 `
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     : E& w# G/ @9 }. f7 W
156. 
     
157.         if(0 == uReturn)
     
158.         {
     
159.             break;
       A6 S/ c) O/ Z- m
160.         }
     
161. 
     + _* r4 S& t! b
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     ! z( I! G& [1 B9 L! h7 b' U0 R
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     * U9 Q, l0 v7 K* j: @
166.     }
     
167. 
     ; ]) c* g, E9 d8 h$ g1 Z7 }7 W5 f# g4 n
168.     pSvc->Release();
     
169.     pLoc->Release();
     9 `" u( f$ p  A' r* g
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     - I* u7 K. Y, c2 ]/ t: Y0 _
172.     CoUninitialize();
     5 n& S) I3 a% t2 N1 j, k6 x' ~# E
173. 
     
174.     return 0;   
     5 I6 g! [4 O& f6 t( O% W* \& S: E2 C
175. }
     

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
2 M% j, y. x. E& @/ J
#include <WinIOCtl.h>
7 [: T; r& m* K#include <stdio.h>

#pragma inline
//---------------------------------------------------------------------------
( {' u3 h) O4 D, q8 h" z/ w// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
, Y  @' O" y' I% d  U) I#define DFP_GET_VERSION         SMART_GET_VERSION
% J9 y6 x. m1 n7 W- }1 ]  D9 {#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
  ?; N. j, N; p/ ?#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

: @0 q7 F: _/ A; @- M$ [% C$ N( {1 iconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
; U- O0 R+ k- m2 |3 Q  E0 O( Z" i6 oconst WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

const int MAX_IDE_DRIVES = 4;

8 q$ {: m' D; ~6 R# x5 N9 a$ c* @// SCSI专用变量
( T- b' h7 m1 m. y% x7 d- [1 pconst DWORD FILE_DEVICE_SCSI             = 0x0000001B;
9 `4 q) G. B' v; w. Z% bconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
! B( [9 J+ z* @/ m8 y& v
  h3 H$ `/ u# i5 n6 G5 otypedef struct _SRB_IO_CONTROL
: [7 B: r3 N- P8 |. R{
    ULONG HeaderLength;
. `7 t0 g& O: q' h    UCHAR Signature[8];
    ULONG Timeout;
    ULONG ControlCode;
    ULONG ReturnCode;
, d! V2 e! ]6 S, Q9 k* F    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

( X) f6 Q& O* y) [# a$ |// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

" }7 `7 ]  X& ?! J! g7 c// 辅助函数
8 A. o+ m* D1 d, h4 l1 K. O0 uchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
, f' ]4 {7 m8 C/ i* Lbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
/ E# L7 ^" g9 }; j0 z7 A7 [+ j  h- ^* J        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
9 K' Q' l8 k1 V8 W, K7 A, q: @        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
! _' ?1 b! q: x4 M$ D4 N
# A. s) s  e8 m2 }# E! [: O, \/ G// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
2 u" I9 o" ?- q! r// ReadPhysicalDrive
5 n4 B9 o# h  H) fvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
    switch(Win32Platform)
    {
$ g+ U1 u, H3 q5 r% @' Q) A3 d        case VER_PLATFORM_WIN32_WINDOWS:
1 {9 W3 K: n0 \            ReadPhysicalDriveOnW9X(pSerList, pModeList);
4 v8 O# J. f5 P" R- `: X' Z5 J            break;
        case VER_PLATFORM_WIN32_NT:
2 V* X7 Y# X' i; m8 Z/ d; V$ ~            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
; Z, t' Z0 B( N& S% @- ^        default:
: H2 g; h9 j3 Y( U            break;
, O( f) \) j) Y6 }7 I" k% W, n    }
}
//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
7 z# h4 k, W3 g{
    static char szResBuf[1024];
    int nIndex = 0;
/ X, Q' D4 a( u# U) w9 F: N/ ~    int nPosition = 0;
6 h: X: r) Y/ e, P$ l% I
    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
* f8 C& C2 F" B    {
4 m" K. [9 A/ H  |        // Get high BYTE for 1st character
9 e  Z. G9 C: Y( N3 T8 S# u) t        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;

        // Get low BYTE for 2nd character
) O' a9 O6 X7 }8 S3 L" \        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
5 q( O/ e( j( P, r* o7 l4 Y. ^4 \        nPosition++;
    }
" [- o3 T, f* z5 T. w* S' B
    // End the string
    szResBuf[nPosition] = '\0';

    // Cut off the trailing blanks
8 f$ G% n6 R9 G+ P5 S7 m    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';
2 z, p7 }! d( R- {
9 O/ b3 {% D2 }1 q: Z/ s    return szResBuf;
}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
8 e# f/ K0 c/ ~8 y, d1 P* p! D//---------------------------------------------------------------------------
2 [& }: z2 D# u  }, {+ x& A, v3 T3 M// ReadPhysicalDriveOnNT
8 m: h0 [7 y! }5 @* {+ Xvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
' a) `. b2 t$ U& s{
    // 输出参数
- P  Q7 @/ h% t8 L    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
6 ~: S, G2 m  _! I/ c( P1 ?' B3 k
) C% L( h" A2 j$ f, f: A9 l2 p3 R    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];

        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
4 t) Y8 j4 L. d0 {& p$ L. J        hPhysicalDriveIOCTL = CreateFile(szDriveName,
) {7 J% |/ b* |7 z  G* ?+ C                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
) [. A& G1 g0 x' l4 D/ ]                        OPEN_EXISTING, 0, NULL);
* h' L$ Z- G4 g0 q
        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
2 X% v, n# F! f        {
            DWORD dwBytesReturned = 0;
9 T7 `4 l% l" s! X            GETVERSIONOUTPARAMS gvopVersionParams;

( ^( }* ~# j+ ~) w            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
7 x  J+ M* G# K5 |8 i) a9 x
            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
+ E$ u' F% Y9 j0 J9 P                    &dwBytesReturned, NULL))
" j0 L9 |0 O' A3 g: R            {
                continue;
; P& T: K: p6 Q" Q& D  j& f+ [            }
- |+ ?7 s  m6 z! W4 L: A
" g1 N5 x" L* O; N* y5 |5 u            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
                // IDE or ATAPI IDENTIFY cmd
# A4 z9 R* D3 @4 a4 }5 a                BYTE btIDCmd = 0;
9 R2 P: ?) E, }! a                SENDCMDINPARAMS InParams;
" ?+ T( o, V7 x) g+ F                // 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
                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
6 G# f9 G! {5 O4 H% o+ Y                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
, }* W: y; ^4 w7 E4 k% D% q( v                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
) Z7 a: p6 S+ E1 f
                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
* @: t5 n/ h8 j: `5 Y4 A                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
0 L( ]2 m; S% ?# M1 [1 F, C  J. _                {
                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
7 f! |) V7 v3 T: d& w' `                    char szSerialNumber[21];
3 W( n, y; @! e7 \1 ~5 B# m                    char szModelNumber[41];
& l$ q+ T) }' _
3 g+ \2 Y0 Z! _* P& ?4 [: m                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
  S9 I  F0 o0 V5 B, f                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
$ u2 F( o7 l; [# U7 m, V; G                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
- d% I0 ~. P3 e7 R: C
                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
                }
            }
" y# W% e2 C5 N6 x# o% ], X            CloseHandle (hPhysicalDriveIOCTL);
        }
    }
}
! o9 e( A( s) b- Z+ n- w0 ?3 [2 a, ]//---------------------------------------------------------------------------
, g9 P0 \# U" t+ F, ~( X1 V// DoIdentify
+ v' y7 r, v# K! O) ?bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
' k( b" _4 g/ f1 r5 P              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
{
    // Set up data structures for IDENTIFY command.
' }( U* z/ i: p2 r+ M    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
- c: B$ D5 G0 f( y6 m    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
+ G, L- ?8 _' h' q; `    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
6 ]  t2 t9 D3 b  d
0 g9 ?9 i0 J' m3 L" H) E    // The command can either be IDE identify or ATAPI identify.
% M" T0 `6 k# |( v) R' g1 `4 j    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
; M# @4 Q# [! |4 D    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
* ^. Q8 J& ^3 E/ o7 W; ~4 {           (LPVOID)pSCIP,
2 b: _1 [+ a9 \. l- n: H4 B, \2 H           sizeof(SENDCMDINPARAMS) - 1,
: o* L5 h7 K: l% y, H           (LPVOID)pSCOP,
6 w' \$ _- `/ D6 s: j; b           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
+ v! ~4 w( x, B. [4 M: Y}
  W9 {# a- o7 K9 T8 O8 @//---------------------------------------------------------------------------
' R/ z; M; Q/ B( O// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
# p( X& D- P4 u1 \7 X, n6 r8 V// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
; Z8 ?2 ?  E+ G8 \{
# d9 ~& l, d2 _0 f    WORD wOutData[256];
    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
! ]& X' k7 P0 }9 a& o
    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
- a% N6 M: u# E. o5 Q8 b    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
& E  D1 q) e) A: @. @    // 避免蓝屏的出现。（期待高人能指出原因）
& p1 y- Q: ~5 [) Z& d    for(int nDrive = 0; nDrive < 8; nDrive++)
) o/ Y% c8 X! i0 r    {
( F5 c5 V: \- o- q: L; d1 r2 r        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
: A, `, Q% N$ E2 o$ y2 n        bool bIsIDEExist;
) C( G/ w& r% [) Y8 G6 Y        bool IsDiskExist;

- c$ o7 |& D0 o3 t        switch(nDrive / 2)
/ r! w1 D- [: R+ p* o        {
            case 0: dwBaseAddress = 0x01F0; break;
4 ~0 N6 O2 S% y* d, |( ]            case 1: dwBaseAddress = 0x0170; break;
) b6 w# U  C/ z            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }

        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
    }
9 n9 h- r0 {% T
' b* k! a% p  t! {  g' j+ U5 r    // 开始读取
( p! l$ w* x; ]8 d9 G: Q    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
3 b" U7 y+ {$ f! D$ U; W2 G        bool bIsIDEExist;
        bool bIsDiskExist;
8 D1 \( _2 m& ?) d* b        switch(nDrive / 2)
        {
: I# ?: H2 c9 t            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
0 E* P+ |" S+ c. u            case 3: dwBaseAddress = 0x0168; break;
        }

        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
4 t; I8 K! N; R, s6 ]
7 `, E" D6 ]% z/ g$ L% [5 G        // 进入Ring0
# P  y4 m7 C, V2 ^( m        bIsIDEExist  = false;
4 D6 y6 \( p, B( ~8 G        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));

5 w7 r1 e# Q3 f3 k$ F        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

        if(bIsIDEExist && bIsDiskExist)
        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
            char  szModelNumber[41];

            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];

1 p& @) b& W; \* I, \0 g8 S            // 取系列号
+ K7 D/ K8 w) p: M& ~            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
- b5 V& v4 f; m5 R4 {) O            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

9 Y- a0 H% f/ p  @/ c            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
; l, Q' S0 T9 s0 X2 D. P            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
9 l; O8 @+ A5 C  R
            pSerList->Add(szSerialNumber);
3 E3 F5 F* \9 y) C9 z, L0 A# Y3 S& ]- b            pModeList->Add(szModelNumber);
        }
    }
; C( w0 T& c/ d    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
3 A+ O$ j$ _& Y* `, S9 X}
4 C6 |6 v$ k0 `6 p9 Q' \% x//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
) L. L/ b9 v- V9 n// btMasterSlave = Master(0xA0) Or Slave(0xB0)
- [, u& ~, o. v7 M3 K4 ?  h//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
* a2 N0 R) u' \  c* y' _    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;
& Q, Y! u6 Y: U7 j% ]; z/ d
, p4 I  \. d9 c4 W  x    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];

7 B- P6 k% F2 m' P/ W    BYTE  btIsFirst = (BYTE)bIsFirst;

$ ?# S1 Y2 {2 a! o) H! ?& Y    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
: P$ C; K8 [/ j' b2 M( q    // const BYTE btERR  = btBit00;
    const BYTE btBusy = btBit07;
1 [9 X, P1 Q5 [, f    const BYTE btAtaCmd   = 0xEC;
$ w. {% F8 I# Q; J/ r    const BYTE btAtapiCmd = 0xA1;

    __asm
/ y9 Y: g; `2 W' i    {
& S9 J3 G! O$ b, t7 Y9 |& i        // 必须先执行这条语句
        JMP EnterRing0
. W3 u% K: u% D0 C4 V
        // 定义过程
& s% k+ M  R4 I- Z( D# F2 w+ i/ I        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc

3 G* B  v: r9 s; p" ?        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
+ S! `" }- H& C7 g$ h        ADD  DX, 7

7 [, K; A& M" L. M! `: X        LoopWhileBusy:
9 W/ h) C5 Q+ l6 Z. w
        DEC  EBX
        CMP  EBX, 0
5 Y+ q% r& F, N: c        JZ   Timeout
9 T& U8 i0 X# ?  C        in   AL, DX
        TEST AL, btBusy
3 u8 x$ |3 M4 Y$ ]4 B: }0 x: y        JNZ  LoopWhileBusy
  ~, `0 l7 |/ y+ P( ?  _# K* `        JMP  DriveReady
2 s# N1 t! X- b
; {" K4 P/ @, r. {2 \        // 超时，直接退出
% _5 r3 B9 `; a& \7 n1 i        Timeout:
        JMP  LeaveRing0
1 N2 B% Z% P+ C        DriveReady:
        RET
        ENDP   // End of WaitWhileBusy Procedure

$ v" O6 V" @5 J2 U* h        // 设置主盘和从盘标志
        SelectDevice proc

        MOV  DX, dwBaseAddress
        ADD  DX, 6
# Y7 c! ]  w% O) J3 @        MOV  AL, btMasterSlave

        out  DX, AL
        RET

        ENDP  // End of SelectDevice Procedure
* c4 u3 [, B* \
8 {7 N' _$ Y3 n8 ]- E( g8 k& Y        // 向IDE设备发送存取指令
        SendCmd proc
+ T# J( g7 a- ~! H6 _4 o
5 t+ v& }' i' B% Q( i) [        MOV DX, dwBaseAddress
; m5 l3 ^/ \+ f$ O        ADD DX, 7
7 C+ d, ^7 p! w2 C2 p6 R        MOV AL, BL // BL是主从盘标识，在过程外设置
" H9 N+ @8 k* I: t! w        out DX, AL
, H3 V) C* K" e6 m        RET
        ENDP  // End of SendCmd Procedure
( u9 t& s9 E( {) s$ k+ v
0 }5 K& r* e9 ~6 ^" {4 R        // Ring0代码
        Ring0Proc:
, V, g( |9 b$ E8 u5 [        PUSHAD
, y8 T2 a0 @! l! i/ g  L- R        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
2 F1 t" T$ N0 P1 O9 R! Z        ADD DX, 7
        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
        JZ  LeaveRing0
  R* W7 y; ^* s  V/ k/ r9 f        CMP AL, 0x7F
        JZ  LeaveRing0

* m/ X/ M: \( k, f) @9 e: Y. W* e6 i  c        // 设置IDE设备存在标志
3 C, O) P2 g( o2 t, K- e4 i        MOV btIsIDEExist, 1

        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
8 l" ^; ^5 F) l$ A        CALL WaitWhileBusy
        CALL SelectDevice
- ~  z6 t5 _+ ?( a8 d) V9 F
7 K4 N$ b+ ^8 B4 b: u, x/ k. q        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
        JZ   LeaveRing0

) l; l' S* U4 x! p6 s        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy
6 {$ g. ^+ X# x/ u. K+ }
9 P/ ~3 ~2 E& p        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
0 {. K' N) n5 d" ]8 [& {4 I        JZ   LeaveRing0

        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1
8 I& k' k1 E  x/ c( S6 A+ i
        // 发送存取端口命令
, s: |" |* ^, |% g5 N% A; X& l7 P. t        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
' @1 F7 W' i  ?. ~' |  Z        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
+ Z6 M2 ^( p; K        CALL WaitWhileBusy
  P7 }" P* t7 n9 l9 E6 B; x$ H! E        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
6 X, |# P; M. m# [; |        CALL SendCmd
3 H, l/ K5 `! M& M        CALL WaitWhileBusy

( i8 |, D' O0 h8 n9 v% p        // 检查是否出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
  X: j7 S0 h) P0 q' u
        in   AL, DX

        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
) y, B1 M' n2 q2 M1 r        CALL SelectDevice
5 n( g! @# _& A7 `6 G        MOV  BL, btAtapiCmd
/ R( e/ k4 _: T7 x/ z        CALL SendCmd
        CALL WaitWhileBusy
& ~; {' D; q6 X. w
        // 检查是否还出错
8 f7 I' a' H: A* e        MOV  DX, dwBaseAddress
1 k1 a. W; q# j8 B+ @- j$ P$ I& N        ADD  DX, 7
        in   AL, DX
        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
, ^5 D6 @5 L9 q# `. s8 W  ^+ i        JMP  LeaveRing0     // 如果还是出错，直接返回

        // 读取数据
: V3 W$ j+ E: u4 I        RetrieveInfo:
; t0 J" X; Y3 f/ g1 V9 Y9 b
        LEA  EDI, wOutDataBuf
( R( T* J: p% n3 o7 L( @* J        MOV  ECX, 256
        MOV  DX, dwBaseAddress
        CLD

        REP  INSW

        // 退出Ring0代码
' \7 k* T! W/ F5 L# a+ r        LeaveRing0:

        POPAD
        IRETD

. ]0 H" w9 k* \/ ~& V* Z; }        // 激活Ring0代码
        EnterRing0:
; C# g' ^' U5 f/ J9 p( |1 N
        // 修改中断门
        SIDT FWORD PTR btIDTR1
. T: ~2 N1 C  L$ p7 Y( _        MOV EAX, DWORD PTR btIDTR1 + 02h
7 y( y( s3 H1 O# I8 I        ADD EAX, nHookExceptionNo * 08h + 04h
( M. j& Y6 h. N8 m  d        CLI
4 i/ p  k# p0 N5 r7 s
        // 保存原异常处理例程入口
" T# y1 p: g) k! c+ Z        MOV ECX, DWORD PTR [EAX]
1 H" _' Q) X( D4 K        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX

0 `5 }7 ?' `( ?8 N4 t3 a        // 指定新入口
- c2 s; \/ T1 Z1 b( k# O* P        LEA EBX, Ring0Proc
& s' }# m9 A, d" q  l  U5 c1 K        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX
4 o: I5 h2 k( Z/ C7 q& @
        // 激活Ring0代码
        INT nHookExceptionNo
/ _6 A/ }3 b% {( A, G5 k* _" Z7 W2 V
        // 复原入口
        MOV ECX,dwOldExceptionHook
1 o, U1 W8 K: }% z- j+ C& r        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
4 C9 F. c8 t) }9 R        MOV WORD PTR[EAX+02h], CX
        STI
    }
    if(!bIsFirst)
( X0 o/ l2 |9 S4 O1 e3 g* K& {9 b    {
        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
0 F! n% n9 l; |* M    }
}
//---------------------------------------------------------------------------
// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
{
; x* K6 r! U* z8 n1 M4 r    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}