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

天云上人

代码框架，你所要做的仅是修改WQL语句，具体可看MSDN。以下代码为简介起见，一次返回所有的CPUID或硬盘厂商系列号
! B9 x/ ^0 o4 R0 i; q- U- a) {3 [. h

1. 
   
2. #include "StdAfx.h"
   - ^( ~: Y6 x3 h6 t% m4 A+ \
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   
5. #include <iostream>
   
6. using namespace std;
   & Q" B9 T. w  E4 H& K$ C$ ~
7. #include <comdef.h>
   
8. #include <Wbemidl.h>
   6 s; N" I) w0 V( b9 g
9. 
   0 o& }% l: {: |3 R# U
10. # pragma comment(lib, "wbemuuid.lib")
    - A" D3 J& g/ ]& k5 s, g
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    * F' u- d9 V: T  X6 V: }
13.     GetInfomation();
    5 N+ l' N& l5 i3 Q! w8 y
14. }
    
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    
18. }
    - o: A; P: H! |6 J
19. int CpuIDDisk::GetInfomation(void)
    + Y0 y5 e3 J. P9 ]4 j
20. {
    ! K* a! F0 b% {: I) z
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    : {0 [4 B! e: Q
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    , C) X' @( C/ i
24.     if (FAILED(hres))
    9 S' i# F! C& d& C* c9 @+ J) v4 q7 y
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    9 y/ i( ^1 o7 G# s. x" e+ b1 k
28.     //步骤2：不是必须的，COM只须也只能设置一次
    " L9 [7 y! J; ^9 n& k6 l2 R
29.     //Set general COM security levels
    / d- X" C6 Y4 U; _5 l/ B
30.     hres =  CoInitializeSecurity(
    6 B( s, l, H# u' g+ d( Y$ I- |/ u
31.         NULL,
    
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    2 ^4 A; S4 T7 s! ?. r' s
34.         NULL,                        // Reserved
    5 [; }$ _- I" ~5 E8 c3 m
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    1 _) d# `7 i/ o/ V4 h4 @2 @2 r
38.         EOAC_NONE,                   // Additional capabilities
    " A8 S( @' a' o" W
39.         NULL                         // Reserved
    
40.         );
    
41.                      
    
42.     if (FAILED(hres))
    
43.     {
    ' _( n5 h( \# d- N" N9 S
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    - i4 V2 X/ m: b* ^* T
46.     }
    
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    $ \, u+ M7 m4 a% p% i( v; n
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    & P, V4 R# O5 J/ Z, s
52.         CLSID_WbemLocator,            
    
53.         0,
    " h, j. y3 t& i5 A
54.         CLSCTX_INPROC_SERVER,
    
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    4 [. @  X$ ?" e; I. W8 N- {
57.     if (FAILED(hres))
    
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    : T* F  U2 s& u* Q: b+ m
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    * h: U" r: B; p* E* F. \
65.     hres = pLoc->ConnectServer(
    
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    2 I- x7 ~+ ~% v; T1 _5 e" m. b3 p
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    / E, w% l, L2 x! {
71.          0,                       // Authority (e.g. Kerberos)
    4 O: {' B  b4 p9 H+ E
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    ' M& t2 w/ U0 R7 q- x
75.    
    : M! T  q/ z; \# M, C; Q# V
76.     if (FAILED(hres))
    
77.     {
    0 ^4 D  o% Z- h/ f# {! V9 Z
78.         pLoc->Release();     
    5 G8 _9 S+ w/ M$ }
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    ' [* s* J% ?6 g
81.     }
    * Z+ b, Z; i' y, Y5 M
82.     // 步骤5： Set security levels on the proxy
    1 O/ Y6 D' V: z  P+ _" n
83.     hres = CoSetProxyBlanket(
    
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
    * F5 ~* D% o" a7 c1 ^
87.        NULL,                        // Server principal name
    6 j4 Q1 v7 c* J1 B! P% _: B9 ~
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    4 i" u6 a2 N. j
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    9 R7 z: D3 ~3 @& o: }
92.     );
    / |9 T/ @$ P9 H- L  k( ^
93. 
    + o6 }" c% L6 L! @, G
94.     if (FAILED(hres))
    
95.     {
    
96.         pSvc->Release();
    8 L5 U; ]% E" l' o
97.         pLoc->Release();     
    : v: Y$ |! Y* O# [+ t
98.         CoUninitialize();
    9 h5 A: N1 J& y6 v3 M% C
99.         return 1;
    $ E0 A) H9 o; `! e/ V. x/ F
100.     }
     0 |3 j8 \3 k% I
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     ) J. \- A: O" A* x. B
103.     IEnumWbemClassObject* pEnumerator = NULL;
     ! G; z# c! w; U
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     6 s# y1 X- _; C* j8 K0 V' M
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     8 @3 X& [8 S+ F5 Q5 M5 `9 p$ Q9 p
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     9 J! t' D% u, s& a+ S0 h* P
110.         &pEnumerator);
     * m2 ]6 T) E% W
111.    
     
112.     if (FAILED(hres))
     ' k. c, a$ |0 p8 k5 r. ]
113.     {
     
114.         pSvc->Release();
     
115.         pLoc->Release();
     1 h2 o: H; n/ o6 F
116.         CoUninitialize();
     ) J' y: y- l3 y/ ?" y& _: ^: ~
117.         return 1;
     
118.     }
     / O* t, O7 q% I$ G
