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

天云上人

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

1. 
   ' z; m) S5 v, N$ F; H+ t# V
2. #include "StdAfx.h"
   - N: ]) P! S! Z
3. #include ".\puiddisk.h"
   " i4 }. g( [; C) g' z
4. #define _WIN32_DCOM
   
5. #include <iostream>
   6 D3 v0 l1 O0 N1 s5 {8 z6 E$ e, ~
6. using namespace std;
   6 V/ i- `+ n8 c/ b, d, s- W7 p
7. #include <comdef.h>
   
8. #include <Wbemidl.h>
   
9. 
   , `* F, k# j1 H- y  C# p, a
10. # pragma comment(lib, "wbemuuid.lib")
    / ]$ M% J2 \, S; Q
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    % @% @. k% O- s$ E/ ]
13.     GetInfomation();
    7 V7 ]" }) L5 K' o
14. }
    
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    9 c( i6 U% n. h2 A
17. {
    
18. }
    5 D+ G% _7 E1 x% F
19. int CpuIDDisk::GetInfomation(void)
    0 B7 m3 @" S* n1 S& L" f% Q
20. {
    1 W8 G7 c( q/ I" o" D
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    " Y; j( M4 O& X; l# F
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    4 v1 u/ b: U& q! t2 @
24.     if (FAILED(hres))
    
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    - D1 J9 Q, l6 B6 n- H* O; L( c
27.     }
    & n4 h6 l8 T' ~) E' H+ d" q  K+ ?
28.     //步骤2：不是必须的，COM只须也只能设置一次
    8 Z  l: R1 N5 G# R
29.     //Set general COM security levels
    4 z* ~) Z# X" R& \) L3 M9 N
30.     hres =  CoInitializeSecurity(
    4 v5 D: Y* i4 M$ s
31.         NULL,
    
32.         -1,                          // COM authentication
    7 J7 N( k# Y3 e" c
33.         NULL,                        // Authentication services
    & ~# B5 r1 Z- @7 N# D  ~, D3 l! F
34.         NULL,                        // Reserved
    , N. v9 a9 I) Q9 I# G- s" R8 [+ |$ ~$ Q
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    , q' ^; k% m2 i: h0 N0 j/ V0 j
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    ) m! Y* T) C  [" S4 h$ I! w
37.         NULL,                        // Authentication info
    2 S7 F: ^8 ?% }0 E: \2 L
38.         EOAC_NONE,                   // Additional capabilities
      `( ~, \$ ~9 H; z( }9 G3 e5 c, Z
39.         NULL                         // Reserved
    " X. y8 c0 ?' O% d. w, H  G
40.         );
    2 W; r" n; K9 \9 K5 h# w% L% z/ U
41.                      
    ) J! v4 ?( ?0 m" ]
42.     if (FAILED(hres))
    
43.     {
    
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    ; \4 d# x+ L( Z: _1 F- f+ Z$ G: r
46.     }
    
47.    
    2 u& \& d# Z7 @/ g5 Z' K
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    + {0 M$ m: J9 S5 z( R
51.     hres = CoCreateInstance(
    7 o: }& A7 B$ S! ?2 p& w6 r
52.         CLSID_WbemLocator,            
    
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    - T1 P% R% x/ H7 @/ `- w+ T
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    
57.     if (FAILED(hres))
    
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    
62. 
    % U/ ^& }2 k- S/ s% D
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    + S9 U, z' ]) Z
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    ( f- ?  n  y& n* _
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    ' h5 J* b2 @1 T9 a& m: K; A/ J
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    / W% D# S# P0 P( h5 C
69.          0,                       // Locale. NULL indicates current
    6 h/ S  ]5 H/ x6 R8 q! V0 \8 Y6 `( f
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    0 s2 k. h1 ^/ ^1 U9 G
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    - K: p8 k' B! n* L0 \+ V) n4 r) F
75.    
    
76.     if (FAILED(hres))
    
77.     {
    5 W0 ]: |0 h+ P( p# P
78.         pLoc->Release();     
    2 E6 c1 J3 E/ p# @: }2 B
79.         CoUninitialize();
    , H/ z3 G1 |' P1 a: J% q" M
80.         return 1;                // Program has failed.
    
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
      ~. v+ r9 c0 b8 W, f0 f& r
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
    3 m+ K1 q9 H" r/ s! s6 U
87.        NULL,                        // Server principal name
    
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    % ]/ J. d9 g4 u! J
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    ! X  X1 s1 s( \/ @4 n# R
90.        NULL,                        // client identity
    ! y) T& ?2 m$ S8 [) b
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    
93. 
    
94.     if (FAILED(hres))
    ) I$ F- c4 h- @: H7 }
95.     {
    ! @9 b2 c- k. P# M; @' K
96.         pSvc->Release();
    
97.         pLoc->Release();     
    
98.         CoUninitialize();
    ; e" L. F+ C) {: M! A9 z, l( X
99.         return 1;
    
100.     }
     ) F5 j0 _2 j' P) G
101. 
     & ^( y& d( X( R# i3 @
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     - Z7 H4 ]8 i+ D* b: x
103.     IEnumWbemClassObject* pEnumerator = NULL;
       V' d8 A+ g- P1 k) I
104.     //计算CPUID
     ( X0 ^' u9 k' C% \2 v, m* B0 z
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     ' W8 [) ~: J8 d+ V  B
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     - J5 S3 p5 [" C9 S
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     5 Z  K3 p! H/ P1 T+ t
109.         NULL,
     3 h3 h1 |+ g% h
110.         &pEnumerator);
     ( Z* ~7 E5 w* g; M* V! R+ D6 ?( A
111.    
     2 H, s. v0 Q& y0 ]# ]9 g
112.     if (FAILED(hres))
     : }" _7 H  C* X  \# W  m6 Q8 q
113.     {
     / u" @" `# G8 ?0 _4 ?
