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

天云上人

代码框架，你所要做的仅是修改WQL语句，具体可看MSDN。以下代码为简介起见，一次返回所有的CPUID或硬盘厂商系列号
$ n" j% U0 D, S6 W: d

1. 
   
2. #include "StdAfx.h"
   ) ~2 C& U$ _/ b+ U/ C: B
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   $ ]  l! H/ N1 D* e
5. #include <iostream>
   
6. using namespace std;
   * c) x  z. r! ]' x) [" L! v
7. #include <comdef.h>
   ! I! D4 s2 h2 j9 _* o. g' ]& R
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    - z8 V' f" z+ Z7 [0 c/ Q3 h
11. CpuIDDisk::CpuIDDisk(void)
    9 F$ e4 x# r8 A) \2 C4 `
12. {
    
13.     GetInfomation();
    ; S- }" e  C3 N% i& V  t# \  J6 }8 p  _
14. }
    , P7 c: t3 r- w6 F, r) S6 z
15. 
    6 T1 M3 d1 ?% b# i  }. Q
16. CpuIDDisk::~CpuIDDisk(void)
    ' m6 n9 \; m, @/ I
17. {
    : `7 N) r. A& _9 `
18. }
    & H' C0 I, ^  l, n) t; ~# m  N
19. int CpuIDDisk::GetInfomation(void)
    " X$ L$ l. m7 b0 K5 _
20. {
    
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    4 t% ?+ r, v& x& x7 l
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    - A2 i5 D( ~- g8 X
25.     {
    % H. H$ b4 w3 y
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    ) D0 p8 ?  N( e: U- ^
27.     }
    ( K0 M* z4 g) `3 A5 y
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    2 P- `+ U; K% }9 ~; w
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    6 F6 d7 n& }' r% a& ~
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
    6 x& c& ~) r! X
39.         NULL                         // Reserved
    " D( Y) x" b' [( j( ^$ O
40.         );
    
41.                      
    4 q- N& a7 N4 L1 D! y/ R! |
42.     if (FAILED(hres))
    
43.     {
    
44.         CoUninitialize();
    # W" ]5 V; i  X) c5 q( O1 c
45.         return 1;                    // Program has failed.
    5 @( D# P  H/ z
46.     }
    ! |. r- \, C* k! j) n
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    + p" d, u' c5 z" Y. r5 Z  q
50.     IWbemLocator *pLoc = NULL;
    / J/ ~7 H6 \9 g  Z