119.     // 步骤7：Get the data from the query
     * {: B6 P; z  {+ f9 t
120.     IWbemClassObject *pclsObj;
     $ p) B) Q+ D5 R. O/ w# F# q" H
121.     ULONG uReturn = 0;
     6 n9 @% l4 }/ t4 f: H/ F. r: {
122.     while (pEnumerator)
     0 T. h, ~  t5 r
123.     {
     1 f7 ^, m5 O: i, q. q% g0 S
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     8 R+ W+ O- N0 k+ K4 |9 [
125.             &pclsObj, &uReturn);
     ! ~: J: J8 y) {5 X$ ^
126. 
     " h2 C& S* f* n
127.         if(0 == uReturn)
     
128.         {
     
129.             break;
     
130.         }
     1 B* `% Y( M0 z. H6 t+ \1 u% I
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     9 l$ X9 |6 c8 b/ ?
135.     }
     
136. 
       _  P3 A) P& L, a
137.     //计算硬盘系列号
     + {* p5 ?9 j. y! T/ j
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     ' D& E- W1 s% n  T
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     + X3 U: H# T- B. x- |
143.         &pEnumerator);
     # M% d+ [( O. [3 u
144. 
     7 {' d$ ~6 j$ i
145.     if (FAILED(hres))
     6 n; P/ g# ~+ u$ k- A: N) W* U
146.     {
     5 L4 k4 J! A7 k7 h2 w
147.         pSvc->Release();
     ' d  M% L! n3 v- U
148.         pLoc->Release();
     5 s& J' t$ R  c1 B! U1 y
149.         CoUninitialize();
     
150.         return 1;
     3 A: ~6 |9 h9 ?7 Y, Y6 Z
151.     }
     
152.     while (pEnumerator)
     
153.     {
     5 z: L5 I- G" `3 u4 |6 e
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     0 \9 J  \2 p3 \3 C1 u: P
155.             &pclsObj, &uReturn);
     
156. 
     
157.         if(0 == uReturn)
     7 {. y/ `1 i; U
158.         {
     6 ~$ c! m9 Q$ @( Q5 {+ _; Z. M
159.             break;
     . u. z) h& l8 D1 S9 d3 _: P; e
160.         }
     
161. 
     5 x, T! m8 Q4 V* t5 a
162.         VARIANT vtProp;
     / x. J6 g! s' F! \, ~$ P; t
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     + \/ F6 T; o8 G/ v5 z# h. M$ x, I
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     0 Z6 D& V' b$ S4 d$ d! g4 n
167. 
     + E6 t7 L/ n0 J& ]
168.     pSvc->Release();
     6 e( n' E; J, U9 O; j7 Z
169.     pLoc->Release();
     # n4 d  ~# _- _' M0 l; d
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     ; d: I  @( R1 e* P' p. U$ r6 g" Y
172.     CoUninitialize();
     
173. 
     
174.     return 0;   
     
175. }
     

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.

4 j: J7 O2 J; V) ?#include <WinIOCtl.h>
#include <stdio.h>

  r& D3 R  }5 M+ R#pragma inline
//---------------------------------------------------------------------------
3 E' G, g# `- y, ~8 _8 x// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
: d% z; x9 e- B- i#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
  r5 m+ L& o, P#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
# l) E/ \) m8 k8 \' h* J
9 v' S: Z; J' B+ }& b5 h8 h) F$ rconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

