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

天云上人

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

1. 
   ( R# L* o, h% K! d. v* k& k4 W
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   " [8 u+ A/ H1 T4 h- Q
4. #define _WIN32_DCOM
   
5. #include <iostream>
   7 }+ ~* S+ v( N
6. using namespace std;
   
7. #include <comdef.h>
   7 f8 d6 Q8 @4 i
8. #include <Wbemidl.h>
   
9. 
   & H9 o1 d  T( f; R6 q, m4 M# |
10. # pragma comment(lib, "wbemuuid.lib")
    7 p' z6 |3 N% U# \/ J
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    
13.     GetInfomation();
    % o; Y% Y) ]2 M2 B) Y- U
14. }
    + B7 ]& [; P3 n& K' k% p; T/ f, m4 n
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    ! d  c; W7 q- K7 y( M
17. {
    
18. }
    ' _7 B- }" d, v1 U3 y! c! h
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    ! A" x  D0 k7 [6 L7 I* }3 i: |4 P
24.     if (FAILED(hres))
    ' O. g  z8 S7 s1 e. s5 K
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    / {1 C2 u- t) B4 H
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    
32.         -1,                          // COM authentication
    $ |9 v( G) y, X; {8 N% U/ {) [
33.         NULL,                        // Authentication services
    , x3 e, p: B( j, u# x1 ~4 l# h
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    ( r6 ^; j% g/ R+ V1 D9 Y
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    8 Q! _; s5 R0 z. o3 V. \+ [- r( Y
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    ( |) n" |  P. u$ w
40.         );
    
41.                      
    
42.     if (FAILED(hres))
    : G: e; [, E. E9 d& i- K+ g
43.     {
    
44.         CoUninitialize();
    8 x# `2 \$ T* C9 b
45.         return 1;                    // Program has failed.
    2 g3 Z8 B2 Q- x. O/ M- \
46.     }
      Y- ?" Y0 ~6 }- G
47.    
    / n) d' s) {, g" C: x, K1 J- E( q
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    , M& a) n% x  m6 P
49.     //步骤3： Obtain the initial locator to WMI
    & U9 a" t# x! t" z: D$ E0 G
50.     IWbemLocator *pLoc = NULL;
    / M: F# P5 f' x: k+ C) W
51.     hres = CoCreateInstance(
    5 z$ b8 l6 J8 ]( Y7 a; S
52.         CLSID_WbemLocator,            
    
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    ( \% s3 Z( [* _8 Z) u' w, t
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    
57.     if (FAILED(hres))
    9 s# T7 C: z& ~, J( s' ]
58.     {
    
59.         CoUninitialize();
    $ a& k6 ], E9 X/ `3 H$ I. ~$ {+ Q
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    
62. 
    2 n7 d: X9 W, N1 N0 d
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    : D' f8 a8 t! }# u& x( t" `
65.     hres = pLoc->ConnectServer(
    * v& D' `0 |3 {0 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
    : n- d- W; R& Q
70.          NULL,                    // Security flags.
    , R* d4 x0 W4 M" m* s4 O8 L
71.          0,                       // Authority (e.g. Kerberos)
    , ]* ^4 o/ y7 h, K3 v* [
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
      V( Q0 Q  e0 ^9 E; l
75.    
    3 g3 m- q; R9 ^5 |
76.     if (FAILED(hres))
    ! `: p$ V! D: a: s
77.     {
    ; z; k0 [: H6 N0 `) {4 ?
78.         pLoc->Release();     
    3 U" ~0 p) [# L# q8 a5 \
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    $ K( T5 n6 S  Z- j! a( O; f( \
83.     hres = CoSetProxyBlanket(
    7 ?# m5 @0 g, R& i$ }! O. ]
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
    + _1 j2 V6 o8 |' ^% n3 k
87.        NULL,                        // Server principal name
    
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    ! i$ e  V# ^7 }' j
93. 
    
94.     if (FAILED(hres))
    , [6 P% F7 X8 B) y! G$ O/ D0 U/ f  M
95.     {
    
96.         pSvc->Release();
    + w. Q3 Z$ z1 U, c+ @6 E9 T! k( @
97.         pLoc->Release();     
    
98.         CoUninitialize();
    ) {# ]3 Q' h8 B  j' m; B1 l
99.         return 1;
    
100.     }
     / F7 [( n2 b. b
101. 
     . d$ c% X( g# g: |
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     # A& `, D1 X6 c, U
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     ) o0 v1 q) ]0 I
106.         bstr_t("WQL"),
     , O9 P4 t( n( S1 `1 T
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     , n, b2 n# \( B2 \1 E4 O
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     3 v! z7 `% ?. G1 q7 Y
110.         &pEnumerator);
     3 r& L) s# V1 U$ H
111.    
     2 g; y5 q, F3 s4 k% K5 y# s. P
112.     if (FAILED(hres))
       u& s9 M; t/ T$ Z7 y5 Y
113.     {
     6 c* M) L$ S7 i) s* L
114.         pSvc->Release();
     / W/ i6 E/ e+ X6 \
115.         pLoc->Release();
     
116.         CoUninitialize();
     
117.         return 1;
     / g/ R8 I4 b; t7 F6 }
118.     }
     2 _" \6 M5 i7 p+ |- H3 M) G& i% Z2 ^
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     $ ?& t1 T9 u- Y, [6 D3 f' |
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     
123.     {
     , z( Z- L7 W3 B! P2 f+ S
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     
126. 
     + J; A8 G# F1 e. s- w' O$ F
127.         if(0 == uReturn)
     $ m8 Y! \# w, z$ |
128.         {
     
129.             break;
     * u, }4 v6 h) ?
130.         }
     
131.         VARIANT vtProp;
     ' Z; Z, ~$ j& d  e/ Q
132.         VariantInit(&vtProp);
     ' \8 P: f7 f6 K# |, ?( X) D
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     ( H& o" q4 N9 w
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     7 d7 ]9 }: r" Q5 }
135.     }
     5 u$ c1 z2 r; R5 Z, a
136. 
     
137.     //计算硬盘系列号
     * U5 C* N8 t) u6 t3 n" l
138.     hres = pSvc->ExecQuery(
     0 Q6 o3 w8 k* J: j
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     ; v2 _; Y+ a" y& c- z/ Z
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     7 m% Q, r, }3 K! \6 I
143.         &pEnumerator);
     6 a. y% z/ M& C% T0 `. r
144. 
     
145.     if (FAILED(hres))
     + p) R5 L4 o3 G* J' l
146.     {
     & F  r6 @" }5 Z, L  h
147.         pSvc->Release();
     7 Y: W: P+ l+ V2 O+ J
148.         pLoc->Release();
     . ^0 a: u$ a; Z; M- Y4 J$ n
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     * y* f- p% a% K. L- F& g6 E
152.     while (pEnumerator)
     ; ]+ u/ {" z8 L) u% d7 P
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     ) v' O2 r& ~# D- F% U
155.             &pclsObj, &uReturn);
     
156. 
     ; e! p  w% F+ z
157.         if(0 == uReturn)
     
158.         {
     * a2 W9 P6 |1 l
159.             break;
     
160.         }
     6 F+ |( s2 P$ R- k; X3 P* ]& _* ^
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     5 O' e# f2 Y+ {$ z
166.     }
     . _' G$ C3 {5 T; h
167. 
     
168.     pSvc->Release();
     6 B, A3 q& m0 r" G
169.     pLoc->Release();
     0 ]# u9 d( Q9 ~5 C5 ]
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     ; |; e' N, _' x) }# t& c7 W0 v! _
172.     CoUninitialize();
     
173. 
     6 x* Q4 O8 E  H8 @; j
174.     return 0;   
     6 [, G8 K" {% _
175. }
     

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
* w9 {) G: f% y3 |5 n
#include <WinIOCtl.h>
#include <stdio.h>
8 h1 X4 \* ]! b
7 |4 l; s4 F3 V* L% z" }4 p#pragma inline
( E4 `# `, @) `7 L% [9 v  |0 S//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
#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

const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

; _% V( a' P3 x1 z4 N( x3 sconst int MAX_IDE_DRIVES = 4;

3 @4 F- c) J* B" f" R// SCSI专用变量
6 N) J/ p: ^. |% @; l3 Oconst 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
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

typedef struct _SRB_IO_CONTROL
{
8 s5 o! E" y) e/ g    ULONG HeaderLength;
    UCHAR Signature[8];
# o8 J6 D) K" J: V: h3 ]6 Q    ULONG Timeout;
* Z, t7 }( z0 [+ h9 ]    ULONG ControlCode;
    ULONG ReturnCode;
0 J6 U6 G- y- \5 z( x* Y    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
3 ~7 y6 z" J0 l, B8 p! n. m2 J; m0 D
// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
7 Z% N5 x, s, k- w- w) j
/ Z1 A# U3 W- {& p: ~: Q4 X) I8 F7 X// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
7 C5 S/ H# \! t8 S8 ]: x// NT/2000/XP函数
" C. K6 T4 O/ r5 {/ wvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
& e% ?' ^9 |: q8 e! C( Y3 L: h        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
' D  j+ L7 o, a1 C! S// Windows 9X函数
- `7 v  T- ]* T4 Rvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
8 a5 n6 s6 Q( N. a( u0 q# b0 `. N
& @* I1 @4 L  @7 c// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
- W; r. P/ D/ O// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
) U* @( q+ ]8 ^' Y{
    switch(Win32Platform)
  V$ f# B3 J- w4 L1 h" ?    {
# v. {/ C6 A% b4 N! _        case VER_PLATFORM_WIN32_WINDOWS:
5 l3 L8 `) l. a* ^; d            ReadPhysicalDriveOnW9X(pSerList, pModeList);
) J4 E1 S+ u( [! H, U& L            break;
* R* ?1 y+ y# r: K0 f* P2 m4 g6 c+ z        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
5 R) u4 q  O5 K        default:
0 g2 |" g) X/ d* C5 H: a            break;
    }
# ^8 ?# i# b8 X# y}
//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
    static char szResBuf[1024];
6 G) x: Y2 V  Z' g" X7 a: w# S6 F    int nIndex = 0;
+ S6 @% |$ A  ^! d9 ?    int nPosition = 0;
- ?, m  o# u- ~) t8 o7 v
8 o  y; i# C7 }/ M$ N- a    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
        // Get high BYTE for 1st character
- |) C& @3 w* ?/ o4 ^        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;
( M/ w, M* k% V- d4 o/ m
        // Get low BYTE for 2nd character
0 T6 ~. |% ]# @9 G4 v) h        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
' o0 Q. d0 ^  ^3 `+ n2 _2 M  `) \        nPosition++;
' C) W$ j5 I* R5 u    }
! D3 @6 Z9 i. h7 Y$ Y
# N1 b# v) k! _: g, u    // End the string
    szResBuf[nPosition] = '\0';

    // Cut off the trailing blanks
, Q6 `+ \3 A  @' o2 S7 U7 h% u    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
1 J+ D( ?3 s' H) B% F        szResBuf[nIndex] = '\0';
6 H3 i# r' n1 P% A# \2 G0 v6 [
) ~! s; @! G/ C5 E" Y3 Y    return szResBuf;
}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
' E2 l' A% B5 S9 a/ }9 P; P//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
; \) C. H5 U! c8 X# p# Z  Evoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
5 C9 z( Q6 A; G% T8 z
5 k, Z0 a/ f/ ^    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
% P, C, h. U5 ]: |0 X) p4 t  p    {
        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];
7 @. b  F  F7 F; t
        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
. c# n8 ?: t; g7 k        hPhysicalDriveIOCTL = CreateFile(szDriveName,
6 l" [: \0 v" o. o                        GENERIC_READ | GENERIC_WRITE,
) o! z6 F) R0 G4 x8 l                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
% w$ K6 X$ m6 ]5 R* n' T                        OPEN_EXISTING, 0, NULL);
" a( u* V3 p+ W
        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
            DWORD dwBytesReturned = 0;
) K9 Z, c/ u- n1 O+ x1 o4 k( n$ t0 B            GETVERSIONOUTPARAMS gvopVersionParams;

            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
  }* l, {6 h. H4 ]