51.     hres = CoCreateInstance(
    
52.         CLSID_WbemLocator,            
    $ U8 Z! k# G5 O7 H% B
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    
57.     if (FAILED(hres))
    
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    
62. 
    . Z/ t7 H6 l+ K. U' P4 d6 l
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    : c8 j1 [8 m) A, W  y( ~% G
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    . t  l. Q8 Y/ i( j* J
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    3 P* \) w; {" R( ]
69.          0,                       // Locale. NULL indicates current
    0 e$ T. B' {4 o) N1 I
70.          NULL,                    // Security flags.
    , D) D4 e3 v% G& P8 U( y2 k
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    8 `+ |& O, D! |5 G: j
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    , `4 {2 x7 A& @4 G
75.    
    : z; M: T* R# B) O1 m
76.     if (FAILED(hres))
    % c1 D. q* L; d5 c* b  D, s4 {0 n2 |
77.     {
    
78.         pLoc->Release();     
    7 p. u- F; q* p  E  H
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    3 M' ^1 C8 P; E" K% C0 S( ]
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    7 N, @7 a; ?* j# M  T) K
83.     hres = CoSetProxyBlanket(
    
84.        pSvc,                        // Indicates the proxy to set
    
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    ) ?: |# f) U* A9 e
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    
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
    , F9 C. C' ?: g  n
90.        NULL,                        // client identity
    ) u7 r( Z$ z3 t7 X2 k
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    
93. 
    . a/ n& z7 G; z# a0 `7 L  b  w# y
94.     if (FAILED(hres))
    4 v& ~! V) c4 f0 w' b3 K
95.     {
    7 y$ U* A) V! x2 S: T, U$ `5 F
96.         pSvc->Release();
    
97.         pLoc->Release();     
    
98.         CoUninitialize();
    0 h0 ~2 P7 g  Y2 |! q3 _
99.         return 1;
    
100.     }
     0 t2 V( @! ^; g7 r& i# p
101. 
     ! G" N' J# k! _4 m  L1 \& @
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     8 v1 k6 x. G" d& i6 [( d
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     0 t0 B& C4 L) f$ I0 v
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     ! |/ L4 A$ V+ j
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     + z& n- W& {3 P. ?( M% B7 q
109.         NULL,
     
110.         &pEnumerator);
     % u3 |1 H) R% f, |) p. j' [0 S, n
111.    
     
112.     if (FAILED(hres))
     
113.     {
     ( o4 Y/ k! }+ B* y
114.         pSvc->Release();
     " U6 ^- Y: ?$ x. A4 i
115.         pLoc->Release();
     $ g* Q% y5 f$ d; z8 l
116.         CoUninitialize();
     ! `+ E4 X/ S! s, O" ]" M+ w4 d
117.         return 1;
     
118.     }
     
119.     // 步骤7：Get the data from the query
     ' n; C: d1 M% ~* s+ S/ N3 r
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     ; D$ X1 Z5 A& l2 h, C$ W) m
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
       N( z# O0 {& e4 W
125.             &pclsObj, &uReturn);
     8 t, A. J$ L, I. c
126. 
     
127.         if(0 == uReturn)
     
128.         {
     1 m7 Q5 m$ n6 ~5 d0 l7 ]( R( o2 V2 s2 o
129.             break;
     
130.         }
     
131.         VARIANT vtProp;
     / r& }3 C+ {5 B# {; M0 P4 E
132.         VariantInit(&vtProp);
     1 J4 P( {9 |1 e3 h
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     9 Q# Q* m5 q" t  E. }0 l  b2 h
135.     }
     8 T8 r7 w0 A% k' y. p. e
136. 
     8 `3 C1 }# {* }, O0 H2 N
137.     //计算硬盘系列号
     
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     
143.         &pEnumerator);
     4 l, E. |7 d7 U/ w" ?4 |, D/ Q# G. X; Y
144. 
     
145.     if (FAILED(hres))
     
146.     {
     6 c4 D: `6 v/ l  d/ A5 ^0 A
147.         pSvc->Release();
     
148.         pLoc->Release();
     & m7 k4 v+ L4 h% a9 T/ b
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     
152.     while (pEnumerator)
     
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     + M* q( [- j; ^5 L
155.             &pclsObj, &uReturn);
     " v, i+ I0 J/ E
156. 
     
157.         if(0 == uReturn)
     
158.         {
     
159.             break;
     # v% ]6 _- w3 q! r# B  g
160.         }
     & ~! }9 }* ~) z8 L: E! ?, U
161. 
     
162.         VARIANT vtProp;
     $ o+ I' L- j  a" C: P* v6 Y
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     6 ^+ i) N- _  X
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     " R% K3 E% U* n, y2 h6 v1 ^
166.     }
     5 `) r& Z) J. `- O
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     3 d0 ^, K/ I; {3 h3 v/ C- Q1 x% u
171.     pclsObj->Release();
     , y' L4 V( M- P6 q6 m. P* A
172.     CoUninitialize();
     
173. 
     / n* M. v9 ~, j/ C8 {3 l* g
174.     return 0;   
     + O! p- ~$ v* x. p
175. }
     ) T: w* z: m7 ^$ R2 k

复制代码

天云上人

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

#include <WinIOCtl.h>
0 y8 W! F4 @) h#include <stdio.h>
1 `6 ~2 ~* O1 Z: ]& b  F' b" }
* w: v- M, p- n. w2 t' p6 j" }* n0 C#pragma inline
3 \. ~. k6 F: g% X3 V& z//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
/ z+ g' {5 I5 B/ K( E  W#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
, i% i$ O0 Q9 r' q& ~" X#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

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

const int MAX_IDE_DRIVES = 4;
' M3 R9 O! z9 `( ^
// SCSI专用变量
* X  J8 l; v- s( d4 \4 |const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
) \5 g! n1 E) `3 G' y! xconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
" K2 O/ |- l7 E9 K2 O' Rconst DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

  I7 f! O3 U0 z: S1 Stypedef struct _SRB_IO_CONTROL
# S# n1 S( f9 K{
$ t6 }0 K+ {- p* F& Q; q" S    ULONG HeaderLength;
/ O4 ?/ @, F" C5 E3 k    UCHAR Signature[8];
    ULONG Timeout;
    ULONG ControlCode;
' v2 d5 n  p4 c. w- t) Z0 R    ULONG ReturnCode;
    ULONG Length;
: A1 J3 I& h  U: I+ d}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
+ v% X4 f$ ~- J3 W1 i5 Y3 L; {* e
// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
; M2 h2 S% N- C; C// NT/2000/XP函数
9 b# Y/ Y7 k7 c, cvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
( t5 a& F; Z& `bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
9 U; y) E* {" y/ m7 I        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
) K3 x( `' m% T9 L+ T6 z; J7 ?// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
. A: N. w3 P( V* nvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
9 f, n  k0 Q$ ?# {& S        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
* R6 {( l& Q: e0 \# J, O* F
// SCSI读取函数(for NT/2000/XP)
( |$ C. f% X9 j8 \8 v5 iString __fastcall ReadIDEDriveAsScsiDriveOnNT();
) w) v5 Z) c' O% y7 C8 J+ j5 v$ y//---------------------------------------------------------------------------
. N3 t  F, \- U' q- g! Y7 e// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
# y& H% T' N; k9 y5 r* u{
    switch(Win32Platform)
& u- X  ~9 n+ m- {  Y7 C    {
        case VER_PLATFORM_WIN32_WINDOWS:
3 P3 D4 K5 f! M' L' ]8 `6 m            ReadPhysicalDriveOnW9X(pSerList, pModeList);
& d( Y( v  \" w( B            break;
        case VER_PLATFORM_WIN32_NT:
# {: M9 y7 Z, E# v            ReadPhysicalDriveOnNT(pSerList, pModeList);
+ {3 C' v9 K' \            break;
        default:
            break;
1 i8 L: \9 u2 i0 p. Y4 A6 K6 N    }
}
//---------------------------------------------------------------------------
5 H+ |" Y& W; Q6 |// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
& T) \! c6 ]& R" [; ~{
    static char szResBuf[1024];
    int nIndex = 0;
