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

天云上人

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

1. 
   8 S* \0 U5 Y1 A$ g, ~" S7 L* |! f
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   & A$ x. c( m" {. s
4. #define _WIN32_DCOM
   
5. #include <iostream>
   . o! P+ N1 A( v
6. using namespace std;
   
7. #include <comdef.h>
   ; c- ~% ]. B$ Q7 |
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    6 F5 s1 @* Z& ]8 K! i1 }
11. CpuIDDisk::CpuIDDisk(void)
    ' \: a& _' C! B" Y4 ?; X1 n
12. {
    + |/ B' k% g' C8 V
13.     GetInfomation();
    4 }( M# W3 H) O* ^- S! C: |* V7 A
14. }
    % B+ R0 O7 F# P5 g: J2 T
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    8 w' v: o* u2 t  C: @! C7 i9 {
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    1 o8 c* e( K+ W( w# o6 m7 g
20. {
    
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    / G$ d6 y' N& H! k- c2 Y
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    3 y3 b9 w9 \7 u9 X' p9 v4 H
25.     {
    $ u' S& q9 L  ?$ y  R" T( `
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    $ a3 W, ?5 g) X& J6 D4 V5 c: o
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    
32.         -1,                          // COM authentication
    & d" J" x# o8 V+ y
33.         NULL,                        // Authentication services
      W, w* U$ i6 ^+ i( |( y& h
34.         NULL,                        // Reserved
    # K! i) ~' b0 E! g. f2 f/ Z) O
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    1 E" B% r" K! Q
39.         NULL                         // Reserved
    9 t7 v- q; z0 ]+ e/ {! E
40.         );
    2 o: }7 T+ Y6 d5 V
41.                      
    . l. g$ X, z4 v7 a9 g( I7 r9 h
42.     if (FAILED(hres))
    & D' p% l6 l6 [7 k- O6 s5 n
43.     {
      M' M: s" V( b: g. T
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    5 I+ w3 ]5 b+ T3 C6 H$ l/ K
46.     }
    
47.    
    7 s4 H5 S' w3 E- L5 D7 R. n
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    ( f- x$ ~8 E: x* Q3 q- C
52.         CLSID_WbemLocator,            
    
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    ' F* l7 I( K9 `
56. 
    
57.     if (FAILED(hres))
    ) v# p7 j& q* D& j: {( o4 Y
58.     {
    
59.         CoUninitialize();
    ( C/ Z7 |6 v, [3 l, y3 Q' }$ |) p- j
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    8 U$ u8 i( G3 K/ m
65.     hres = pLoc->ConnectServer(
    0 I. O4 d" e5 Q8 t$ J/ F- X
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    ; c, [3 q( g( h7 q; w- K& k  |
68.          NULL,                    // User password. NULL = current
    ) O: W5 x( c. _- p! O4 p2 }: c
69.          0,                       // Locale. NULL indicates current
    ! _$ p9 N3 N- M4 g, z6 u/ T+ b, T
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    9 \4 d7 @/ J9 Y, F# F8 V
72.          0,                       // Context object
    ) r. F* v: U/ q' D8 _( j9 R% b9 [
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    - e2 v0 i5 b; }- X
75.    
    
76.     if (FAILED(hres))
    - g1 Q( H% Q8 F1 }" w: Y0 e" K
77.     {
    
78.         pLoc->Release();     
    
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    : L( D' |1 D- x6 m. Y
84.        pSvc,                        // Indicates the proxy to set
    0 n" _/ B# ^8 H& ?
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    5 V- o6 j0 v8 h2 a3 b7 }
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    - p7 j+ E7 G4 I5 n( M% W
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
    : J! L$ B( L. F$ q* o% v: o0 Q1 I) y) c
92.     );
    
93. 
    ! `) T, B) N+ l  w$ _" H& |
94.     if (FAILED(hres))
    
95.     {
    
96.         pSvc->Release();
    
97.         pLoc->Release();     
    
98.         CoUninitialize();
    
99.         return 1;
    " S% y/ M; F5 ~" d! W
100.     }
     3 B, b' B0 ]9 l2 n
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     1 L# L# a, U; W1 I; c* n
103.     IEnumWbemClassObject* pEnumerator = NULL;
     & U' a! i- B. \9 V9 L" Q
104.     //计算CPUID
     % h7 X4 P8 k! Y2 j. I6 l% }$ l
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     2 x; Y" V, e- D. |4 ?, T
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     ; `9 D2 @9 t6 {, m! M& Z4 j/ r
109.         NULL,
     ( s% K/ w8 U7 o
110.         &pEnumerator);
     
111.    
     
112.     if (FAILED(hres))
     $ Z; Z% e  P1 _. E! Z) _0 \
113.     {
     + e) \' O& t1 {% f/ x2 j  X8 L, U5 L
114.         pSvc->Release();
     ) X; f, F2 _; K- U* |
115.         pLoc->Release();
     
116.         CoUninitialize();
     
117.         return 1;
     
118.     }
     # X* \8 R7 y/ s( s7 M
119.     // 步骤7：Get the data from the query
     1 m) C2 d6 d. ^% u. o5 D! n+ ]; A
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     4 ]0 x! h' V! ~+ L; Z5 T3 T' L) U
122.     while (pEnumerator)
     ) z( M! c8 M/ l# K* x) a
123.     {
     6 T: z/ m# y" K, x
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     
128.         {
     ; j/ n+ I( M1 `4 G% U' T
129.             break;
     & }6 U' W# G: c+ s% M8 ?
130.         }
     3 V  n9 T7 ]* B) ?8 u: L5 G9 u' O
131.         VARIANT vtProp;
     9 V$ x( M4 A0 n5 h% M
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     % \- N7 d3 E4 U) X4 T
136. 
     3 w8 C/ t$ o: ]
137.     //计算硬盘系列号
     % m% V! o5 w" b" I
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     / P0 D0 L$ r+ Q! i8 `+ r$ k
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     . e  `0 l, x( i2 E3 @0 S  u
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     2 u5 Z! @/ Y6 [  I$ R/ o
142.         NULL,
     + ~$ w, l9 Q* e1 @( m; N! N  N8 H/ o
143.         &pEnumerator);
     
144. 
       ]1 S: F3 J5 [9 E. r
145.     if (FAILED(hres))
     
146.     {
     
147.         pSvc->Release();
     
148.         pLoc->Release();
     4 C; w5 l# l5 Z3 V7 t/ W4 u+ p
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     
152.     while (pEnumerator)
     " k; R' e1 m$ v/ N- A$ w
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     , s) p9 J8 ^3 S& E9 F0 N+ F& w
155.             &pclsObj, &uReturn);
     
156. 
     
157.         if(0 == uReturn)
     
158.         {
     3 U' x/ x$ ~2 @. c1 |2 a% h
159.             break;
     7 Q, A0 I- ~3 j! k$ x' ^4 r8 k
160.         }
     
161. 
     2 \% o3 R" m7 w% \
162.         VARIANT vtProp;
     & t! P4 k/ c6 V8 D  K
163.         VariantInit(&vtProp);
     - l. |) R9 C  ~! t' Q" T
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
       a, ]) |  r" B0 t# u, x
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     2 f; X% a( l& U6 B4 A
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     / v- {1 [' O/ y. C  M) U
172.     CoUninitialize();
     
173. 
     , |8 H- F* I0 X: Z
174.     return 0;   
     % e+ u( {3 T$ ~' w) [
175. }
     

复制代码

天云上人

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

#include <WinIOCtl.h>
) l( v% A% a5 F; h#include <stdio.h>
. P9 n6 e( J( j) y, k
#pragma inline
. }7 v6 E2 b3 A) j/ h2 n; L% ]5 Z//---------------------------------------------------------------------------
. l% I; `: z1 \// IDE NT/2000/XP专用变量
8 G% a) x+ N7 x3 m8 P9 W% L#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
0 g" A5 @5 t# K: F" G; Q& Q# o#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

0 `( ~. K  T% `, D) e, Z: tconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
: M2 F( G* a0 w3 E; {3 L. Vconst WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
8 Y1 w: H$ j, ?# N
const int MAX_IDE_DRIVES = 4;

$ P+ f- `: n  z) ^6 s" ]// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
2 J0 t5 j  C5 ~: f' Q" k! [. wconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
% U4 Z/ J$ R- a5 J2 rconst DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
1 I5 h& o2 T" f; P* K7 f& ]const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
* }- `$ g0 O9 ]3 ]4 }+ H/ y/ U) [! `
+ V& I8 w- L. L% f4 `" r  C8 Q2 Atypedef struct _SRB_IO_CONTROL
. t3 S7 n: {! q# E' O{
8 U$ i  r, ]( |0 i0 Z    ULONG HeaderLength;
% g8 D8 L* l4 Q. M, r    UCHAR Signature[8];
    ULONG Timeout;
2 ]) B4 n( p0 d+ B' U* t+ Y* N- E    ULONG ControlCode;
    ULONG ReturnCode;
. C* j9 ?4 P0 S5 D    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
9 X. |' @) U6 }7 S6 |& w4 x' k
6 K3 z+ j- f4 [// 辅助函数
; |' V% ?1 R, Tchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
  R" M7 \' V! V8 Z# c: Q5 ~// NT/2000/XP函数
# m: O$ [, ~# R+ d* Fvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
) r8 U9 ~; o* g2 @# R6 f! y4 j        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
& m1 r" D1 A( N. K) D# a- T        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
2 ]# u/ X0 x/ e- V6 W' H+ B// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
2 V( m5 S* l9 qvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
6 y# P- u/ ]8 Y8 x1 J' N- ?
  D- x1 S0 `+ q: q+ }% q// SCSI读取函数(for NT/2000/XP)
  l/ A1 [$ ~4 \, ?, w6 d1 OString __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
8 g; _: m: h4 d8 j' t4 E{
    switch(Win32Platform)
4 p% F/ }! a9 R! M' D+ [1 A    {
/ s1 e4 B0 G7 _. ?  \1 K' b        case VER_PLATFORM_WIN32_WINDOWS:
            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
2 [% @5 W- f" e) o, D. t0 S% W! N        case VER_PLATFORM_WIN32_NT:
9 y$ T. c4 x5 p            ReadPhysicalDriveOnNT(pSerList, pModeList);
6 [7 g: `: Y+ B4 t            break;
        default:
            break;
1 u+ q% w* o$ k4 i    }
7 z9 h: A+ f: p% b+ b0 q# I7 m}
0 o7 U" ]1 I- S9 W//---------------------------------------------------------------------------
// ConvertToString
/ l3 e( K: s# K, ?7 Fchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
% q2 M( q- X' @, c8 ?/ q{
    static char szResBuf[1024];
    int nIndex = 0;
    int nPosition = 0;
! ^0 u$ {  R3 J' Y1 v" |
    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
  z1 g( u1 g4 [" t+ |+ C& {    {
, r2 R& J6 C8 d2 Z; N$ }        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
% f6 x+ o( A7 E, N        nPosition++;
. E' T8 h7 P% ?* {) P3 Q. N
; P/ a& t6 U1 a4 S& y# A) g( L, y3 |6 S        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
5 `$ k+ y3 k; v        nPosition++;
    }
9 P# Y- [" @0 @" ]2 m, f# u
2 |* `, J: d; u4 u0 d    // End the string
    szResBuf[nPosition] = '\0';
4 ~% i# x3 h7 ?7 d
5 a$ ~. ~, M0 a/ W6 H6 P$ m    // Cut off the trailing blanks
    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
- k1 L/ O2 Y9 b; d' N' [        szResBuf[nIndex] = '\0';
/ D2 p5 g, r) ?" }3 Q% a" B
/ |: Z) q+ P+ m: ]+ S0 o  \    return szResBuf;
+ y1 H) j- w2 Q+ q% P, L: R1 a}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
( s# p( }4 I4 ?0 [9 h! z2 @6 `- P{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
% L+ \$ h" `; z/ c/ l- n; w) d
, x, X( D# w0 q1 r( ]% h* I    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
! O/ \& g) O& z' w0 {# F4 P    {
        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];
/ V) g# X2 N1 o/ w! r/ @1 A: _
        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
4 W+ ]0 q- M2 Q" D) L3 T% `# J8 y; m                        GENERIC_READ | GENERIC_WRITE,
8 U( J: X/ V% D2 V) P                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);

        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
            DWORD dwBytesReturned = 0;
) W% P8 [; R( n1 Y0 S+ L$ T/ s$ e5 Q            GETVERSIONOUTPARAMS gvopVersionParams;

            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
( H! \/ X! u% L- @5 z% V/ ~                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
( T, W% z% n/ A3 J0 w9 H                    &dwBytesReturned, NULL))
7 U+ f; ?1 d6 Y! L+ c: r            {
; P9 |& [# P5 v# n                continue;
6 d8 Y7 ]: Z0 H. S0 I% n* d            }

7 B! M$ T3 I" g" [* t( `. N" z            if(gvopVersionParams.bIDEDeviceMap > 0)
8 K4 n5 Z& l9 V7 y' l! @            {
                // IDE or ATAPI IDENTIFY cmd
, [  B; q  _- ]                BYTE btIDCmd = 0;
                SENDCMDINPARAMS InParams;
5 K/ o, [4 v7 F7 y                // Now, get the ID sector for all IDE devices in the system.
5 Z) |4 b1 ~" I- h                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
" x+ X  h! v( v( V4 I7 i' ~6 Y. g4 L                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
: y/ ?: v+ M+ C0 ]% N7 n
' h. e2 x, s1 ~$ h                if(DoIdentify(hPhysicalDriveIOCTL,
, O1 P  {0 N7 ]                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
- j7 R  x" |2 k& S( {7 v( O                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
                    DWORD dwDiskData[256];
4 y* ?* }# \' v% k+ e$ C! {                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
; ]; ?2 r$ s- w9 M- @; R5 C& k5 O                    char szSerialNumber[21];
5 x$ L1 x; e# E- H" D/ X; a                    char szModelNumber[41];

" V1 H) v; b& w+ y" d                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
" ?4 d9 D, d$ F9 r2 z1 `' N( X                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
  p' D/ H# \/ V0 w4 L& c; h1 `
& ?: {" G6 j: {                    // 取模型号
% _% u0 a! v2 ?  S" T3 E7 ^1 @3 q                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
' K) d: A4 B* x, @) b. q/ ]
9 f: |+ r% ~: A                    pSerList->Add(szSerialNumber);
6 G3 L6 G" E( Q/ [9 r                    pModeList->Add(szModelNumber);
                }
            }
            CloseHandle (hPhysicalDriveIOCTL);
        }
    }
* P# g: N4 {& }}
, q" p' j+ `! o7 t//---------------------------------------------------------------------------
* k- W0 U0 p  J  y& ^/ ]  Y7 O) q// DoIdentify
- o9 a/ ?# {/ i( Sbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
$ M$ D8 X' Q) F6 X' ^8 d3 R# g              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
9 o! T" k' M5 T( d- j              PDWORD pdwBytesReturned)
{
    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
" u, H& _2 S% X/ t% K; J% k: U7 N    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

6 g9 P7 e% Y. l7 f" v    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

/ x3 Z( n% O1 R    // The command can either be IDE identify or ATAPI identify.
* y, ^3 l& a7 b    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
/ m, y) x4 C! w+ y0 H    pSCIP->bDriveNumber = btDriveNum;
4 i8 {( i4 I" e' R: V9 N    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
2 i  ]% ?$ g' \4 F
    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
2 Z( j( t3 K; e1 h           (LPVOID)pSCOP,
% K* U4 u5 D5 D* b' X/ B# e           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
1 z$ R1 T" z  F& `, B           pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
( ]5 f$ V) h3 I; ~// Windows 95/98/ME 代码
& `/ p' @) \# U+ a9 ?. b//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
* h; z' y9 O( O% p1 Avoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
    WORD wOutData[256];
& C8 v4 \8 }! ^) w2 B: S    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
6 w) g) `$ O  [! O    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
) G4 W/ W5 i1 K3 @+ r    // 避免蓝屏的出现。（期待高人能指出原因）
" o+ s# c' [, Y8 M8 c( k' e    for(int nDrive = 0; nDrive < 8; nDrive++)
% @! ]( d" j6 S" t    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
! P/ F. s! |+ L        bool IsDiskExist;

5 w1 M+ C$ x; \" g8 O        switch(nDrive / 2)
        {
( t6 ?) `- }0 l1 U1 N; \! K            case 0: dwBaseAddress = 0x01F0; break;
# p1 V% Z0 o7 N8 K% a6 c2 Z; o            case 1: dwBaseAddress = 0x0170; break;
7 V5 J6 ~) q0 `3 I% d) Y8 j            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }
4 z$ b5 [* ]. b
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

        // 进入Ring0
% l# d8 y$ b9 u9 P( O! N  g        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
) ?1 z2 F# s8 k; [% z& p                bIsIDEExist, IsDiskExist, wOutData);
4 Z$ I$ h% {; M    }
3 K/ X. G# R+ |+ b9 E
3 O$ L* b7 n' \2 n" b0 L    // 开始读取
3 Q7 K/ o) B) r4 N0 b    for(int nDrive = 0; nDrive < 8; nDrive++)
& l7 `& m4 p3 x& ^$ V. H    {
        WORD dwBaseAddress;
5 R6 f: [% w) T: K- [0 ^9 R# c        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
        bool bIsDiskExist;
- t/ m) z! V+ y* ~$ D& f1 _6 w  f# H        switch(nDrive / 2)
        {
2 y" d6 v' Q' L* a  C; Y( W9 }            case 0: dwBaseAddress = 0x01F0; break;
* ?3 v6 e( V7 V# w% g& a3 ~7 F            case 1: dwBaseAddress = 0x0170; break;
+ P8 G7 q- ?, K9 q: ^* l% h8 G            case 2: dwBaseAddress = 0x01E8; break;
. `( s4 r$ \# h6 a            case 3: dwBaseAddress = 0x0168; break;
' L/ I* Q9 B, n        }
8 I' U- `( {( m% T9 U
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

        // 进入Ring0
7 [, _# T9 |+ U' y        bIsIDEExist  = false;
) S5 @4 x0 t' Q, |2 ]8 R/ f! f        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));

        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);