# I: g2 X0 a5 l9 Z9 Q            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
8 F; w) r3 H7 b3 h3 \# n2 a, L1 {                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
& a: P; b8 Y3 X( e  W                    &dwBytesReturned, NULL))
            {
7 @& P9 w  ?6 Z5 ~! W2 A  l' P) ~                continue;
  |2 t3 l2 G7 M7 z8 t  j            }

1 M  b, o( A. X  v$ k            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
                // IDE or ATAPI IDENTIFY cmd
1 S% s3 h; r$ W# T+ A9 x: P& n                BYTE btIDCmd = 0;
                SENDCMDINPARAMS InParams;
. W  R7 D* e8 ~                // Now, get the ID sector for all IDE devices in the system.
1 [9 g% u9 x! g$ |                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
  V3 @) e+ m0 F3 ~                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
0 E2 |- j/ G- ]                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
: _# P8 T" H0 E& P5 G% b" k                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
$ O1 K# a# l- h8 g' o( T+ |
                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
& V" Y+ P9 d. }8 v+ ?                {
                    DWORD dwDiskData[256];
- a. b& [: |4 V; o                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
8 O. w. d; d" m1 s. o. F# f                    char szSerialNumber[21];
                    char szModelNumber[41];

                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
' P. z4 x# E9 J# H                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
& b& I2 w% `9 `$ {/ I0 Q                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
4 A0 G  ^! P# k+ {+ _/ @                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
6 ^: I, K# v/ i1 w
                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
9 p5 W3 e$ d  e0 ]
                    pSerList->Add(szSerialNumber);
3 T' u4 i& P, A  Q                    pModeList->Add(szModelNumber);
                }
            }