! F4 u* v4 S) `9 n" `    int nPosition = 0;
3 E+ F/ Q4 x  h7 }) G- N: G
    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
% I/ U; e# D4 ^) ~    {
7 B  N. I6 c4 @, A5 l        // Get high BYTE for 1st character
8 L" I. ~) q. e* C0 `' V$ t        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
: j' a9 [4 P5 A5 t        nPosition++;
1 B* N. Q: g& t
2 B* f3 x$ L- ]. K& C" }0 K% l        // Get low BYTE for 2nd character
9 {2 m  Y3 ]; p* t5 ]- Q        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
# J; T- O' h7 f+ h/ f: t! m2 ^    }
4 r. h. X6 J- f4 y2 R
7 b% P5 g; K/ s4 t    // End the string
, t) ~  t0 T( D& ]    szResBuf[nPosition] = '\0';

    // Cut off the trailing blanks
    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';
0 F- `6 q3 o' ^: i& w
3 C! F+ J7 L; ~7 e/ W) a0 c    return szResBuf;
. g" b# c% E! V2 U9 ~}
& C1 g1 @, ~& R7 _9 P" I6 v% B' t/ B//---------------------------------------------------------------------------
3 G4 P2 E8 ]  ^// Winndows NT4/2000/XP 代码
. E5 M3 ~$ _/ w, U//---------------------------------------------------------------------------
6 |" K! h5 O  e8 j+ H4 j9 ~  z// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
+ q. y  h) |" u3 p! m2 e; C9 z{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

7 [* p$ F' r7 U* x0 m- e, N% o    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
; o. i! y. S. Q9 c) L* F) f    {
        HANDLE hPhysicalDriveIOCTL;
$ N4 t6 t5 _* @# }        char szDriveName[32];
) c+ Q* P1 T9 p- M8 F
. H# d& q% t9 Y  K) c/ _        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
; S- I* D/ [( Y( `1 K+ a. J        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
* y! G; _, o7 O+ _" R                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);

        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