$ k, y3 \: A0 m- t$ P7 Q' @2 bconst int MAX_IDE_DRIVES = 4;
# D* M  y; ~( T' {
6 ~) t2 u3 c2 Y, n' n: u; J% H# r. f// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
' G6 W6 p; @9 @const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
, ]  A2 p2 S7 _: W9 J6 Uconst DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

typedef struct _SRB_IO_CONTROL
& y" M9 I* v) z* k{
    ULONG HeaderLength;
    UCHAR Signature[8];
0 C6 E) O4 P9 {    ULONG Timeout;
' \+ ?, w+ N3 u/ S    ULONG ControlCode;
    ULONG ReturnCode;
    ULONG Length;
9 M- t: I9 Q: y1 d' P$ ^9 B* ^, x}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

// 辅助函数
0 P! \; J4 K! _# C: e% g" k  lchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
0 [0 e2 H* H- R' O4 S4 |bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
. {- p$ Q0 }) ~! l/ {! `        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
, V7 y+ J+ e* G! N        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
, R3 H, X7 }1 I, A// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
( j1 U& }% ?4 F2 B# f$ a! R- R
// SCSI读取函数(for NT/2000/XP)
& R- ]* ~1 Y% hString __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
) {! P+ z+ S7 W% ivoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
1 B  j! H9 d& r+ Z& N( v" M1 h/ E    switch(Win32Platform)
; e& C9 n/ u) e* |' Y2 S    {
        case VER_PLATFORM_WIN32_WINDOWS:
            ReadPhysicalDriveOnW9X(pSerList, pModeList);
* K+ Q) S- Y" ^3 Y0 n            break;
        case VER_PLATFORM_WIN32_NT:
! J0 o- ?+ r8 |, }, z& o            ReadPhysicalDriveOnNT(pSerList, pModeList);
' x4 `, l( H4 y: M            break;
        default:
; x% g1 U$ d" v! a( g" D" A0 a$ H            break;
    }
1 A8 }; C: ~2 d* `}
//---------------------------------------------------------------------------
// ConvertToString
2 C9 }+ c$ ^  S1 P, S& O) V/ @char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
" s9 r8 F+ M! j4 A+ `    static char szResBuf[1024];
    int nIndex = 0;
    int nPosition = 0;
( S- S( g$ \4 J1 m. q- n
! ^0 L4 y; T$ }2 Z) s* J  \    // Each integer has two characters stored in it backwards
- f  q& C& Y3 y* t    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
, M0 o" k# c* l, b9 @        // Get high BYTE for 1st character
% Q! E9 X, P$ v1 I( i; t/ U        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;

/ I- `1 H9 |/ r) y- Y4 d" g5 X        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
2 s2 w5 R1 d; {& Y" T    }

& @3 ]. W: q( L  }    // End the string
    szResBuf[nPosition] = '\0';

$ B/ W3 |8 Q8 s9 m2 F! c$ D: _; V    // Cut off the trailing blanks
* S* B( ^* U) d, }: X! [$ E    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';

    return szResBuf;
$ ~" y8 n; d3 N0 b- g5 A}
) M/ C/ h# F' H( r. J//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
/ K: y5 Q/ ^) X) }! h//---------------------------------------------------------------------------
; g4 Z1 f+ ?# |; s- x// ReadPhysicalDriveOnNT
( o: ?# z3 F% s' Hvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
! Q9 Z& d, `% s4 a7 Z3 }4 F{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
/ z; L) R& \& ]+ T8 t7 y
    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