/ i) |1 U# N* N: X5 [; s, E            CloseHandle (hPhysicalDriveIOCTL);
        }
    }
6 ^1 x9 V& W8 J) p+ J9 F+ ^}
0 i( Y. n7 X+ y, J  _2 U  ?//---------------------------------------------------------------------------
, g4 R% f0 F  Y) b// DoIdentify
  Y9 G' P+ N3 K2 i& Q1 _bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
; r2 @+ t5 b6 K: E$ A/ @              PDWORD pdwBytesReturned)
  h7 G' y  O$ V% B  d8 T{
    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
. I/ V5 I) G) `    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
: k4 j2 }6 E! g* t    pSCIP->irDriveRegs.bSectorNumberReg = 1;
' _* B8 _: f- d% w3 M1 a# {7 b    pSCIP->irDriveRegs.bCylLowReg  = 0;
/ q9 I' c( ?1 l+ i  G% o7 F( t    pSCIP->irDriveRegs.bCylHighReg = 0;

8 T3 `! b0 z! I. z    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
) V. C9 I/ J1 A" m    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

    // The command can either be IDE identify or ATAPI identify.
/ F6 l) z0 \8 o' }/ c    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
. t" H) G: `: s9 J) a# H* |  d8 K    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

$ L* i' w7 O$ I    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
+ e4 F2 r0 t7 b           (LPVOID)pSCIP,
- {9 a! f( p/ `0 f5 E           sizeof(SENDCMDINPARAMS) - 1,
  |. B" S; I. N" o           (LPVOID)pSCOP,
/ G$ X# t3 I& P) y, S7 M           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
2 T9 @6 a" {6 n# R+ B           pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
  X- y7 p5 d- L+ R// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
/ F) Y5 f- z9 ~9 [$ J    WORD wOutData[256];
  q8 h+ ^- c8 I    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
  u9 z2 W" g) ?$ v1 ^& u" s/ K
+ f6 c. R4 y. @# v4 j( o! m" t    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
        bool IsDiskExist;
, g  t* i5 ?5 V) T! Q9 h
+ w) K! z) ^" O) Z5 S. p" ]1 _! @        switch(nDrive / 2)
8 }# {6 |3 S$ w7 M: d; u! R        {
2 `3 P  P8 v5 v            case 0: dwBaseAddress = 0x01F0; break;
; q* w/ M5 j; _: @  f            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }

        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
; A) T5 y7 Q2 {. S9 j: l+ h4 h, B
9 j: p  \8 z4 V  ^: _        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
, K5 h2 r/ u4 v. r( r( f1 k. l                bIsIDEExist, IsDiskExist, wOutData);
    }

    // 开始读取
    for(int nDrive = 0; nDrive < 8; nDrive++)
( A& K" o* I* i* Y0 ~    {
6 a. Q  O  K" k! Y) s: x        WORD dwBaseAddress;
2 F! e+ M/ q) Z. M        BYTE btMasterSlave;         // Master Or Slave
; E0 b3 I3 u! b& w        bool bIsIDEExist;
        bool bIsDiskExist;
        switch(nDrive / 2)
        {
2 y  w1 [9 \$ ?! e  L            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
6 h) w7 ]( G1 {: {4 |$ }! u            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }

) U6 D. c& c8 ]. _, u/ k        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