2 d9 {# A+ w  `2 y. e; J: g: G- W7 `+ z        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;
! }0 a( e$ s6 o4 G# P$ d
            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

+ V+ J6 B/ k' |# L            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
9 g+ A* z% Z" Z( X                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
& V5 l  N1 x: P7 I  B3 l8 p                    &dwBytesReturned, NULL))
6 \. |, k( H6 G: ^            {
                continue;
$ G: o$ k/ Y# ?( |" t            }

            if(gvopVersionParams.bIDEDeviceMap > 0)
% c1 T3 G: g; h            {
                // IDE or ATAPI IDENTIFY cmd
                BYTE btIDCmd = 0;
! H* T7 L+ f& T1 B. M: O9 q                SENDCMDINPARAMS InParams;
                // Now, get the ID sector for all IDE devices in the system.
% R4 B, Y" `8 D9 g! b: t4 L$ V                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
" J) D+ ^: W8 x. u2 I- B8 ]                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
5 s! k; I$ g0 q: |: c( F                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
9 |( z- N  \+ d, n3 Y                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
) z# k* y6 v) K+ @, E8 r                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
5 w! G* r  A9 w# ]                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
2 C+ t9 i. ?/ `1 Q& [1 t* w+ N  N9 `                {
* v& Q/ V+ _! c4 u' r" I( E" R                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
4 k5 m& g) b% m- N" R                    char szSerialNumber[21];
                    char szModelNumber[41];

+ X; N/ f6 K  i                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
% O: D+ m4 d% g  A8 A- c' M; S                    for(int i=0; i < 256; i++)
; v' U6 S, k/ O/ E2 c                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

+ n( q' Y" |0 b% G! }                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
  Q) E' g1 M) g, ^2 H; y' o3 ]                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

9 H+ @6 F, d! q1 D                    pSerList->Add(szSerialNumber);
1 Y/ y2 W4 o' `4 B/ D                    pModeList->Add(szModelNumber);
* V  `) M7 f; g                }
- {" J2 r0 I, [% R0 B& M5 ^            }
5 f* h0 F1 A9 w' k. d$ C' E2 \            CloseHandle (hPhysicalDriveIOCTL);
        }
4 s8 z. a: }! Q! [( ]8 {' x    }
}
//---------------------------------------------------------------------------
// DoIdentify
8 M7 F( v$ Z, q% u0 Y0 W6 P: Lbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
. N2 A* l$ b: r# o" k# Z              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
9 |6 C" G; J* P& z/ v7 i# g: E              PDWORD pdwBytesReturned)
{
' b# o- J" o5 u. V! m9 u& k    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
. ]1 Q1 c. a( _8 u7 A    pSCIP->irDriveRegs.bFeaturesReg = 0;
9 B! C+ C1 n. s- u$ j    pSCIP->irDriveRegs.bSectorCountReg  = 1;
  w/ r8 W7 B# ^    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

  E/ c. t9 V( l! F* d' O+ J2 G    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
7 U4 _/ t" d2 y) w    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
$ M" e+ R! i. e# T
% H* l, L/ b1 k9 v% P) v    // The command can either be IDE identify or ATAPI identify.
6 i1 e1 P" R: s& ?    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
3 p  B* b& i! G% E8 A/ @5 H
    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
( z  V3 z. {9 q& ?: _1 y( f' _           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
4 b; T7 C$ H6 }3 b. ?           pdwBytesReturned, NULL);
7 B8 D1 [  o/ W  b" {}
//---------------------------------------------------------------------------
9 y2 W  H# c. I# b* G1 ?) ?// Windows 95/98/ME 代码
* C, D2 m: F7 P- e# O0 e' D//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
/ t! u+ U" F: n7 k. @# V3 Jvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
5 h0 k+ p; v0 \( y9 d' l0 L    WORD wOutData[256];
    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

3 g9 l4 @. e" {# z3 N    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
. v; p  a+ ]' e    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
' ]' P# E: [" g5 Y    // 避免蓝屏的出现。（期待高人能指出原因）
% e6 n; ~# e! n7 a) n9 x    for(int nDrive = 0; nDrive < 8; nDrive++)
* I5 n# l# B8 ~    {
6 C8 ~. c3 W# [9 J7 y        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
% X3 z, K! O" ?        bool IsDiskExist;
% q4 Y" l! o! z* e" X! C
/ ~! x" d3 q1 s5 Q" c6 o! M% `3 L        switch(nDrive / 2)
6 a# x0 f5 `+ i3 R9 W, {        {
7 W6 X% i# X1 X) \4 d. Q            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
. u, {' v- m2 [# u7 @- g* x& l. V+ R4 [            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
, R1 G0 C1 ]$ ~* ?1 I; X! c        }
$ C0 w9 W' H7 y/ x% o+ `
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
# Z: ]) m( \; O  u2 o
/ V2 w: H' c' u4 m        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
6 T- [; B' g# t( h) E' z  ^* P                bIsIDEExist, IsDiskExist, wOutData);
    }
' F' \$ }, A; j$ y
    // 开始读取
