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

天云上人

代码框架，你所要做的仅是修改WQL语句，具体可看MSDN。以下代码为简介起见，一次返回所有的CPUID或硬盘厂商系列号
% Q" q) n+ G- \1 \. C7 ]/ h

1. 
   9 B( f  c+ @* o
2. #include "StdAfx.h"
     L4 n# `8 `  ?! K) S  a, [
3. #include ".\puiddisk.h"
   9 B: n2 f( |- R; k
4. #define _WIN32_DCOM
   8 [, H! n6 J" F' ?8 U
5. #include <iostream>
   
6. using namespace std;
   
7. #include <comdef.h>
   
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    * x+ U, e8 }/ F% j& O* A
11. CpuIDDisk::CpuIDDisk(void)
    4 n/ w6 G7 A  x0 C$ r( K! L5 ]
12. {
    
13.     GetInfomation();
    2 |7 N  S$ w# P6 ~% i
14. }
    
15. 
    ! g+ O. U7 m3 [" d  O$ k
16. CpuIDDisk::~CpuIDDisk(void)
    9 q# d" ~% q5 T! Z" K1 X; o
17. {
    5 c) A1 f1 }5 N1 Z
18. }
    & Z( e% }* y$ K3 l7 S/ j
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    % }$ |/ Q4 P( V6 C* O, l. V/ e5 E
21.     HRESULT hres;
    & u5 k# P0 ^$ ?* A
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    0 I$ Z) v% q  E1 r3 {1 l
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    / t& _: p& A! H' Q, b3 z
24.     if (FAILED(hres))
    
25.     {
    9 j/ C7 r( [, p* u' s
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    ' Y5 R9 ~% }' m; v, ~" n7 U$ Q9 |
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    * E! D# u6 O( p& O+ O
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    : i* k! l# G! C5 d/ w. b" Y5 l$ \
31.         NULL,
    
32.         -1,                          // COM authentication
    ' M6 I' K& I2 s( Q+ J; B
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    5 n6 [/ ?* |& @$ S
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    ; K0 {- p. f5 X( T1 v
38.         EOAC_NONE,                   // Additional capabilities
    # L; ?2 m: ~5 x& A
39.         NULL                         // Reserved
    2 b" X4 S4 Z/ |. q. {; S' P
40.         );
    ' W( B. S5 a- G; ~! _/ Z' B
41.                      
    - w, W% }# H" ?. C4 X1 ^
42.     if (FAILED(hres))
    $ |" x; T2 w7 C* v5 o! S. e+ P$ d, l
43.     {
    
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    4 r. \" k9 }& B7 D5 c5 |8 M
46.     }
    
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    + u, _0 l2 U' w6 S) e
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    1 I8 H( v# ?3 A& b! w- y5 x0 l
51.     hres = CoCreateInstance(
    2 G5 \# Y0 \- S
52.         CLSID_WbemLocator,            
    . Q  |8 z4 K( S! I1 l/ B% X7 \+ ^
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    8 |# ]% o1 o/ p7 D2 H" ]
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    
57.     if (FAILED(hres))
    ' f9 w* i5 u- m7 H! N3 e
58.     {
    ; H* o0 }; H8 j, y0 ]' H; [
59.         CoUninitialize();
    " \' G( Y% a9 X
60.         return 1;//Failed to create IWbemLocator object
    $ v5 U  N3 @% e$ v: G7 S% P
61.     }
    7 \) s8 d! i) z  {2 \5 t3 G; B
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    - n5 E: J+ p& X  S4 t2 B0 s
64.     IWbemServices *pSvc = NULL;
      U3 b% I: X3 H
65.     hres = pLoc->ConnectServer(
      [6 T  _# m: K  d# f
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    . n' q# l4 e6 [6 D' c
71.          0,                       // Authority (e.g. Kerberos)
    1 H8 k$ `/ i. g5 ^5 P. ?8 R
72.          0,                       // Context object
    " F4 h8 D0 B: N8 T7 A( {9 U8 t  H
73.          &pSvc                    // pointer to IWbemServices proxy
    8 I5 g' A. o; L' ?) ^1 c9 E
74.          );
    
75.    
    
76.     if (FAILED(hres))
    
77.     {
    
78.         pLoc->Release();     
    
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    : O! C2 P" e4 d3 N  M
81.     }
    / W$ |" }6 m1 N; E6 N
82.     // 步骤5： Set security levels on the proxy
    5 D( W+ Y' Y. C" X
83.     hres = CoSetProxyBlanket(
    
84.        pSvc,                        // Indicates the proxy to set
    
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    ; l. u( k; A7 O4 @$ Q  H
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    # S. }7 r% {6 n6 i. o. @
87.        NULL,                        // Server principal name
    5 }/ K! z1 l3 m/ Z2 s
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    2 m; S3 z& z: @) O$ A+ X6 W
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
      H3 K6 m- d) Q0 a( C* ~( T8 P. _
90.        NULL,                        // client identity
    ' @2 M# {# ?$ P- S2 W8 N$ }
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    0 `, r: t: D* t: ^' }: O( M
93. 
    ! ?8 p. Z% x; e, G6 S( F3 j
94.     if (FAILED(hres))
    ) G( P" T+ S$ X0 D! u
95.     {
      M' x& q8 `" C' ?
96.         pSvc->Release();
    
97.         pLoc->Release();     
    
98.         CoUninitialize();
    
99.         return 1;
    
100.     }
     
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     ; o8 G. T3 G; f$ D3 e
103.     IEnumWbemClassObject* pEnumerator = NULL;
     9 r/ t) a, r* Z9 R; c/ Q2 `4 i
104.     //计算CPUID
     7 x4 [/ b# t2 Q9 `
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     9 X' R" I0 h- @4 M
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     $ {8 z' ?% S5 f9 D  M" h6 I
109.         NULL,
     ! F8 n% ^! H, c- }+ N  ]
110.         &pEnumerator);
     : f# b+ H& T: e6 J0 w! x
111.    
     
112.     if (FAILED(hres))
     . [  Z$ Z/ j) L( G9 ~) x( k
113.     {
     
114.         pSvc->Release();
     5 K# N& o7 G  F  B# U
115.         pLoc->Release();
     
116.         CoUninitialize();
     9 v. m9 J" }) p+ P) Z
117.         return 1;
     $ e( H* a% A. j8 y. b
118.     }
     ! v$ u$ J! h5 H1 `% F2 ]
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     4 D- F, l% K3 g1 _8 h' F2 Q' q
121.     ULONG uReturn = 0;
     ) j- F0 F: W+ w4 H; }
122.     while (pEnumerator)
     & G! L, n1 a: ~  v# J- j. U7 V
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     ; b1 f3 V) Y! @  n8 d
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     
128.         {
     
129.             break;
     , v  X$ [, k, S& J( R
130.         }
     
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     7 [6 i$ B9 j( d) k! b
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     , h! }! [& z. d) |. o/ x
135.     }
     
136. 
     7 g! ^* u1 D' _' T+ r
137.     //计算硬盘系列号
     
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     $ w. E5 {$ j1 T' A: P) T2 x* Z( n
143.         &pEnumerator);
     3 e, c! [  b" @1 c/ G1 d
144. 
     
145.     if (FAILED(hres))
     
146.     {
     
147.         pSvc->Release();
     7 ~- L- C7 O! H1 X! b9 ?6 d% B% J
148.         pLoc->Release();
     
149.         CoUninitialize();
     
150.         return 1;
     8 h/ |" `; r+ _/ {3 {, Z* |
151.     }
     
152.     while (pEnumerator)
     , U# a8 z  [' a; _; S( s
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     / Z& p7 D# }# D
156. 
     : l% u( \2 ~" f, O
157.         if(0 == uReturn)
     
158.         {
     " m" @% `3 _; s$ ?/ K
159.             break;
     7 l& ~! z) N5 l8 R' A7 \, G7 L
160.         }
     
161. 
     , O& c- r. C7 A( D; W- k) w
162.         VARIANT vtProp;
     * {% v5 d6 k9 u% d# M" e3 t" Z) t
163.         VariantInit(&vtProp);
     ; v0 C: W, F6 D& ]
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     6 ^4 m9 F$ s. N% |! e3 z
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     1 @) z0 K& D0 ~, _, ^
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     6 Q/ L$ ^. `' |7 S/ I
171.     pclsObj->Release();
     . q1 `1 J* @, J
172.     CoUninitialize();
     + R0 R# ]4 u) m9 w: g  N. w7 M
173. 
     
174.     return 0;   
     - u8 [/ v7 |/ ~, i! e( F0 n
175. }
     " p( x8 o6 q9 m* A% r" h

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
: E# ?' T6 c! Z* X0 p" O; P. L# U% T
8 l) ^6 N! `( [2 z/ k4 v#include <WinIOCtl.h>
3 t5 x$ g/ A( H#include <stdio.h>
5 L- C! X) z0 I$ K- k4 h) [
#pragma inline
//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
2 ?" e( n. P* y, Y; T. \" b#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
' i5 i+ G. i  R( l8 A2 t  e
const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

const int MAX_IDE_DRIVES = 4;
5 H* V/ }, U5 [; G" c8 i* d. }! J
// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
# X- J( w7 g9 M5 k* ]: Y! \const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
* L% F6 ?0 I. X2 m- k2 S' k
typedef struct _SRB_IO_CONTROL
{
    ULONG HeaderLength;
    UCHAR Signature[8];
    ULONG Timeout;
    ULONG ControlCode;
    ULONG ReturnCode;
    ULONG Length;
  c' W4 z0 e% G: k8 ]; m" f& g}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
7 q. g3 l% M6 M
8 K8 Q! c5 [* v* W* t" q, ?// 辅助函数
- a* J5 F% o8 b0 Nchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
/ H0 N0 e+ l( H! B- A! L9 Q1 [// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
" U6 H: E. |- p7 J9 G0 V" j- [5 n        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
; W6 ~) k5 \& s5 y        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
' `7 p+ f# q+ A  ovoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
8 o1 i1 {+ _4 V0 b, i( T7 K) tvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
, [& r! _1 N) O+ v        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
, L* _" a8 Q% z: V' C
// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
; b) D- d  O, C4 F: U3 y# W8 ?( h, L// ReadPhysicalDrive
: m$ Y$ E. E! Y% nvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
) b# T4 ~9 _' k* F, y& U" ^{
& ?- B% L! E6 ]0 B- [7 _' l2 i. ]    switch(Win32Platform)
    {
        case VER_PLATFORM_WIN32_WINDOWS:
6 }" P' r- g  N2 v            ReadPhysicalDriveOnW9X(pSerList, pModeList);
9 G+ ]' p9 q) S$ ~/ S5 u            break;
; b" M' Q+ q0 G        case VER_PLATFORM_WIN32_NT:
: r* ]6 o& T: u7 O/ l& ?( l            ReadPhysicalDriveOnNT(pSerList, pModeList);
- U. }- c- M2 j$ F& B            break;
        default:
            break;
    }
}
//---------------------------------------------------------------------------
// ConvertToString
) ]' ~+ a$ D0 A: n9 m! Ichar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
# C7 r% T5 Q; E/ E/ P    static char szResBuf[1024];
    int nIndex = 0;
    int nPosition = 0;

4 n/ |8 u2 `( U+ ^3 [6 W( L    // Each integer has two characters stored in it backwards
6 F! |5 n8 f9 z3 K0 e    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
& h- h6 W) a' t" [5 e    {
  S( s# H! O/ e& J4 Q/ |' _! [        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
1 F- t# y' i2 Z( U/ m2 f        nPosition++;
/ ^% J* B1 u( U9 F
        // Get low BYTE for 2nd character
; ~' l4 X* q) Z$ Z4 D; j: V2 m! n        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
& K  f( G  q- @2 E, D& R        nPosition++;
    }
$ V8 u* O' O, t( Z- H
' ?. c) {7 k' F, f* w6 N    // End the string
* j& R; m; ^4 k7 i    szResBuf[nPosition] = '\0';
+ ]4 S% W- y5 {- z3 O& E4 D
) ^3 Y) @  G( O+ u+ \4 ^/ h    // Cut off the trailing blanks
    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
4 P4 R( \5 _! i8 \. U/ D        szResBuf[nIndex] = '\0';

    return szResBuf;
$ d4 a* L& `7 T}
//---------------------------------------------------------------------------
7 c2 ~2 Z2 a' B  w3 |4 D) s// Winndows NT4/2000/XP 代码
. x* D! j- }1 _0 P# B6 b' V//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
0 q& A5 {2 D$ t' R! @9 a{
6 b9 m1 C& n; L  a; ^    // 输出参数
; f2 F7 _7 e' l+ M: I9 ?# ?  {    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
- x! s. J+ X. W: B7 ]  U3 f
5 j/ f' f+ W, d. j! ?6 U2 K7 X6 d    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
/ ]3 i# C' C. O/ |        char szDriveName[32];
* ]# K4 E6 e. v7 t8 z
7 i2 E. N& F) c% I7 A1 a/ S        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
, c. f) x& [. G- z        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);

# o) T6 Y  u6 \8 c- }3 G        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
/ H* z7 a' c& m" x        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;

            // Get the version, etc of PhysicalDrive IOCTL
% e' W  s3 ^% a9 `, w; e2 U            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
- c( ?9 p  L: `  d$ G                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
            {
- o& V8 J, P$ T; k- P% ]7 X: C                continue;
            }
; w0 h- c) H, L. C" j
            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
                // IDE or ATAPI IDENTIFY cmd
) d6 ?8 q& ]7 `# t: w3 j  M                BYTE btIDCmd = 0;
% n6 l( P5 l6 r2 y/ H& D5 C2 n                SENDCMDINPARAMS InParams;
( \$ H: l% g- [. I  |& Z                // Now, get the ID sector for all IDE devices in the system.
+ V# C5 u8 m3 m; O                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
/ Z8 n6 G- B5 u/ N                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
, A' {3 B) `* H' V                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
4 C/ T# {" ?$ E# c, {                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
) h; y6 }! @0 ]/ Z3 s
; q0 [( K& `+ j; S& ]                if(DoIdentify(hPhysicalDriveIOCTL,
( q0 A3 F  T0 P1 a                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
2 \3 X3 c6 k# N  x                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
1 R1 k+ s5 i- U% x& h                {
                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                    char szSerialNumber[21];
2 n. I: d# `# v: U                    char szModelNumber[41];
7 O/ j/ i& Q! m) b2 W9 f  ]0 j9 q& Q
" c$ H6 Z7 |# ^5 x' G; c                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
! j( c0 ?: L3 @. U                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
' P) G  M( n5 P* ?                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

1 A1 k6 U4 w! ?9 q) |- K                    pSerList->Add(szSerialNumber);
" N6 ~( n, ?! ^% V( A                    pModeList->Add(szModelNumber);
                }
            }
            CloseHandle (hPhysicalDriveIOCTL);
        }
9 _, {+ i: Q, |    }
}
9 q% T) i& v& |# [* ?+ d' s//---------------------------------------------------------------------------
// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
# J! V- p+ q' W. C# |  P              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
  r5 {: d+ {$ j( j9 r              PDWORD pdwBytesReturned)
{
+ f! ~' w. t+ g0 b1 z    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
0 [1 N9 Q$ g7 |# a9 F8 I    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
, n1 N* N3 K5 K+ {; e, U    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

$ d( t0 {& P+ q: f6 G    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

7 e7 h4 ~2 w6 O( u$ h+ R  {    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
2 Y/ j- U5 o, _' w0 W    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
* a+ }+ h$ Q/ B" R  M
4 c3 y/ n! B& z2 @2 c: c    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
1 k  E' s: H& m+ `1 g2 R5 p/ N}
$ i, s' D, T) _9 g) ?//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
& ?2 g- ?6 |$ j9 W+ M5 Svoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
6 \2 x3 f8 E( r$ q    WORD wOutData[256];
* @, y' p; e- \; m7 }5 ]    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
/ B& L) g8 K) f, ^9 z+ {" F4 q
    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
, \9 ]2 S  X3 \7 t* t' h8 ]    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
$ j( H- L* v% b. L3 j" w0 }        bool IsDiskExist;

7 N, r, V$ P7 D+ _) \4 T        switch(nDrive / 2)
2 Z& J4 s& e3 I& L        {
            case 0: dwBaseAddress = 0x01F0; break;
$ S! l2 U8 Y. _. I8 t5 E# |" z            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
- S* x% g  V  ]1 D/ b* D: ?            case 3: dwBaseAddress = 0x0168; break;
        }

6 |1 V+ g3 g( ~  l6 w1 R        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
4 E' h: O+ P* l) x1 j% @/ l
        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
, [7 O( A9 G5 n1 M/ V                bIsIDEExist, IsDiskExist, wOutData);
    }

8 H. r' R9 W" |/ B    // 开始读取
    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
- D5 L# K, K6 V        bool bIsIDEExist;
3 x2 W& w. ^  k; F        bool bIsDiskExist;
% ?2 h- d7 n# m4 ^& z2 k& y        switch(nDrive / 2)
, n. \8 _4 O% X' F: P( b        {
  i& O. f5 n0 B" V& p) T% j& D            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
6 m4 Q! A/ j  d            case 2: dwBaseAddress = 0x01E8; break;
$ U3 F# I/ k) [# o, R            case 3: dwBaseAddress = 0x0168; break;
        }

0 s- q7 i! H! _; H& @* [6 v- l        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
" m# l( {% m, q0 H0 {* Y; T
0 e* q* ~2 N7 O: T0 D% X; O, \        // 进入Ring0
3 Y* A( n% v  A+ Y. K        bIsIDEExist  = false;
        bIsDiskExist = false;
7 ?, c6 T/ ^& j        ZeroMemory(wOutData, sizeof(wOutData));

        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

        if(bIsIDEExist && bIsDiskExist)
3 S( m4 |7 a% f' d        {
6 b* O1 I) J7 t% }7 j3 l8 v* H            DWORD dwDiskData[256];
; e0 p9 }2 ]3 Y/ X            char  szSerialNumber[21];
' D; W$ m" F4 g8 y( s+ }  @7 @            char  szModelNumber[41];

$ l* E2 W! {: b  C& k, |            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];
4 c; D: e) ~/ z4 m+ W
! M1 s0 ^: l0 F* a! r. J2 B            // 取系列号
3 b) D( n' I* d+ @, c            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
5 d$ w% g. a; f/ k+ B. o4 L' [6 W- ]            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

  m3 d% t  b$ [! j! m            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
' k9 s1 l& N+ S& t0 A( Y
7 ]  L7 d- I/ R8 S% u5 M6 [            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
        }
5 x0 f: G' ]- M7 f. S$ X% R, x! i    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
3 b1 e1 g  q* D2 M" `* ~; N* \- H}
//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
" d/ M+ X. Q# m+ Q4 J& l// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
# d3 m( ^! j6 g$ I4 P//---------------------------------------------------------------------------
. t3 ^9 d8 V' X9 ~3 zvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
' d1 e8 u, T, M! T2 ]8 D) ?* a        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
$ u, l# X5 k/ G8 p1 A5 s{
$ X$ l+ {& j. h! i: b% a7 u2 v    BYTE  btIDTR1[6];
; I+ V% y' J- D$ Z    DWORD dwOldExceptionHook;
+ p' B9 d5 e2 u5 x1 l$ f) q: j4 r    const int nHookExceptionNo = 5;
5 E" F" G! Q7 b
    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];
  Y/ F4 q1 b& R/ ^
    BYTE  btIsFirst = (BYTE)bIsFirst;
5 i, D1 g9 W+ G
" U6 d2 J5 [' w% F3 k9 z4 W8 s    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
# }7 ^5 [0 g+ G% |    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
1 V7 i( s/ b1 N; D    const BYTE btBusy = btBit07;
& l# ?: \6 _' z& g    const BYTE btAtaCmd   = 0xEC;
+ i5 |7 N! c0 G    const BYTE btAtapiCmd = 0xA1;
2 x* e$ [. T9 k; T0 K: O0 p# k' U  H
    __asm
/ ^5 K" R- f* o+ h7 e; _- h    {
6 F9 U+ a) [* s" u# f+ ?5 Y( A        // 必须先执行这条语句
& j+ k5 [& U' g        JMP EnterRing0
1 E, J) X! M, N9 @' W
! |; I" z5 ~2 T) Z9 h+ b4 L9 X% ^        // 定义过程
4 W0 G* T: D1 _0 ~6 h: i( x+ Y        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc
" h# B) a4 \9 \$ x2 F! R: o/ X
        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
& M% O: ]! _3 J- }1 h        ADD  DX, 7
4 P; `/ p; o* ^( I+ W* a( L& a
4 K% e3 R& E; K1 n4 `        LoopWhileBusy:

        DEC  EBX
/ s1 E. q: k1 u( P/ E        CMP  EBX, 0
        JZ   Timeout
        in   AL, DX
5 X: K+ A# f# r! ~& X7 M7 _8 Y        TEST AL, btBusy
        JNZ  LoopWhileBusy
$ C2 q* H5 N( h        JMP  DriveReady
5 k$ q0 K) \: K0 p. `
        // 超时，直接退出
7 y/ ^9 g& \: k! d' K) G7 J6 _        Timeout:
        JMP  LeaveRing0
+ T, N. y1 ]; C- n        DriveReady:
        RET
        ENDP   // End of WaitWhileBusy Procedure

        // 设置主盘和从盘标志
        SelectDevice proc
) X0 Z8 e) e. c! r. y. s
) I& Z0 N8 k! `7 Z        MOV  DX, dwBaseAddress
1 N0 e$ U4 l9 U        ADD  DX, 6
' m8 w2 _7 @! t$ Q) J0 K        MOV  AL, btMasterSlave

8 B1 q7 u2 c- x" x' n( q+ a3 y        out  DX, AL
        RET
5 K9 P2 c3 |8 b* b- E2 [! C3 R
        ENDP  // End of SelectDevice Procedure
$ @2 `+ x3 Q: Z) v, C' V( Z- R
8 a: L9 N6 |  i3 j9 T. u" K        // 向IDE设备发送存取指令
; `# q& E+ U  |& j) P0 U        SendCmd proc

        MOV DX, dwBaseAddress
4 N! S$ [% z; k9 y! P8 e        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
" z5 u/ |* T8 |% x        out DX, AL
' _! w) T/ k; m  h        RET
* J8 ^7 l- X' G! i        ENDP  // End of SendCmd Procedure
) |0 Y  ~: V% v* s2 q
5 I& i$ h. I% I) U3 T; B& g        // Ring0代码
        Ring0Proc:
5 }; C* O& U4 i$ b        PUSHAD
        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
' t: W1 }& B: k5 b7 E        ADD DX, 7
        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
        JZ  LeaveRing0
. ]* B7 @! I/ x( u1 G5 \7 ]        CMP AL, 0x7F
        JZ  LeaveRing0

        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1

' G* W+ D; S1 c, L3 E9 _        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
6 H  Y+ ]5 p2 y* T6 `) p        CALL WaitWhileBusy
( C' @* Y3 [, {; l+ r        CALL SelectDevice

* e; h. J3 y3 g4 _# h! V; v        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
" O: N4 L' j# C  ^! o1 e4 I        CMP  btIsFirst, 1
/ i, m( y4 |% i" a- Z" O        JZ   LeaveRing0

        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy

        // AL的值等于cBit06时，不存在驱动器，直接返回
" Q4 q. S+ _4 o) p' `" G        TEST AL, btBit06
- \+ L! Z1 d/ _% L' Z        JZ   LeaveRing0

7 O- G6 f! d. t' t        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1
  X4 U$ {' [5 a  C8 @! f
        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
: z- h7 H8 `- p% a' l  M% J        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
2 ^8 O1 y# i' s: R9 J+ |2 G, X        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
+ G/ i! b+ G! k* C' v        CALL SendCmd
0 m. ]  i' M  j2 ]/ C. o        CALL WaitWhileBusy

        // 检查是否出错
( ~/ F  W1 W0 v" j$ `        MOV  DX, dwBaseAddress
- z& c; f& L- z) i        ADD  DX, 7
2 u  N# Z. ?- Y7 I. R* w. E" E* x
        in   AL, DX

        TEST AL, btBit00
; F% y( H3 q1 g: e$ ^        JZ   RetrieveInfo   // 没有错误时则读数据
  t: x. F7 S" n2 I
0 K5 w" e1 u  p9 d        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
# j0 h! F- ]/ ~& }; O, B7 j        CALL SelectDevice
7 h) e1 }' z; `  L        MOV  BL, btAtapiCmd
2 x+ ]) K- R- @$ T" A        CALL SendCmd
        CALL WaitWhileBusy
  S5 @2 H) L/ F- w  J) T