2 Q' f0 M, r- q5 {) I        // 进入Ring0
$ `5 J* B; I7 [& y  M        bIsIDEExist  = false;
- g" ^0 ?. y* p; m" k4 D+ }* c( m        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));
. S- a3 d8 ?, e# L; q0 Q8 s4 M
/ H$ |! P" Q, r4 G        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
$ @$ O7 p) y# V) `                bIsIDEExist, bIsDiskExist, wOutData);
+ j- r, i/ v6 B+ {% j0 S+ R7 {
! I" Y6 I* |# a2 j& A& s# `        if(bIsIDEExist && bIsDiskExist)
        {
& w5 H7 r! B- _- [            DWORD dwDiskData[256];
6 l: K2 g. S' H- S( f( d, p            char  szSerialNumber[21];
0 h2 y! i! e1 k6 i            char  szModelNumber[41];
1 n) q# U+ g9 ?( O3 B9 v
6 O" V" |. O! p1 X% g- U            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];
# `0 L1 _! l6 w; }/ K
+ R7 ^; L& f4 F3 R( Z            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

            // 取模型号
. ^8 ]5 ]6 e# _! W            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

8 z- Z, m$ z# ~- b            pSerList->Add(szSerialNumber);
) X; r  V% R. W$ s            pModeList->Add(szModelNumber);
8 n! ~' R2 B+ F" x; B7 ^        }
    }
  _$ v% n  O, G# C5 S    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