, z+ ^2 u) e' ]/ f' h! G6 y- a        HANDLE hPhysicalDriveIOCTL;
/ K) n# f4 k6 |# J* ?        char szDriveName[32];
9 s4 N3 b5 y4 K4 L1 P8 X
        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
! i2 H) P0 Z4 M% J        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
8 o- e6 M9 u" e1 \8 e                        OPEN_EXISTING, 0, NULL);
5 y+ Z: c7 @0 ]" f8 C1 q1 Y
        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
; Y7 P. O3 I4 i; p$ L" Y            DWORD dwBytesReturned = 0;
0 y! R9 z+ [$ p# U            GETVERSIONOUTPARAMS gvopVersionParams;
! L& Z2 ^" n; n5 F( |
6 Z. M& g0 b/ R. j' v: q8 _; h            // Get the version, etc of PhysicalDrive IOCTL
4 f# x! ?! [4 S$ I( O            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
4 r- X; l4 A8 w8 _+ R& d
            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
- ^& M5 K# D% t6 Y5 m3 e                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
" H  n+ c( K6 \! n! g/ B  C                    &dwBytesReturned, NULL))
            {
  l- v4 O0 c, m- c' R2 k; S                continue;
            }

3 ?2 D% k% o7 G1 J# |9 p            if(gvopVersionParams.bIDEDeviceMap > 0)
1 O' n. Y# M7 Z            {
- o  q) ~6 |  t! t& q9 C# f                // IDE or ATAPI IDENTIFY cmd
                BYTE btIDCmd = 0;
+ J6 t7 I: R: w- E                SENDCMDINPARAMS InParams;
2 B( o6 k2 O3 W& [                // Now, get the ID sector for all IDE devices in the system.
                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
$ _& w8 g5 W4 ]5 V1 A                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
0 |6 G5 Y( X/ o: V" s/ l9 Z8 _& X                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
: [2 P  Y! c  k7 ~& T' }                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
3 a* `/ g4 ^4 D                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
# L6 f8 V; [( _3 n, F* R5 s                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

, x8 ?; ^0 x$ c- C                if(DoIdentify(hPhysicalDriveIOCTL,
* w5 }1 C: d; U. V( w. B  J2 v) a                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
! u6 i+ Y* S0 B% ^                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
8 n9 N8 w* s8 q                    DWORD dwDiskData[256];
. I& ]0 T# h+ l5 {! j, n* r' ^                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
; u6 H  H; u& G& _# N% d                    char szSerialNumber[21];
. i& G7 H8 V  `/ f1 U$ Z                    char szModelNumber[41];
7 R" b+ ?+ A- x* U' O3 j8 q
  O( t* W/ S  f7 d# M                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
" n+ I6 T3 Y) y, e2 x" v                        dwDiskData[i] = pIDSector[i];
8 I: ]  J7 d  V                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
4 J4 d( X/ ~( ~, ?# K, W8 G                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
$ f: r) \% D. m+ }                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
% S* R2 u% f0 B6 A2 n' S, r  b4 T8 S                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
                }
            }
4 p+ S- x" J0 R6 y# z4 g            CloseHandle (hPhysicalDriveIOCTL);
        }
    }
}
//---------------------------------------------------------------------------
$ {# W' y( ^+ N3 ~// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
7 ~6 F$ x- u8 b& q) |3 V0 r; F) i              PDWORD pdwBytesReturned)
4 w* [- |: r8 `0 q- ?{
    // Set up data structures for IDENTIFY command.
4 ~. |/ z) K: J    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
& v' W, C$ G, O# J+ }    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

' x. ?6 x4 p1 B6 G    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
, ?4 _+ D! p0 @( S& A    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
& L0 a- E/ ]  X
4 G+ N" J4 `: E' b    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

" g" S6 n1 \+ s# ]$ }. ?1 n/ X8 e    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
7 C% H! c0 |* F0 g5 [           (LPVOID)pSCIP,
9 q7 x: n+ F- i' c" E, H% V           sizeof(SENDCMDINPARAMS) - 1,
# H# T% r+ e. e: T0 ?9 N6 S- m           (LPVOID)pSCOP,
; p2 |8 c1 c, T4 k! a, E           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
  y! H8 f+ b) J9 ~  ]5 A//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