; z3 m7 A/ f3 c, h' w    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
$ s; l! _' E$ E0 I        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
. n' E# ?1 G9 z5 Y9 T- q7 J        bool bIsIDEExist;
        bool bIsDiskExist;
# t' f# o3 n$ Z! u5 ~- j        switch(nDrive / 2)
        {
) A) i6 V/ a9 {; F9 g            case 0: dwBaseAddress = 0x01F0; break;
) \3 ^# @& t$ [; G/ G) p6 h, a            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }

        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
2 D+ r/ P: m- |$ c. [
        // 进入Ring0
        bIsIDEExist  = false;
        bIsDiskExist = false;
& s" V5 |" |7 S# M/ s1 I$ @5 u        ZeroMemory(wOutData, sizeof(wOutData));

! U$ [3 u7 A' n7 q2 ~7 \        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
- G) F! i) b) h                bIsIDEExist, bIsDiskExist, wOutData);
% a6 o7 \$ B- k! P; V. L2 d
        if(bIsIDEExist && bIsDiskExist)
- r3 I2 H  _9 I9 X        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
            char  szModelNumber[41];
! l. G& X+ o' Q+ r7 m
5 V! d$ Y4 @0 B; u: }+ Q            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];
* ]5 T1 b) w: E1 l* x
            // 取系列号
, \/ F( z, V8 P7 V9 n0 L  O) q( _& E            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

3 Q' m5 A, x% i9 f) A            // 取模型号
7 Z/ e6 Y% l+ p4 B+ P& \; P- r8 s            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

            pSerList->Add(szSerialNumber);
' A2 u$ E; g6 h8 x6 c            pModeList->Add(szModelNumber);
        }
    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