& M7 t: T: l8 e7 ?- n. |( r) r}
//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
& |2 ]. _* [* c' Z8 g' M! Y) y//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
3 P6 n/ W$ l% H4 k7 A: ^// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
+ ^" z* O6 i7 }# \" [// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
+ T  ]( e" o* M2 z  zvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
) i* v% h% S; [! R! ~$ M{
    BYTE  btIDTR1[6];
8 M# _6 i8 t+ a$ Z    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;

4 @' ]+ y8 D& z2 X2 W8 k    BYTE  btIsIDEExist = 0;
5 g% l+ T+ {! L, Z9 s& `" a    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];
1 M. ]1 f: h- h: N: i' W
4 t; O: Z% _9 z! r    BYTE  btIsFirst = (BYTE)bIsFirst;

: r# Q- R8 _& O# V8 x+ S- p1 t    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
2 p4 R: n! T# g7 F. g# z    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
7 h8 R+ b/ C$ Y- J5 A% H# B, {    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;

    __asm
    {
0 j  O1 Z9 B" i$ p& B1 M        // 必须先执行这条语句
        JMP EnterRing0
8 n" d! i1 Q8 n1 G& \( ?' x/ }9 [) n
/ ~9 `, r7 c+ }0 {( d. J# r        // 定义过程
        // 等待IDE设备直到其不为忙为止
* y+ J+ m) p; i& D4 O* L        WaitWhileBusy proc
. T, Q+ h3 {/ T
        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
        ADD  DX, 7

        LoopWhileBusy:

        DEC  EBX
        CMP  EBX, 0
        JZ   Timeout
        in   AL, DX
        TEST AL, btBusy
9 Q  ~' ]0 \4 r6 B1 V0 T        JNZ  LoopWhileBusy
! m' H! S- r$ ?4 Q2 F; |  a0 z        JMP  DriveReady
, j# E& C4 a% x
        // 超时，直接退出
        Timeout:
' B( ^/ }7 D; g! q4 c        JMP  LeaveRing0
- n( N  K8 K: C; T        DriveReady:
        RET
! `3 p& j6 x! g+ H! [  X) U: g        ENDP   // End of WaitWhileBusy Procedure
" _! \! }6 d5 I
2 h) ]: G' d  C/ h7 e/ M2 q        // 设置主盘和从盘标志
        SelectDevice proc

) G' ~, Q/ u0 Y0 @2 H$ L9 M        MOV  DX, dwBaseAddress
- ?6 I/ U; s- w* L        ADD  DX, 6
" U4 F9 F* `8 p  b- t        MOV  AL, btMasterSlave

        out  DX, AL
        RET

5 A; y" |* R' i6 x/ K1 A        ENDP  // End of SelectDevice Procedure
  F4 A" Q' W  r% X
        // 向IDE设备发送存取指令
0 R, \/ i5 p5 U: j8 B6 G/ ]        SendCmd proc

- M$ V+ q8 a5 R# a% s        MOV DX, dwBaseAddress
        ADD DX, 7
6 _) x2 }$ W* I0 l5 i% ]        MOV AL, BL // BL是主从盘标识，在过程外设置
6 x+ Q' b. K( F9 c9 g        out DX, AL
        RET
' ^* W' l. ^2 ~        ENDP  // End of SendCmd Procedure

; M5 r" \5 n! P- r; H# c        // Ring0代码
        Ring0Proc:
        PUSHAD
        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
. F/ `$ g1 J8 X( P& o' C- {' R        ADD DX, 7
        in  AL,DX
+ S$ c% O# ]: {; T9 A
        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
3 }: V0 A2 m6 H' F1 L        CMP AL,0xFF
2 Z7 ?; L9 b, b+ I9 t* j        JZ  LeaveRing0
        CMP AL, 0x7F
* s/ z, b% i9 H/ e% X        JZ  LeaveRing0
" j$ h' e( M8 u* E
        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1
9 d& ^1 b0 y) Q9 {
        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
        CALL SelectDevice
. ~0 c, Y$ T; v% J( F
        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
        JZ   LeaveRing0
: O' Z7 G" C# {# V% `
5 g, p) [# x! {1 u: A+ ~2 A1 f! O: ~        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
  f  s1 a$ @' ~7 U& w        CALL WaitWhileBusy

$ I; W4 s* I; ^        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
        JZ   LeaveRing0
3 u3 p% ?0 ?. J% g  l
        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1

        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
8 W. z: T+ c& a9 @; {2 p0 [* r        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
& q% a# N/ t7 v0 [  H: I        CALL WaitWhileBusy

        // 检查是否出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
" b; o9 p" K+ y
        in   AL, DX
* }) A, I7 w3 e
5 @* C6 J. V/ Y; K6 D" c        TEST AL, btBit00
% r0 M" Q% q0 T! k( t$ q; l        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
; @3 R4 W/ f! l) h- n4 n# N4 W0 h3 [        CALL WaitWhileBusy
0 ]: _; l! P8 E1 m3 s4 k6 L        CALL SelectDevice
$ t9 {- v( _7 u2 f; i        MOV  BL, btAtapiCmd
+ L3 s. F$ w& U1 O2 d3 C        CALL SendCmd
5 p- Z. y5 ]3 T1 p        CALL WaitWhileBusy
( j+ x, l  M# ?8 E; J! n
        // 检查是否还出错
        MOV  DX, dwBaseAddress
- t7 B3 u. v6 w" ~& y1 o        ADD  DX, 7
, ?% b/ G+ x7 a4 ?        in   AL, DX
, j" H8 s& z6 @/ Q- `9 R9 p        TEST AL, btBit00
# g& {6 d% G0 Y3 p) ^        JZ   RetrieveInfo   // 没有错误时则读数据
/ a2 f8 T8 W1 Q# B. X+ A& r9 l        JMP  LeaveRing0     // 如果还是出错，直接返回

& Q  h9 t5 i3 z7 |' l        // 读取数据
9 Q- z4 Y$ p# S1 M; F        RetrieveInfo:
2 v( e3 E5 S% _" j
& ]3 }, z) |, s" o        LEA  EDI, wOutDataBuf
# M& O8 G9 H. g        MOV  ECX, 256
        MOV  DX, dwBaseAddress