( h  g- `4 b) C6 z0 J9 E        // 检查是否还出错
/ n% O4 @/ |+ n$ M  T* K' Q9 p1 E        MOV  DX, dwBaseAddress
4 O" s% h; ^/ @; ^        ADD  DX, 7
        in   AL, DX
0 J) X$ n! B: z3 U3 d4 u9 O        TEST AL, btBit00
% h6 A. z: o7 `2 M- B* R* @        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回

  `! X8 h- T. K: }. D9 Q* }0 N; R        // 读取数据
7 \$ _; U9 N7 U        RetrieveInfo:
+ W( f2 g  K  P2 u* L6 f* M
; d: F- V: {6 \2 S& l  d4 f8 J        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
6 V# }7 C! W& d4 n: \) e4 Q% z        MOV  DX, dwBaseAddress
$ b0 |: a. @8 S9 h9 F; c- b) W        CLD

& V0 n, k. [5 B* }" h        REP  INSW

        // 退出Ring0代码
        LeaveRing0:
! o7 C3 J8 o7 T9 X8 d$ Q8 j
        POPAD
        IRETD
( H* E2 v. n7 W7 s7 V: k
        // 激活Ring0代码
( n- U" \; U- S$ D9 b' m$ Z        EnterRing0:

        // 修改中断门
+ ?* d* g! O6 ~' g% U* X8 p        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
5 p# ~0 y$ k# T% y! q8 t        ADD EAX, nHookExceptionNo * 08h + 04h
* j2 O; m- a3 K% D4 E* Q        CLI
: Y6 T0 I7 J8 l0 ?  d* r$ L( |
        // 保存原异常处理例程入口
2 E. R2 D  }2 n" t: e! P/ `# |& K4 Q        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX
9 G+ ~1 X7 L$ F7 y; s3 R
+ F" n1 D0 u: ^" U2 Z2 r        // 指定新入口
        LEA EBX, Ring0Proc
( k% l% J  F! K( d        MOV WORD PTR [EAX-04h],BX
9 l; {# [4 B- l& N9 j        SHR EBX, 10h
6 l) N, c8 C% }        MOV WORD PTR[EAX+02h], BX

        // 激活Ring0代码
        INT nHookExceptionNo
9 `! ?/ C9 T# e' [* U
, u0 p! s: @6 ^        // 复原入口
$ ?1 B# p- I3 F+ S9 p        MOV ECX,dwOldExceptionHook
( a6 O4 M$ l( F5 j2 I        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
        STI
    }
/ H3 o7 u- f1 h- T7 U    if(!bIsFirst)
- T  t8 v: \' K. k    {
        bIsIDEExist  = (bool)btIsIDEExist;
6 Z7 V. T, I) L6 q        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
9 \  m! r5 h' K" X( [/ Y, c    }
}
//---------------------------------------------------------------------------
) F! e  W" x4 W& ~+ U' S# l// 调用方法：
* E3 Q6 ]: G6 g+ ]; Jvoid __fastcall TForm1::Button1Click(TObject *Sender)
{
5 [. j* `, m" X' o+ W8 ]) u% F# J    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
% J" U$ ^! y3 c# a* u4 X" T+ l4 s}
/ u5 O3 [. U& F, b