7 G+ `4 k! K% u" B$ U}
% V% j! f* k/ N8 A  Z1 \//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
2 v/ T% M2 _1 k( J! K* W7 V// ReadPhysicalDriveOnW9X_Ring0()
//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
3 O" l  v4 S6 N! i2 I# ~! L6 x// btMasterSlave = Master(0xA0) Or Slave(0xB0)
: Z- U# r+ _& j//---------------------------------------------------------------------------
; O1 Q7 O7 o3 I4 E& ovoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
, h* F8 P; s( I* ^, B# O        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
    BYTE  btIDTR1[6];
1 R8 c! U, a  N& L/ ?0 ^    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;

    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
/ y4 s- v# S, s! E( P    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;

" f8 O* {/ f* j    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;
3 f, ^# j% J1 h$ B8 Z
5 L- Q  R) z  l6 [# l8 J' U    __asm
' w# b2 K# v0 ~1 q9 ~# E    {
        // 必须先执行这条语句
( i# ?, t" g# t4 I1 |$ [        JMP EnterRing0
) X1 d/ M7 J2 G" V' P! |
        // 定义过程
        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc

! f5 B% u# h1 l$ H! E- x        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
        ADD  DX, 7
+ b, [5 d+ B7 M: L/ y4 H$ h
! x, w' D( Y& r$ q  X1 Q        LoopWhileBusy:

        DEC  EBX
        CMP  EBX, 0
        JZ   Timeout
        in   AL, DX
        TEST AL, btBusy
        JNZ  LoopWhileBusy
2 M, ]& o. J7 k6 Q, C        JMP  DriveReady

9 @! Z/ v" S" E; h6 ~; }$ v+ Y        // 超时，直接退出
- w! u! |$ R8 P6 T        Timeout:
        JMP  LeaveRing0
        DriveReady:
        RET
        ENDP   // End of WaitWhileBusy Procedure
2 q- {7 Q  X, ^# Z  X8 Y4 x8 t& H
) s4 d% ^5 `4 R9 i4 d; D( @8 V        // 设置主盘和从盘标志
        SelectDevice proc

        MOV  DX, dwBaseAddress
        ADD  DX, 6
! m8 Z! f/ J8 a! k$ W$ r- D) L        MOV  AL, btMasterSlave
$ c) d, t; q- N; c) \  a* v
        out  DX, AL
        RET

        ENDP  // End of SelectDevice Procedure
% i6 R. M$ `  w; q- o4 R& O9 @
        // 向IDE设备发送存取指令
        SendCmd proc

        MOV DX, dwBaseAddress
        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
% H6 c; P- M3 R        out DX, AL
        RET
. O2 q9 N/ j' x; P' M        ENDP  // End of SendCmd Procedure
6 p+ s* E$ H, v3 p6 L- p& F8 e
4 e4 G$ R3 d* E8 j5 ^8 a1 `0 T  q        // Ring0代码
        Ring0Proc:
( b! l! h  U1 r6 V        PUSHAD
. ]) d+ z, e1 r& Z3 S3 \* I        // 查询IDE设备是否存在
$ g) c6 _+ Z7 v0 G1 ], ], k- P        MOV DX, dwBaseAddress
, n7 c4 b9 y1 s9 W7 R' N        ADD DX, 7
8 `+ z9 G, U! N( z( d3 O& f. {        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
9 n7 f* o8 \6 e, D- G! `) h6 S% J6 p+ I1 @        JZ  LeaveRing0
        CMP AL, 0x7F
        JZ  LeaveRing0
0 j& j7 V( ^% c' Q9 l7 C
+ N9 c8 S0 v0 p* }, G7 V+ U/ N        // 设置IDE设备存在标志
" r. i: {6 O) ?* y! I  A        MOV btIsIDEExist, 1

        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
0 I" j8 j/ U- A' ~" i7 ~: U: ^        CALL WaitWhileBusy
        CALL SelectDevice