' h3 A$ m6 S2 N* H+ q+ a        CLD
6 \: u5 N  c  |) X8 r
. j/ K3 u6 j4 s& p. x        REP  INSW

        // 退出Ring0代码
        LeaveRing0:

        POPAD
        IRETD
% W/ B$ l: e% F; y8 h' R
  m% w- b1 r, j        // 激活Ring0代码
* J, V/ \* m3 P. x1 w+ F        EnterRing0:

        // 修改中断门
        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
4 b+ A8 J6 Z$ p, I/ H8 ]! W5 g. u        ADD EAX, nHookExceptionNo * 08h + 04h
. d8 F2 T4 j( J: R! R        CLI

) U- o5 N6 @+ R4 e. @        // 保存原异常处理例程入口
- M2 @% B( z6 x) D1 C( W; s        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX
0 g+ }1 h3 S1 O; M
8 E2 {4 p" X) Q% x+ w) p% y+ h3 u        // 指定新入口
        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
* S$ O  g. J/ `8 O# t# Q) H        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX
7 C+ ~( v% y% K$ ]
        // 激活Ring0代码
! p6 W3 c# g9 u3 j* S; m5 G        INT nHookExceptionNo

( t' ]+ k' v* N' Z6 X! P        // 复原入口
5 W& x" ]! N7 f! Z" z        MOV ECX,dwOldExceptionHook
* k3 J! O' i' C/ m; L        MOV WORD PTR[EAX-04h], CX
6 f" [. C: f  ^, s2 N        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
        STI
    }
( k# n  f( J8 a9 e  E& t0 I    if(!bIsFirst)
8 A# B9 K4 a: O& b- @. M    {
        bIsIDEExist  = (bool)btIsIDEExist;
2 B. g1 h" _2 P; c' M& {        bIsDiskExist = (bool)btIsDiskExist;
' n: f" n4 y/ b        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
, [; T# M1 S2 B    }
6 B/ q7 v. S5 u  S* Z' h( X7 Z}
1 {1 e6 I, \. j5 }. J2 z//---------------------------------------------------------------------------
, F4 p/ C2 m5 I& A; g7 Y// 调用方法：
; ^$ Q$ f2 Q4 U. w  m5 Y, Mvoid __fastcall TForm1::Button1Click(TObject *Sender)
{
  ~. O' p. d" W    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
3 b' J' \& K8 R6 x% v0 B/ |% }9 W+ {  I; M}
( B. n+ F7 L) ]/ |