, W  Q: g1 E8 B0 v8 E! {) `2 y9 S% avoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
' d+ P- U6 |8 _( B3 k. D* c    WORD wOutData[256];
% s" I: u; G  q7 g' ?: a    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
& S, V2 R1 ]: s- q5 o
/ O  r7 z7 C/ [    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
3 a: M- ?8 e3 S' X8 `+ r+ s7 I    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
" m& K% b9 ?% a" x    // 避免蓝屏的出现。（期待高人能指出原因）
0 x  E% _" c  N$ M# Y8 S4 I    for(int nDrive = 0; nDrive < 8; nDrive++)
; L7 O3 _! a2 D    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
% I/ Q. l) p& S7 N        bool bIsIDEExist;
: d' s4 g% C  P0 g( p' B3 m        bool IsDiskExist;

        switch(nDrive / 2)
+ d. D: v( {6 P- t        {
! ~$ c. b* o  ?            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
9 |6 P7 C+ G# X  A1 {3 g            case 3: dwBaseAddress = 0x0168; break;
& h$ M) h4 \# j6 s; l        }

        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
) x* Q8 F7 Q6 f4 ]: U3 I. F# D
- L" V3 c- d7 E" a6 x( {4 l        // 进入Ring0
2 O% ?$ u- f$ ?1 r        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
* K- `! j% m7 Q4 C' G, X/ d9 n9 X                bIsIDEExist, IsDiskExist, wOutData);
+ [& o$ U! Q: }    }

( D( I: R' |7 H  I    // 开始读取
    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
, y0 i. Z% \( V5 d$ Q+ W) J& n        BYTE btMasterSlave;         // Master Or Slave
% F$ ?4 u- q/ N3 G2 T        bool bIsIDEExist;
( T, i! R1 \6 Y/ Z3 [7 P        bool bIsDiskExist;
' y9 T: t9 L( h* v. h7 P: e. D        switch(nDrive / 2)
& J1 u# M" ?! J8 V6 {        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
" c) w$ l6 j, A4 m        }

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

- I0 M3 q5 C; a) l8 y        // 进入Ring0
' L! z# p; V( P: ~! \        bIsIDEExist  = false;
& y$ w0 M% p6 I        bIsDiskExist = false;
0 v4 w) k# u$ N, j        ZeroMemory(wOutData, sizeof(wOutData));

, p8 R) G( K/ l* p9 W% r        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

        if(bIsIDEExist && bIsDiskExist)
        {
4 F% `8 B  e$ m! Q            DWORD dwDiskData[256];
            char  szSerialNumber[21];
            char  szModelNumber[41];

0 ~* }& Y! u3 X) P( l            for(int k=0; k < 256; k++)
  |9 Z, Q6 V+ m  a! }: S                dwDiskData[k] = wOutData[k];

3 D$ I7 U+ A1 o- Z& ?6 h6 o            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
" t6 z- |; N; i# w& v            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
: E+ c9 }3 P' Q! ~# }6 v$ w
5 U. r, G2 I6 w" V( G            // 取模型号
4 N. ]! S& A2 g            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
- N. g$ h/ i5 L0 U
            pSerList->Add(szSerialNumber);