0 G8 G7 @) d% I
. t. t0 C! x, f        if(bIsIDEExist && bIsDiskExist)
        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
2 `2 v7 @* o! p4 A* e$ A4 ^            char  szModelNumber[41];

- I; ]8 A' i/ Y( E2 x4 z' V3 r& h            for(int k=0; k < 256; k++)
  A' ]2 u# q5 W* Z& O6 m                dwDiskData[k] = wOutData[k];
  V# q& L$ T; h) o
+ F! |/ u  U' u* C  Q            // 取系列号
' h  {; O; v5 \. l+ s  k            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

& X. d8 b  l- c& N            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
7 V* W6 W1 Q8 g        }
8 }: [6 i; Y0 b    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
3 N2 b$ E3 J3 V}
4 c# l+ a4 N4 Q. X$ P( H9 H2 n//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
4 p; r# q$ u$ }; p# @& \; r// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
5 s* B# \" F/ j) B) Q// ReadPhysicalDriveOnW9X_Ring0()
$ D+ |( `0 \9 [; N* F$ S( r; F% [//
3 b; d# d  C/ W5 G8 k8 }// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
* i- @, |( N/ L// btMasterSlave = Master(0xA0) Or Slave(0xB0)
  f2 J+ D) L. n, |$ t9 W//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
4 N7 g  e( r" t. P2 }1 N        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
    BYTE  btIDTR1[6];
2 Z7 H4 X6 D2 D) W+ x- P7 k) A/ N7 J9 l    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;
/ E* O0 O' Y- O# B5 A1 U  ?) G
    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
' E1 ]: X7 P% f) ]8 }    WORD  wOutDataBuf[256];
, T% y7 ^, q! M' t8 k$ P4 W% I% X
) V: G& o( [  V. K    BYTE  btIsFirst = (BYTE)bIsFirst;

5 z% {2 ^0 X) w/ g8 Z, O, S    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;
# N5 {2 P9 p7 Q' }8 E$ W% v; Z
. M/ O( U6 B& c. p/ B$ y    __asm
    {
        // 必须先执行这条语句
        JMP EnterRing0

  L# u+ w* @: n6 V/ R5 W- \        // 定义过程
        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc
+ O# G, n( n) p$ T- \
        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
8 z! k+ k: d" L  ~        ADD  DX, 7

2 S- J- g( x$ I! g: B6 S        LoopWhileBusy:

! F4 G. V$ K8 G* w$ {0 d        DEC  EBX
0 ]" J. }2 N" S3 d2 q        CMP  EBX, 0
        JZ   Timeout
" k. I, i% L# r9 a        in   AL, DX
        TEST AL, btBusy
' F$ m9 ~( ], j, `        JNZ  LoopWhileBusy
        JMP  DriveReady
* K, R. B" U5 [) }0 ]
+ X) O1 o1 o& }/ H  |( d        // 超时，直接退出
        Timeout:
7 F; ?' Y% t5 h  |# S+ c        JMP  LeaveRing0
4 I/ M; f' j. L/ X# g! I+ U9 e# N        DriveReady:
9 P) k1 i, O9 ?        RET
        ENDP   // End of WaitWhileBusy Procedure

# [+ B. b) U3 J3 ~$ n" p        // 设置主盘和从盘标志
        SelectDevice proc
6 V; h. v5 e) z
7 k7 X3 J  g3 }        MOV  DX, dwBaseAddress
        ADD  DX, 6
( v- M- C7 p7 r2 C        MOV  AL, btMasterSlave

5 U  E! K$ x8 H- g# v' C5 N        out  DX, AL
        RET
$ U$ _" T# j; P
        ENDP  // End of SelectDevice Procedure
+ y$ Q8 z9 S" E& g8 G' D
        // 向IDE设备发送存取指令
        SendCmd proc
+ D/ u6 `+ A3 s* x; D) `+ m
        MOV DX, dwBaseAddress
0 x0 G( T% R3 x6 F! m5 O8 u, d# z2 ?        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
' R7 A2 }% _: t9 K( Y* q# F) f        out DX, AL
        RET
        ENDP  // End of SendCmd Procedure

        // Ring0代码
        Ring0Proc:
        PUSHAD
        // 查询IDE设备是否存在
/ l6 o8 E6 z. h, r/ K        MOV DX, dwBaseAddress
        ADD DX, 7
, U! _6 A$ P, ~# G& N' u5 n        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
6 T" Y, }$ E; Z; {% `        CMP AL,0xFF
        JZ  LeaveRing0
        CMP AL, 0x7F
        JZ  LeaveRing0

3 P0 F9 M. p0 z        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1

5 i  l- b# P3 f7 V2 k( L6 N; I! w        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
6 F* q; k* p+ Z) E% a' H; W9 f  M        CALL WaitWhileBusy
0 {! i/ O/ S! J3 _9 B, X+ a! F8 a        CALL SelectDevice
$ T) k, _5 t) g1 w2 U
        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
% X  o0 e( i; I- K( P) K7 P( u0 N( a1 Y        CMP  btIsFirst, 1
        JZ   LeaveRing0
$ ?3 S! I) C' o" h
        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy

' @" E2 h" Q% P# _/ m4 ]( q        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
        JZ   LeaveRing0
, T; L% t+ q: t& ~
% k; @% p+ U+ h/ \2 K! x0 b8 v        // 设置驱动器存在标志
5 a! {9 `% J" e        MOV  btIsDiskExist, 1

        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
* T' r+ h$ |& t. J0 P/ A/ a        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
+ r- u: n# ?% l8 G. K! p, R' E        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
( d3 o+ ~5 N+ @+ m        MOV  BL, btAtaCmd      // 发送读取命令
, u7 V: i8 s/ h8 P% z2 @* W        CALL SendCmd
        CALL WaitWhileBusy

        // 检查是否出错
6 P* c4 N1 B/ b, {( G# \3 r        MOV  DX, dwBaseAddress
        ADD  DX, 7
8 t3 _0 J2 \9 }
3 P/ V* m, c% |: x/ v* y        in   AL, DX
; {5 M5 C7 j+ l9 K
        TEST AL, btBit00
2 X% y- |$ Q1 S' X        JZ   RetrieveInfo   // 没有错误时则读数据

8 g- y3 i/ O( R) u% q0 I; }        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice
* l/ O( o4 B, b        MOV  BL, btAtapiCmd
/ T4 [+ M( x( B) g' Q! I/ s        CALL SendCmd
        CALL WaitWhileBusy

        // 检查是否还出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
4 J8 i5 I( M: g& ]        in   AL, DX
' c7 C# Z' z" S% x        TEST AL, btBit00
5 x- y8 M) i+ e4 d        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回
( m7 O5 g. ?9 S0 ?" w1 A+ G
        // 读取数据
8 f! H/ x, t: O" S9 P9 l/ y& Y        RetrieveInfo:

        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
5 N" o, w- D' p6 |" g" _        MOV  DX, dwBaseAddress
        CLD
# `# b% d) H0 G& t+ c
        REP  INSW

: s" ~0 U9 U+ @        // 退出Ring0代码
        LeaveRing0:

- n3 Z% P9 q4 @' Y        POPAD
        IRETD

        // 激活Ring0代码
        EnterRing0:

4 n$ [" O5 P3 I8 u9 i& ?* ^! v4 s        // 修改中断门
        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
0 K& v$ s# X/ o& D        ADD EAX, nHookExceptionNo * 08h + 04h
- K) D8 c. a; l# k" f, }        CLI
. W# ~& H3 X( k" l2 ?
- {  c2 Z- ^/ t( y2 c! Q" A        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
& K  M1 c0 z4 j5 K$ r        MOV dwOldExceptionHook, ECX

        // 指定新入口
- O  P; P0 U% G; d1 i+ K# M        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
! N) E$ _9 Y3 B1 `3 C$ [        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX
) V" t" i- D; ~: G8 P
, J9 m; m! }  p( ^6 O  ]; v6 }) N% G        // 激活Ring0代码
: T5 \, s# v) q7 q* J* I' j, ^        INT nHookExceptionNo
( u, M& P8 H5 k4 g% p
4 L" {5 R+ f  D; q4 A, s' l0 g6 R        // 复原入口
        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
" ?) ~) N0 {' t! p        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
; E1 t- Z/ ?; ]  ~0 `        STI
4 h9 E) ?+ v9 [# A) G, ]7 X    }
1 M: H$ l$ D7 z* F* Y" ?    if(!bIsFirst)
; O% [9 h( Y/ a3 u4 U* x    {
8 E. j* n6 s# Q" x( x5 {9 E2 z9 F        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
% @8 i/ y* t6 A8 U1 `    }
}
1 i; ^6 F% `& K" n0 Z" m1 p//---------------------------------------------------------------------------
2 r$ I) |. E# J7 _5 r4 Y9 I// 调用方法：
. @1 k! h8 F' R4 uvoid __fastcall TForm1::Button1Click(TObject *Sender)
{
" U( C8 n( s7 r    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}
7 U5 r; e$ }7 {/ X