114.         pSvc->Release();
     7 a$ L8 T7 q% d* W; s
115.         pLoc->Release();
     & a2 |2 L$ P! ^
116.         CoUninitialize();
     & u. I6 @! q* m: [+ a) K$ A
117.         return 1;
     
118.     }
     
119.     // 步骤7：Get the data from the query
     ( J% f& Q# S& K0 H% n6 }
120.     IWbemClassObject *pclsObj;
     ; M* O$ [4 p# E+ }2 T5 R$ j
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     
123.     {
     , _. U0 K5 L& v$ l0 }8 X3 u9 }
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     0 n1 X- \4 v. Z& k* D! f
126. 
     
127.         if(0 == uReturn)
     0 g" o8 w) m9 A0 G. ]2 w: c
128.         {
     
129.             break;
     ) i$ u1 b+ U. _+ g! I
130.         }
     
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     ( x3 T+ }) ]7 _* A, m. z1 H( f
135.     }
     
136. 
     
137.     //计算硬盘系列号
     ; o( E) A9 L5 u
138.     hres = pSvc->ExecQuery(
     0 N3 y  a; I$ D1 f
139.         bstr_t("WQL"),
     5 Y  Q4 D" E. n$ r
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     7 P/ v; R/ F% M# i) v1 O
143.         &pEnumerator);
     
144. 
     
145.     if (FAILED(hres))
     