! a& B. p: s$ i/ c            pModeList->Add(szModelNumber);
3 q% G# H. O$ E! p* x# w        }
" i) \- p  G: N$ h1 ]2 n0 M    }
" m' P, W8 Z, ?* A! F) x- n    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
: u) U" Q% r& \2 _}
//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
( v6 @5 F- r8 Z( H  J4 n; r' c, R( E// ReadPhysicalDriveOnW9X_Ring0()
* \- V2 M' J) w% K- ?//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
    BYTE  btIDTR1[6];
! E, ~/ d* D* Z% I- B! o4 H! E    DWORD dwOldExceptionHook;
$ ^0 K2 S  ]& p* h( b    const int nHookExceptionNo = 5;

/ r! G5 r! c2 h# S2 f/ ]    BYTE  btIsIDEExist = 0;
6 m" W8 f0 f9 u4 J8 _    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;

    const BYTE btBit00 = 0x01;
0 m/ V7 V. n9 |" n- y; Z, e; c    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
0 H0 P7 N( U9 h/ S  Q2 H    const BYTE btBit07 = 0x80;
7 G+ Z: Q: l- k3 E: b    // const BYTE btERR  = btBit00;
/ ?+ C1 F; s, S    const BYTE btBusy = btBit07;
( Y* R3 A( S9 M& w    const BYTE btAtaCmd   = 0xEC;
* _' u# Z( q2 [: V$ _5 u    const BYTE btAtapiCmd = 0xA1;

    __asm
    {
        // 必须先执行这条语句
: L  g3 N: \4 E0 x( b) q9 \        JMP EnterRing0
3 T6 b! |, A1 l/ w% |1 u
# i; }, Y% m# j' k# X        // 定义过程
* Z, p$ @, ^0 e( [2 M5 }        // 等待IDE设备直到其不为忙为止
3 a' j) C$ P- S* E# W        WaitWhileBusy proc

+ w# x& B' A6 y* j        MOV  EBX, 100000
: Y" j% Z. k0 m; ?, t( I* \        MOV  DX, dwBaseAddress
( u5 y, I6 z4 |5 ?. ~        ADD  DX, 7
! V. m" T, y4 ^( V) X
# g5 R$ I  G2 F9 l/ F, n3 y        LoopWhileBusy:
1 ^' ]! _! \- C, A% x
        DEC  EBX
# W9 {0 E  Q. Q( @7 p4 Q        CMP  EBX, 0
        JZ   Timeout
. |; z! k+ k' h% d+ f  [        in   AL, DX
        TEST AL, btBusy
        JNZ  LoopWhileBusy
        JMP  DriveReady
* V. [5 T+ F% k) J- `$ M: C
        // 超时，直接退出
        Timeout:
        JMP  LeaveRing0
        DriveReady:
        RET
! v( k: b% Y- M        ENDP   // End of WaitWhileBusy Procedure
5 }! P# t$ `/ k( e  ?& B& Q0 S
7 @5 a( I  t2 A, L0 A7 W! C0 H5 \+ `        // 设置主盘和从盘标志
        SelectDevice proc

        MOV  DX, dwBaseAddress
7 K' J& [5 ^4 ^5 A7 Y' N4 t        ADD  DX, 6
        MOV  AL, btMasterSlave
$ ?7 ]4 l9 X9 F  f6 t" b% a. f
        out  DX, AL
        RET

        ENDP  // End of SelectDevice Procedure

" c7 M4 a3 N& X  {        // 向IDE设备发送存取指令
        SendCmd proc

4 }: W/ y9 B4 E8 r9 E        MOV DX, dwBaseAddress
        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
        RET
& [; G( |* L0 I  @        ENDP  // End of SendCmd Procedure

5 h; Q; s: A: j( R        // Ring0代码
- I" F: P$ }3 o+ K9 A# r7 [        Ring0Proc:
        PUSHAD
        // 查询IDE设备是否存在
( L0 J& n# a: D% D5 O        MOV DX, dwBaseAddress
. Q' A: K4 a3 d- @5 |        ADD DX, 7
        in  AL,DX
0 t* n6 m9 j" z% X( h$ j9 P
        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
        JZ  LeaveRing0
) a  v& j3 b) t1 l; @! X$ u0 N        CMP AL, 0x7F
! j; U9 A0 t: `, m$ H% T8 F' s7 W        JZ  LeaveRing0

        // 设置IDE设备存在标志
" G5 n7 V# A# z        MOV btIsIDEExist, 1

% M3 f5 u0 w2 e' p4 a6 H        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
        CALL SelectDevice

* n) c2 g! H' T) c        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
( m  T7 |, \% k        CMP  btIsFirst, 1
        JZ   LeaveRing0

, D- v3 f+ P4 c* p/ }5 ~3 j+ \        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
- n; n! t$ h$ z) o        CALL WaitWhileBusy
. C% Y6 M$ w$ d- d4 f8 ^
        // AL的值等于cBit06时，不存在驱动器，直接返回
& i* g4 R6 Y  ~& z        TEST AL, btBit06
, m: ]3 ?1 g( x5 {  M: @        JZ   LeaveRing0

        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1

        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
8 S1 b: s$ p4 r2 B2 z4 {        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
  p7 v- a- S6 j6 ]        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
, M* _+ G% |2 k# Q5 B: }        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
        CALL WaitWhileBusy

2 _% S# U- F0 T) p        // 检查是否出错
" h% D% A. V8 D) m: ~        MOV  DX, dwBaseAddress
7 t' @9 o2 K% e) R. t) m) q$ T        ADD  DX, 7
% w& Q; V5 L2 D
& v) {3 d" w1 k. k* }0 D        in   AL, DX
+ m- c% q* j( {7 F2 Q
        TEST AL, btBit00
* S6 r8 u* w: Q* J        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice
; k9 u: q8 `8 u+ \1 t        MOV  BL, btAtapiCmd
        CALL SendCmd
( ?( f& ^1 \& y! I        CALL WaitWhileBusy
3 b  S& ]* m" R/ y
        // 检查是否还出错
        MOV  DX, dwBaseAddress
2 \9 V/ _4 y/ T) y        ADD  DX, 7
& @8 X! P% x# g7 C8 @( K        in   AL, DX
8 T: I4 e( Z) |  b0 `4 ?        TEST AL, btBit00
& n- |1 t* R+ }7 t' w3 z$ u        JZ   RetrieveInfo   // 没有错误时则读数据
4 l% b3 h4 c! P8 E8 \        JMP  LeaveRing0     // 如果还是出错，直接返回

3 r; [! p6 P" u        // 读取数据
. F: J8 B9 }/ }" d. o1 V& x: K  S2 k        RetrieveInfo:

' @% q* X7 G. X# R* h+ D. I        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
) o" @* |$ ~+ U# c6 J        MOV  DX, dwBaseAddress
        CLD

        REP  INSW

        // 退出Ring0代码
        LeaveRing0:

        POPAD
        IRETD

        // 激活Ring0代码
2 t, \1 ~& a* C% O6 ^/ e, _        EnterRing0:
$ g# \* ]1 T$ y) U8 L; s. K5 L( y
* o7 b3 F5 H2 y, |7 L        // 修改中断门
        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
/ _4 k+ |9 z) f# N        ADD EAX, nHookExceptionNo * 08h + 04h
7 F% Z* C* x3 x; e: L- B6 m) A        CLI

* R. b) s& r0 }! Q& H$ v0 P# P        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX
1 C2 T- t+ R6 G1 R" R
        // 指定新入口
        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
+ H, a' O# @+ |8 i        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX

! Z- h4 W! u. X3 g7 P$ S        // 激活Ring0代码
( z* B* B: B; E3 u+ e; b- t        INT nHookExceptionNo
2 `7 p7 y* {7 N1 Q  z& y& ~) p+ v
        // 复原入口
        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
' V% F8 I, [0 M8 [: I1 \        STI
    }
    if(!bIsFirst)
1 ^9 M+ S% e. z4 u5 O    {
        bIsIDEExist  = (bool)btIsIDEExist;
; \: h$ Z% A4 U- G2 b( {- `  K        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
/ }" c9 ]- _) n' i6 Y% X    }
) Z* f" j0 I+ H2 f}
' s6 |0 \4 ?& [. X0 Q0 v; r+ l//---------------------------------------------------------------------------
// 调用方法：
8 z2 K' ^" ~% @void __fastcall TForm1::Button1Click(TObject *Sender)
{
% }$ z# C7 r; _# s' h/ M! {    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
/ K: u, G. y  S( f2 Y7 c) C}