. A5 K2 H5 J9 b  z0 s) J        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
5 g) h, u0 r2 O6 [  y8 n        CMP  btIsFirst, 1
        JZ   LeaveRing0
- _: }. F' j8 d- D. x+ Y$ t
- o3 R5 k9 d& j+ C& _+ l" G" r        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy
9 T$ o8 \* J( e
        // AL的值等于cBit06时，不存在驱动器，直接返回
$ b( H* T# v  `, ?- d        TEST AL, btBit06
        JZ   LeaveRing0
* j; _9 h+ m" T4 f6 t
8 L. u9 X6 e5 c# P  ?$ v, h        // 设置驱动器存在标志
" R, z7 a; c9 E$ J4 I) g+ W8 e* h0 R        MOV  btIsDiskExist, 1

! O5 N/ ?  p- f        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
( j3 U- V2 H3 I7 V        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
! s3 R- ?5 ~0 C0 O        CALL SelectDevice    // 设置主从盘标识
7 F1 S2 w( Z" T4 E        MOV  BL, btAtaCmd      // 发送读取命令
" N, w+ |8 F* O* @        CALL SendCmd
0 n' A, z) I1 x  P        CALL WaitWhileBusy
! ~& ~, {6 k4 I" D* q
/ \" b# {) _5 m, u2 l4 R        // 检查是否出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
# L# K! C3 e( @5 G3 H2 W
/ z; _% g- _* W/ q8 k+ s        in   AL, DX

        TEST AL, btBit00
  j5 {1 D/ G  g' k' p        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
8 I( s+ S" l  Q0 S, c        CALL WaitWhileBusy
  Y' A; t( C: N% C( C4 A; g! C        CALL SelectDevice
. t0 O$ P7 U% w3 B; [        MOV  BL, btAtapiCmd
- `& b% S! k( Z1 k6 R- ?, B        CALL SendCmd
        CALL WaitWhileBusy
/ D  L& ?, X# a4 C* U4 z
        // 检查是否还出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
        in   AL, DX
6 L/ n- X/ k* g2 W% B        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
$ I! `- t) ?, r! _4 n        JMP  LeaveRing0     // 如果还是出错，直接返回

) y" R$ l! c  {& s& Z3 i- M        // 读取数据
        RetrieveInfo:
3 I0 j# i( Y* f3 j  R' `
+ v/ d9 [5 ?" [2 y( u        LEA  EDI, wOutDataBuf
5 s  m6 |/ |% T' K# Y- x: A. c        MOV  ECX, 256
        MOV  DX, dwBaseAddress
        CLD
; u# o. |0 k) n
        REP  INSW
/ c- f  Y( b* C, z0 k5 y/ \) n
        // 退出Ring0代码
7 t1 h  J5 q6 G* b+ [        LeaveRing0:

. j7 D  ?$ R; I' P7 @        POPAD
        IRETD
) Z: c: J% U" C6 g" ~6 b, |
/ M" a6 B4 }! f        // 激活Ring0代码
        EnterRing0:

        // 修改中断门
        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
& u7 F7 }/ P' K) J        CLI

        // 保存原异常处理例程入口
9 b9 V8 f0 F9 u6 ?1 N+ n! F9 p        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
% y2 l1 `7 Z% @9 j' N) A) I8 x        MOV dwOldExceptionHook, ECX
( B. k6 }  f9 s/ X( R. V# h8 I
. [. m5 r! a5 v/ Z        // 指定新入口
        LEA EBX, Ring0Proc
' ^0 a8 n& c8 k        MOV WORD PTR [EAX-04h],BX
" a% B9 I% V- H; q/ |2 |        SHR EBX, 10h
9 p6 r' @7 g+ m& x& J8 M* @" X/ h        MOV WORD PTR[EAX+02h], BX
$ g2 g* s# Y2 s9 g5 {7 K
; o2 N$ z1 l$ G+ }% P! P( j0 W        // 激活Ring0代码
. Y- L0 f# A" J1 L' q' W) u+ Q7 `- p        INT nHookExceptionNo
/ j0 s) u" W# V. h" l
        // 复原入口
        MOV ECX,dwOldExceptionHook
0 C9 E: u% ]2 E" y* P        MOV WORD PTR[EAX-04h], CX
, c) ~0 s% E& p" {9 _9 F        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
1 }1 X2 J8 Y1 _) w        STI
    }
4 x3 V8 H+ ^$ [' r8 ?9 r    if(!bIsFirst)
    {
        bIsIDEExist  = (bool)btIsIDEExist;
) s& |% @( J" V8 Z; f        bIsDiskExist = (bool)btIsDiskExist;
' r0 `1 l' e: r$ a. u0 [        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
/ j. i+ C3 |) @. G2 C}
# L8 Q4 ]2 O5 o: z  u% h* y//---------------------------------------------------------------------------
4 P4 P( P8 D  _$ F// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
1 A2 h/ I- _0 M  Y. ^8 Q' e+ b) V  P, g{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}