146.     {
     ! B: E( V2 N, j; ^+ b
147.         pSvc->Release();
     
148.         pLoc->Release();
     6 D/ P1 X# `8 }% o6 M% u
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     ( ~# \6 w) }% |& M  ]- i
152.     while (pEnumerator)
     % Z0 T1 U& Y' s6 |& B! {) B
153.     {
     , e* i( B% L: P5 e1 p7 S! e% ]) C2 v8 V
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     / b8 h' u/ |2 }& {
155.             &pclsObj, &uReturn);
     
156. 
     
157.         if(0 == uReturn)
     3 C# S3 m; {5 ~2 q! j% Z5 j+ a
158.         {
     ' ~1 [% k9 Q1 ]; u1 R4 f3 \
159.             break;
     
160.         }
     6 y: k5 w* |4 s1 s! O9 s9 v/ v0 c
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     ; U; D, c5 A5 F% \) f& W. Z3 R
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     
167. 
     ; `# q# s/ h& q& P  t# |7 w# `
168.     pSvc->Release();
     5 Y' ]* H  O" X% t
169.     pLoc->Release();
     2 J4 k9 W! {1 Y- L
170.     pEnumerator->Release();
     % \. Q  {, B7 Y2 B9 J  v% a! m
171.     pclsObj->Release();
     " S8 ~+ V6 ~7 K. _( M3 E) ~6 C( c2 L
172.     CoUninitialize();
     ; T5 G0 V4 o8 Y# |$ Z: b4 T( |2 W
173. 
     
174.     return 0;   
     
175. }
     

复制代码

天云上人

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

#include <WinIOCtl.h>
, Y1 s9 D. D" s. F. f, v8 M3 ~#include <stdio.h>

#pragma inline
//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
" _, a. q' q0 V( S, R) n- c: M#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
6 Q8 h+ V$ C& o2 G5 S: ]#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

' b& Y$ W, `$ i+ r4 `const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

! U6 X+ g0 e* `/ ~, fconst int MAX_IDE_DRIVES = 4;
9 U9 o6 u* C8 B, Y8 Q# o
// 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, C: H! x7 _% M0 }+ H8 gconst DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

typedef struct _SRB_IO_CONTROL
) n  D8 g1 ?& `# [- r  A% A{
1 w% A2 i" ^& y2 C" V, M; ?+ J    ULONG HeaderLength;
    UCHAR Signature[8];
    ULONG Timeout;
    ULONG ControlCode;
+ i  P% X& ^8 \( c    ULONG ReturnCode;
$ G; c1 `) ?$ R" ?1 Q1 W5 `) O    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
3 H0 H) }7 i0 F# u7 |+ e1 q4 u" E) m
* |# k; e# D  e; O5 q2 N, b" x// 读取的主函数
2 s: U, O# Z) x4 H: W0 b9 ivoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
# d1 i1 I+ v, F- K7 }
* A  B6 H! C' p9 f// 辅助函数
8 D: R) f1 Z- Q" _$ Y. x% lchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
* J" u- D% M4 Z5 s5 |; Svoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
+ D+ e& u: Y! s        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
! S8 M. x- x1 p7 l5 `% j// Windows 9X函数
# z1 _6 z9 o4 f  w0 d( R) S3 j& Q' r, }void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
$ B2 ~' }, Y0 e. O1 c0 w' ~        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
4 n  c7 L0 Y9 O//---------------------------------------------------------------------------
// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
- U' J5 g2 Z3 c% w; s' ]{
+ x5 ~' k9 W, B5 L; E- K4 l. z8 T    switch(Win32Platform)
  V/ P6 v$ z6 C    {
8 s4 j8 E3 V' C5 g        case VER_PLATFORM_WIN32_WINDOWS:
$ ^" j1 S8 J# Y! r  }; ~            ReadPhysicalDriveOnW9X(pSerList, pModeList);
" t) O' j% ^' Q/ m5 d* V            break;
& q& }) g" f0 R* x5 A- i        case VER_PLATFORM_WIN32_NT:
- K% z+ Q8 X# T/ @+ m6 F            ReadPhysicalDriveOnNT(pSerList, pModeList);
3 E0 \  W) \& ~+ _0 d            break;
. R- h' e# X7 m8 I, y& b3 u        default:
            break;
    }
/ h& [2 n6 i& @5 i# s+ v1 q% A}
//---------------------------------------------------------------------------
! t1 ]1 i$ J" ~+ e$ Q: }9 M* ]// ConvertToString
" L6 q7 P, R' Dchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
! k1 k  W+ j; @* F{
: V: f1 n, l# p; n9 D    static char szResBuf[1024];
    int nIndex = 0;
    int nPosition = 0;

; U0 O! a- U6 R  ?1 `" q* f    // Each integer has two characters stored in it backwards
( y, m) R8 \( u: O7 R6 q    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
4 M- C; p% m# s        // Get high BYTE for 1st character
* x+ r* B( r6 Z# O$ i% I        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
, |" u$ l( J6 m- T7 R4 a' Z! j        nPosition++;

( W$ _6 e2 Z/ U( f        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
( Q& O1 b7 g2 F" y) \. b    }

! q+ w7 {& T/ Q! O    // End the string
0 T7 s: `0 _, B5 P    szResBuf[nPosition] = '\0';

    // Cut off the trailing blanks
% B6 i. u3 ^1 N0 f" N9 E    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';
, G8 d& a9 L8 t- y
/ G% @' Y+ v* X/ K/ M+ v; }2 H    return szResBuf;
/ D  d1 O/ {8 c5 L1 K; P4 R: J1 Q7 a}
; N! R( s! [1 H/ e7 s$ M  p; f//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
. a( M! c, N8 H7 v6 B5 M$ lvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
    // 输出参数
0 ?! b: \" a) j4 D8 R! J    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
+ q2 I$ ]# Q+ }1 t
) t' i2 s7 {, c) J    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
, b: u, z$ w, g8 H# G) I! Y        char szDriveName[32];

. O+ `" V5 L  T; m        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
8 Q7 c2 ?+ X( T# P        hPhysicalDriveIOCTL = CreateFile(szDriveName,
& ~6 Y" Z8 `: n4 ^2 s3 G* J                        GENERIC_READ | GENERIC_WRITE,
/ C5 d4 U5 g5 G1 {' v                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
, U6 [7 e+ _% s" y5 g' {                        OPEN_EXISTING, 0, NULL);
* k5 d+ a- e' Z2 X% J
) i: F1 L1 m: v0 j' O7 V        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
7 U% P: q8 t7 U8 _; U% }        {
% D! I6 a- X3 O. d$ u& y            DWORD dwBytesReturned = 0;
1 ]  \5 X$ z% ]9 Z5 M            GETVERSIONOUTPARAMS gvopVersionParams;
' V/ M7 A/ W) J" z
            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
/ l% h) F5 R* T! v  H& H' o0 t+ i                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
0 o: `' B. f/ A* {9 E- a& _                    &dwBytesReturned, NULL))
0 l6 Z' q" L, s- O& l/ v! J            {
                continue;
, d& u1 U% W7 U1 @" p; t            }
& z0 f) ]) D# j# [3 j
6 @& `# I7 N$ C' F% s6 `* e            if(gvopVersionParams.bIDEDeviceMap > 0)
& v( X( G$ c" u" {; z. C( C4 a: Y            {
                // IDE or ATAPI IDENTIFY cmd
  f0 P4 C) l. {# @: H+ |, z- ]7 t                BYTE btIDCmd = 0;
6 b6 z* F9 y% ]  l) G* q% ?                SENDCMDINPARAMS InParams;
2 K- S9 h- p, }5 b) k' t- Y                // Now, get the ID sector for all IDE devices in the system.
                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
6 [4 c( L. E0 R$ i! m                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
; X& A; ~' h" O. H) O! X6 [                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

                if(DoIdentify(hPhysicalDriveIOCTL,
' n$ @" `  i9 J- W                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
6 y$ o2 S  R( _* _" M                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
5 h% J. G. G- Y, L/ I, E                {
/ e; Z5 m9 U$ Y: V2 c! |; f                    DWORD dwDiskData[256];
6 T- d$ H7 t' t1 O, X; t( e                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
2 b% o7 W( s9 \0 x( z                    char szSerialNumber[21];
/ V$ s. U- l* p/ ]                    char szModelNumber[41];
) ~5 a+ W; Z, G# o
                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
' |4 {5 p, N; y& |                    for(int i=0; i < 256; i++)
+ m4 G6 \7 x( G                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
* F3 E& \5 S/ p4 n/ J                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
" w3 l4 x+ |# |$ s' e, g0 u! d                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
. ^1 d" w) j! m$ r1 s. J  u
                    // 取模型号
& M9 a; w, P' p! E) }4 R: |+ A                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
! F( j7 `1 G4 U0 y3 Y+ x
: ?, F. r8 z. R& |5 y7 \                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
' n9 C& r' Z% [) H: k. L( J, c4 m                }
            }
6 e; b( r# Z9 k* s            CloseHandle (hPhysicalDriveIOCTL);
! k, v5 B2 h6 O$ `" E: R        }
    }
& \3 C" m" {! {1 ?  U$ r1 k}
' {/ p) ^. ]$ Z5 v) ^//---------------------------------------------------------------------------
4 P4 t' ]# b( A/ ]: `// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
7 K1 j6 i# M+ }& l& |0 f. W7 H              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
7 @+ S' k. m6 M! l; G{
- w- _6 O7 V6 e  G0 t. }    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
) ]0 c5 ?, P% w    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

; @* F1 k$ D; H- H    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

/ r4 b" `) O) P! p, R& c    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
1 f$ [. T. q. [. P% h$ c    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
1 ?+ r; A8 h  g/ W8 ?
    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
- z- d, |' n* R) C! A$ R           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
' v' A% v. D, r# o/ Q2 U2 r//---------------------------------------------------------------------------
  x7 a' ^  U, y! x" _// Windows 95/98/ME 代码
) s6 h) C" W# Z7 ~& A2 H- X//---------------------------------------------------------------------------
" {1 L% j3 v1 S& J2 g' z// ReadPhysicalDriveOnW9X
1 Z2 l  a- C1 f4 t: R$ \2 Q& Vvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
# B1 U' o) W5 o1 N8 R2 s    WORD wOutData[256];
$ a- V$ B# W. c2 x; T/ m5 E5 r! Z' [    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

. C* X5 X" m4 L/ J    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
$ Y: y# K  L+ _# v% b& I    {
+ e0 ?7 M2 }" h+ p0 ]9 c) O' [        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
        bool IsDiskExist;

! _) E1 s4 E5 c9 ^        switch(nDrive / 2)
; Q; w3 a3 K% x7 D! r( }! d' E        {
; y* S$ J3 T* H& n- ]6 o7 `, x            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
4 d5 b* }1 A8 v) W7 \            case 3: dwBaseAddress = 0x0168; break;
        }

6 K2 ~0 ]% n/ C' c% J        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

- ~' l5 [: o2 g        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
; n. `6 g8 s; M! K) I                bIsIDEExist, IsDiskExist, wOutData);
    }
9 h7 E1 `3 S0 o4 ?! X0 v
6 R  \" N8 B) @# \    // 开始读取
$ u( k% h) s0 y% c    for(int nDrive = 0; nDrive < 8; nDrive++)
& \6 X2 }; P4 _5 P5 b4 D9 \3 h    {
7 o6 X2 H; C; p- l  e7 T0 j5 S        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
" z+ {6 |5 R' k# g/ v        bool bIsIDEExist;
5 |1 S; A& c& c! V        bool bIsDiskExist;
        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
1 N2 H3 Z. X5 |  H3 ~; [/ K+ L            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }

# ~8 x' D. W% i3 _5 ^" w        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
& |" `0 T' p% z3 A* h/ n+ p! b6 B
        // 进入Ring0
4 ~1 c2 Q* g4 Z0 ]5 Q/ f% T        bIsIDEExist  = false;
        bIsDiskExist = false;
1 l3 H: |2 ^- {5 v1 ~        ZeroMemory(wOutData, sizeof(wOutData));
7 {- p- T1 g% Y- q6 f
        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
2 U1 ~  j* U0 J# A' }$ P( L$ L                bIsIDEExist, bIsDiskExist, wOutData);

" U8 W6 x8 i/ p2 d9 W6 i        if(bIsIDEExist && bIsDiskExist)
        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
7 ~" s; S$ \$ Z- G- H; `            char  szModelNumber[41];
8 x& Z, C; y6 |( o' H  {
            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];

3 D7 ^( ]' {1 u% }9 y            // 取系列号
5 |8 s/ W3 p/ O1 N6 f            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
% A: F8 S' r0 @3 ]0 j4 p
1 d# k- U# U7 Y, q: ]& ^            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
        }
    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
+ {) I- D% z7 ?  h! T//---------------------------------------------------------------------------
9 b# h  Z3 J6 W9 j// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
" n# `# |$ T- g$ J7 g// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
8 l! B& ~. M! ~( J3 ], ]- k; D// ReadPhysicalDriveOnW9X_Ring0()
//
$ T5 P+ W# T) w// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
2 c0 |% G& J2 f5 a7 k3 g2 l2 o2 L//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
, j3 `- C% v3 K9 q+ F1 p, v{
    BYTE  btIDTR1[6];
5 |  I) Q, W) J  G' ^    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;
, g" e1 Y7 }, B
5 U1 l+ o) y# I1 [& {/ H( ?    BYTE  btIsIDEExist = 0;
6 X9 f  y4 B( O9 a    BYTE  btIsDiskExist = 0;
+ l. g' C' e0 P7 N4 @    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;
6 W# K& a4 w, e( I9 {" s( Y
8 a& F; H4 z6 {5 _0 z6 c    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
2 [5 c3 S* X! y; {' J) T8 C& Y0 \    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
. c; X8 p: m3 ^) g0 Y8 V    // const BYTE btERR  = btBit00;
1 [. j# @' S' M    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;
8 B) p# m& j6 t+ f% p
    __asm
    {
        // 必须先执行这条语句
3 l1 {4 |' G7 ]- p        JMP EnterRing0

- f3 Y" b: U$ H: d        // 定义过程
* _; T+ R0 }! x0 m% r+ D0 W        // 等待IDE设备直到其不为忙为止
* H! _4 |# E% @* S1 f        WaitWhileBusy proc
  z* x" F6 R0 W4 ]) _7 j8 H6 @  t
) d% K1 q; @. f3 K7 g        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
        ADD  DX, 7
0 P3 X5 Q3 p. k3 M: ^, q
        LoopWhileBusy:
9 R" L! p9 l' N  @3 c3 N
        DEC  EBX
7 Z% K% Q! P9 O8 ?- `, G- s        CMP  EBX, 0
        JZ   Timeout
        in   AL, DX
6 _' i- c) w& W2 {/ G        TEST AL, btBusy
        JNZ  LoopWhileBusy
        JMP  DriveReady
/ J' t) a4 o& {+ r5 H! t+ j6 a
        // 超时，直接退出
        Timeout:
        JMP  LeaveRing0
        DriveReady:
; |/ B. D# k  A8 Z' V- z6 i        RET
        ENDP   // End of WaitWhileBusy Procedure

- Y' ]2 w& L# |5 S# N: K        // 设置主盘和从盘标志
4 N8 ^' Y! D3 z/ b; Y        SelectDevice proc

8 a  d4 J  A2 p) Z        MOV  DX, dwBaseAddress
$ L, z, F# }, |$ |        ADD  DX, 6
' P) ?5 u: b- C. D$ G% n4 j) }( _        MOV  AL, btMasterSlave
* Z2 m1 G5 z( {3 d
        out  DX, AL
5 j  K& n4 [2 @( F; w5 t        RET

        ENDP  // End of SelectDevice Procedure

        // 向IDE设备发送存取指令
        SendCmd proc

        MOV DX, dwBaseAddress
! ~. O$ A% ^4 K% m* t        ADD DX, 7
2 K9 b$ b2 z3 k( M- p% l3 A        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
# m! f9 A# j- P: q        RET
( I. p' O" h* C; P2 ?( [' x* |9 z, U        ENDP  // End of SendCmd Procedure

        // Ring0代码
        Ring0Proc:
        PUSHAD
7 Q( K1 Z/ D6 E% S" l6 J  l        // 查询IDE设备是否存在
4 O$ P  ?" L: {  I* i        MOV DX, dwBaseAddress
        ADD DX, 7
        in  AL,DX
# D: s1 T% j! n
; m5 O3 S/ R) o        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
! Y- r, h& n) q* e        JZ  LeaveRing0
- H' [/ U. H+ F- R2 V/ I! m        CMP AL, 0x7F
  C) K- K& K: R( B; W( P& _$ I        JZ  LeaveRing0

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

$ {( v. Z$ J) _8 @) z* o6 u7 U! K        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
6 H3 L+ u1 w! |  m3 T% F        CALL WaitWhileBusy
- Y8 m* K. |7 s. H& q6 _$ c, L/ P& i        CALL SelectDevice
1 v" B5 ]% p5 F8 S
        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
        JZ   LeaveRing0

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

8 i* f9 n* b* s# q4 |8 C        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
        JZ   LeaveRing0
  p  j& _: _8 M1 q3 G: V7 D
        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1

        // 发送存取端口命令
% M6 y8 W- G, ^/ L, `        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
- N9 _6 u5 e  a) ^( e5 |6 Q( Q- k        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
$ U: {9 q" @2 F% v# a, I        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
; J  s8 w( g, r1 e) w& t" |        CALL SendCmd
        CALL WaitWhileBusy

: ~( P2 b9 Z! O1 B        // 检查是否出错
8 x* u8 T! x- |+ Z) v$ W6 ^' p        MOV  DX, dwBaseAddress
        ADD  DX, 7

        in   AL, DX
* [. y/ X% v( ~3 h! A
6 I: {4 a5 Y8 N5 u6 v4 G        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
# {. j4 l6 z9 J- {1 N7 Z; {) E
        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
- J. o9 {- V7 D+ M  q        CALL SelectDevice
( |3 x; c2 s! S/ q6 M) L        MOV  BL, btAtapiCmd
        CALL SendCmd
        CALL WaitWhileBusy

* F) C2 h* R! y$ l) |$ h        // 检查是否还出错
        MOV  DX, dwBaseAddress
: O5 [$ u; C8 O/ X: l        ADD  DX, 7
+ X. ^/ ?" O5 l/ m2 S# s/ r        in   AL, DX
. v, d1 t) T! @" o- i) o" y        TEST AL, btBit00
3 {6 B7 `5 c' u$ `& t4 a        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回

        // 读取数据
: [4 e1 B% C  F$ \        RetrieveInfo:
6 n' p) k4 H! I" j* J9 l6 q2 L/ v
! M. |0 r! N- I        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
* D/ u. ~& U5 m, H& s6 s        MOV  DX, dwBaseAddress
        CLD
* j9 j2 w6 x  ~
        REP  INSW

! V7 i% k. I3 r" [        // 退出Ring0代码
4 ^) B, S" w4 z( N! ~4 l        LeaveRing0:

4 _& r8 ~6 n: i. d        POPAD
        IRETD
0 Q0 J6 n6 C# P* }
        // 激活Ring0代码
, [" @, V& n6 X# L+ A/ F% D        EnterRing0:
7 u$ u' v# @3 \! k# m/ X1 y
  N7 w- k* n! W& c8 h, J& h0 P, G. u& w        // 修改中断门
        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
9 J3 R7 d! E5 R) w- L3 P        ADD EAX, nHookExceptionNo * 08h + 04h
3 V" E. M  ]; T9 P3 s" A1 r$ M        CLI
2 n$ @# Z# |4 M5 ]0 H6 u
  ^, x  S; g' v, I( z* s# a4 s        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX
& _4 k. C  h% T
# x+ g; J. q3 O: H        // 指定新入口
        LEA EBX, Ring0Proc
/ z8 C; m: L" ^) {9 u* H0 ]        MOV WORD PTR [EAX-04h],BX
( W0 a& @8 Y* ?4 ?- `) t2 g        SHR EBX, 10h
4 f3 \% z9 v  o( Z. ]7 f- h        MOV WORD PTR[EAX+02h], BX
% D& O  i3 C. v/ G/ y% [
        // 激活Ring0代码
8 ^& \0 |- c# L' H% n6 o, n        INT nHookExceptionNo

' v) [" V' H6 U$ i/ U" ]        // 复原入口
: f1 K7 i( R. L- u# ?! R# l        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
: c/ i8 K8 I# K1 o- f" z0 X- v        MOV WORD PTR[EAX+02h], CX
: E- A' h0 G7 a  J) Z# c! O9 ^        STI
; `) S7 c" S$ K' S  p    }
" `( l% e/ j7 _+ L6 ]5 y    if(!bIsFirst)
    {
; T+ i4 d9 d6 w7 t        bIsIDEExist  = (bool)btIsIDEExist;
3 `+ `! a) o5 p; |7 S        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
; v$ p: J* D4 _    }
( q* ^/ E1 z# X2 R}
//---------------------------------------------------------------------------
// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
{
" S- b) A- ?5 t    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
- D) U0 C0 p5 L$ {/ r}