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

天云上人

代码框架，你所要做的仅是修改WQL语句，具体可看MSDN。以下代码为简介起见，一次返回所有的CPUID或硬盘厂商系列号
/ {3 s% h  `6 J9 O5 p: T

1. 
   % R8 ]/ l8 l+ C4 R5 T* x
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   0 e, P+ g; j  G- S0 ?4 g9 H, w+ p
4. #define _WIN32_DCOM
   
5. #include <iostream>
   
6. using namespace std;
   4 H" h& ~0 s0 ~) j
7. #include <comdef.h>
   1 d, ]4 N# ~* u( f
8. #include <Wbemidl.h>
   
9. 
   9 i+ y" `9 p, @- z
10. # pragma comment(lib, "wbemuuid.lib")
    9 @$ k0 q0 P' A2 [
11. CpuIDDisk::CpuIDDisk(void)
    % Q. f. p2 o2 h/ O& v' M
12. {
    ; x' J, {, J( }
13.     GetInfomation();
    3 [& h5 ^& R, @% L) h
14. }
    2 H# B8 q) V; k1 v! {4 u
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    4 f1 K) T, M& J  B" J4 H+ ^; Q
17. {
    
18. }
    5 ^4 m" `- u9 D. R
19. int CpuIDDisk::GetInfomation(void)
    , a  o9 K& _  A' ^
20. {
    " k1 A- S0 L. n5 @' }3 ]
21.     HRESULT hres;
    + |) D" G& v1 V9 |5 p
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    . D! ?  g( [3 @
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    $ e4 }7 Y9 ?- v- O% f5 X
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    0 d& r( @$ m3 j0 p% C) B2 f
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    8 K% Y/ u$ b/ a2 n7 d/ {
34.         NULL,                        // Reserved
    / M, q4 k% r* \' |$ E" ?( C1 Q
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    9 b8 B8 z9 N7 Y6 `. G
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    " c1 U. o6 J9 w0 H0 M( v. W
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    4 v  k$ \( H. c; R. I+ @8 t7 k$ y! F
40.         );
    
41.                      
    2 b! G0 C& [8 ^/ W% q" f* e
42.     if (FAILED(hres))
    
43.     {
    
44.         CoUninitialize();
    ; q6 Y! d6 X6 X8 P$ Y2 E5 s- a
45.         return 1;                    // Program has failed.
    : I  j+ \  c9 o# b9 d! U- L
46.     }
    ) D6 C. m( |8 F0 a
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    * G8 f7 B1 z& ]% a
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    - P$ c8 d$ n6 }4 }0 R) o  V
51.     hres = CoCreateInstance(
    ( u3 B  h8 A8 i9 h
52.         CLSID_WbemLocator,            
    
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    5 K) |3 [' I5 s; }
57.     if (FAILED(hres))
    ! ]! @% k0 [. Y: f, _3 {
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    " b/ N2 _% p9 S* _8 \$ P0 U
64.     IWbemServices *pSvc = NULL;
    ; k, p6 b- {% ]) G3 T' A
65.     hres = pLoc->ConnectServer(
    
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    . _: ?6 \" [( i
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    1 T; @0 E$ c1 Z7 z' P- G' b* k  O
74.          );
    9 d9 q9 G7 ?+ }  R7 w  S' E$ R. }" _
75.    
    # }7 g  m0 j* C
76.     if (FAILED(hres))
    ) ~* I; y0 l: K
77.     {
    ; f; j- i! @8 e+ S# N* A
78.         pLoc->Release();     
    ( d' v" W1 v" G* X! q8 ?  ]8 `0 R6 o
79.         CoUninitialize();
    8 d/ k  f* ]' [6 F' W
80.         return 1;                // Program has failed.
    . x. q$ N5 Z' Z' A
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
      Z4 i6 T, h0 g
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
    
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
    1 o3 Z; X3 _# L8 O0 e5 v
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    4 v; L3 _" d& }- T& _5 @7 w/ R
92.     );
    
93. 
    * ?" q1 b: J- d: y5 d& z; v& {0 m
94.     if (FAILED(hres))
    7 \  ]5 s! z" p$ ?- V) R
95.     {
    ( [* C. a! g9 E/ Y7 R
96.         pSvc->Release();
    
97.         pLoc->Release();     
    
98.         CoUninitialize();
    : U' O8 I* ^! t9 P  f
99.         return 1;
    
100.     }
     
101. 
     1 r4 _  k8 H, G/ l/ V
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
     3 w! a0 d! Z5 X9 T
105.     hres = pSvc->ExecQuery(
     ! Z, @; E; \% U
106.         bstr_t("WQL"),
       P( O4 G, h' e
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     6 {. E+ \  n, k3 x% w+ G* ?
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     3 R7 m: I& c1 x4 p, j
109.         NULL,
     
110.         &pEnumerator);
     
111.    
     5 o% ]0 b; H7 }" C
112.     if (FAILED(hres))
     
113.     {
     & J5 B8 W3 k# K! u" B8 x
114.         pSvc->Release();
     
115.         pLoc->Release();
     
116.         CoUninitialize();
     
117.         return 1;
     2 R- L3 d6 s) u% f
118.     }
     $ c* @" _/ Y6 F% Z. b. ]  ], e
119.     // 步骤7：Get the data from the query
     ) m. ]3 p1 }" D! P0 W* s! y5 _1 q
120.     IWbemClassObject *pclsObj;
     ; z* Y/ b6 @" M. y5 Z, T/ U
121.     ULONG uReturn = 0;
     " D2 q( R. s) L# s8 R3 p% w# Y
122.     while (pEnumerator)
     
123.     {
     2 U1 ^' p  m( e" n4 Z, n
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     0 m4 k+ R- A, t. D, j
126. 
     " A5 a# L" F5 f0 Q; G. J
127.         if(0 == uReturn)
     + s4 r9 U  l: W/ j' E: T
128.         {
     . Y% m5 [' w7 _/ u4 J
129.             break;
       G" {$ d" {9 C9 c0 W0 U
130.         }
     
131.         VARIANT vtProp;
     * y* r! l" j; E# w5 t) a- X: P
132.         VariantInit(&vtProp);
     1 q1 t8 p) p: W: S* A8 t! t
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     6 }$ m% X1 U: |3 N/ C% l0 x5 x2 _
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     
136. 
     : c( t% k! {# ?* A
137.     //计算硬盘系列号
     
138.     hres = pSvc->ExecQuery(
     - I- x2 S, l  @% L7 W
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     - L) O! v( s) J- _$ G! _& C
143.         &pEnumerator);
     
144. 
     
145.     if (FAILED(hres))
     
146.     {
     
147.         pSvc->Release();
     * V$ o: S/ N# ?
148.         pLoc->Release();
     8 h7 Z+ S; Z' x& B& e0 E
149.         CoUninitialize();
     7 Z; q  m" R2 ?% K, g, k
150.         return 1;
     
151.     }
     ! j8 ^. i! B3 T
152.     while (pEnumerator)
     / h4 e- A+ D7 b. d6 S9 m
153.     {
     ' e0 X4 c) Q1 r+ ^6 O
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     % I1 s5 d- ^) X- s' y1 y. a. u
156. 
     " j0 Y( p! R6 s: G# o  h. ~. d
157.         if(0 == uReturn)
     
158.         {
     0 D" U- q0 i$ r8 M
159.             break;
     7 C3 Y( {0 {4 V& t+ ?6 B5 W
160.         }
     
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     - ^8 r) Q8 U1 d2 V3 m4 O
166.     }
     
167. 
       Y( r( B3 ]( ?* d
168.     pSvc->Release();
     ! x# v! U+ O* }" q0 R0 C% k! C
169.     pLoc->Release();
     ! L2 v$ R2 p' W2 j
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     
172.     CoUninitialize();
     
173. 
     ; [7 f: ?, j  ?2 U  W
174.     return 0;   
     $ `2 J7 t' u' t  C0 d9 u7 N6 s
175. }
       ]/ d# n& P* i* f

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
' f: G$ g# t4 j) z
$ U5 |0 {3 A1 D& h( r- E$ V#include <WinIOCtl.h>
& ?; t# n0 x% E/ y4 `#include <stdio.h>
3 [9 t( O7 I4 d) E) v# X4 U
#pragma inline
+ p; W, f( K9 Z. v/ [2 n+ y//---------------------------------------------------------------------------
+ h1 H; `( R9 O) I) h7 \3 V// IDE NT/2000/XP专用变量
. e4 B+ N/ g( u2 _#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
6 s9 r. H; g1 R! N( K& _#define DFP_GET_VERSION         SMART_GET_VERSION
5 \2 c) \  o" c( C6 K) I2 Z' L#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
* t3 ~1 e& K) P5 ~5 v
const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
( C: a& [6 ]3 |3 g# A' Q  |const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

/ {- p& \3 k: h5 {: zconst int MAX_IDE_DRIVES = 4;
# A+ E1 H* p. A; T6 d
1 A% L* f8 V; y// SCSI专用变量
5 q3 N2 z' ~3 U/ t- wconst DWORD FILE_DEVICE_SCSI             = 0x0000001B;
const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
1 H7 S. t  z% ?0 f+ [const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
7 M9 Y. I# D( C+ U- Z
8 o. T% E1 F4 Ttypedef struct _SRB_IO_CONTROL
{
    ULONG HeaderLength;
    UCHAR Signature[8];
    ULONG Timeout;
    ULONG ControlCode;
+ a: n! |1 x. l, F    ULONG ReturnCode;
    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
- A& X2 u# E: Y; `1 N( q
// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

6 F$ o% `! Y. V" ]! p+ K// 辅助函数
: E, u$ n0 i5 d7 A. E0 ichar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
% D8 W/ {; M' E" {; W// NT/2000/XP函数
; G- n: G1 T, B7 B6 @+ F$ U# bvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
0 R  o0 c5 Y3 X) j( }( ibool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
1 M$ g) ?, q9 o8 u, L! C/ j        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
- F7 p0 D4 S8 A" a8 S// Windows 9X函数
& l; H8 y% p0 c1 C  u% ivoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
' t: j: X) K& F( T% r. z+ ivoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
+ J4 q0 |4 y, q9 G
// SCSI读取函数(for NT/2000/XP)
7 r# x: A! O+ s* E$ W: M7 b/ Y0 AString __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
" a  |0 \5 g( R4 h// ReadPhysicalDrive
# b1 L$ ]6 M- P1 ]  r( jvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
2 I: @$ I7 a% O2 j+ P& @. f{
    switch(Win32Platform)
    {
        case VER_PLATFORM_WIN32_WINDOWS:
            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
2 ~; T* e6 A, b; A* d* r/ D        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
1 D! p$ L2 ?" X# w  w            break;
        default:
            break;
    }
}
; @6 G+ n- ^* P  B% Y; M5 W& v//---------------------------------------------------------------------------
/ W! c& Q/ _' m) M+ Z5 Q8 [5 i0 x( E% Y// ConvertToString
: }* U. C7 v1 Bchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
; c! N/ k! T+ u# y' N7 H8 a+ W    static char szResBuf[1024];
9 V3 ^  M+ I& y4 R! T; `7 m7 D    int nIndex = 0;
; E, J2 e$ Z' O  G5 K4 r    int nPosition = 0;

% R# e9 }' x* Z  k3 }    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
6 `) V6 H7 Q2 \. ~2 Y4 I: j$ w        nPosition++;
9 ]1 j4 X) X7 U; p2 G+ w
5 e8 }2 b& M9 o2 r0 [! I        // Get low BYTE for 2nd character
. z7 K/ ]8 v# K6 I1 E% }        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
    }

    // End the string
    szResBuf[nPosition] = '\0';

    // Cut off the trailing blanks
) [4 Y( N  i2 F! ~! G  F    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
' ?* p: O5 `  V: U8 E( b& g) Q4 N        szResBuf[nIndex] = '\0';
3 c$ I3 t5 k; Q$ T
    return szResBuf;
}
* E' |0 L* ~  l, o1 y  m//---------------------------------------------------------------------------
- r9 e( Q! S3 U! M3 k. `" G9 l// Winndows NT4/2000/XP 代码
7 G6 V6 _; y) B/ u//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
- U  C$ h' P5 R2 P{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
' [: P" s! R2 r9 {5 j  o4 L
; v0 a/ x" i9 {0 v    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
& J% Z" y9 q* A9 v+ K6 ?( i# b    {
* A0 J7 v4 t9 p8 W1 t: d$ I        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];

        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
/ @5 h/ r# w7 a( f9 |2 p" h0 o                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
! i9 }) Z2 `% [" V0 y" `5 ?                        OPEN_EXISTING, 0, NULL);
4 ?2 C5 y: e' _% W
  g, E- t+ Z/ q' A        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
  F7 U0 ~1 C) E% U7 l; a1 K, K! K        {
            DWORD dwBytesReturned = 0;
: [& X# v7 U  V* u1 t* u+ p+ `            GETVERSIONOUTPARAMS gvopVersionParams;

            // Get the version, etc of PhysicalDrive IOCTL
7 C% L8 t# G$ g' E. q" W            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

" m: O; [  J- N            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
/ A5 O" _4 {2 j+ S1 O3 I* ?' T                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
6 `8 Q' r" H* s, J                    &dwBytesReturned, NULL))
            {
% l, O+ c9 r: E& ]                continue;
            }
' k5 z! {0 p! `5 j
            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
% m2 M5 m8 K9 C) Z. H$ K                // IDE or ATAPI IDENTIFY cmd
                BYTE btIDCmd = 0;
& h! _  J" c# \) N                SENDCMDINPARAMS InParams;
                // Now, get the ID sector for all IDE devices in the system.
) Y- l$ A* ~& h! q                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
. o6 X, y7 r/ `                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
+ F, t2 O* ?% n' ^5 ?                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
, d6 E: _6 f5 ]1 L- }& w) e8 n                {
- N6 r$ R* v! R) b4 v8 G5 K7 b                    DWORD dwDiskData[256];
. U7 a0 |0 t( D9 N  W, X3 c4 b                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                    char szSerialNumber[21];
                    char szModelNumber[41];

                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
2 s, b0 G" J# w% g) K                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
# a% U/ S/ t! {' B8 ~2 b' m3 n
                    // 取模型号
" ^% `8 [2 H- E) c* n! u. V                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
' ~. D1 R7 O. H2 S2 P8 n% m+ G: X                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                    pSerList->Add(szSerialNumber);
: f1 a7 H3 \- [3 B  O. w                    pModeList->Add(szModelNumber);
                }
; z7 i2 Q, }8 i& Q0 I1 Z8 p7 X            }
            CloseHandle (hPhysicalDriveIOCTL);
7 M2 V3 d1 f+ p        }
+ u- a6 q7 q2 Z) o- n! f+ R6 i    }
}
//---------------------------------------------------------------------------
// DoIdentify
) V! O* a+ E1 ~& Mbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
7 M3 }! B- ?: j9 l              PDWORD pdwBytesReturned)
{
  l) D) K6 I* p- e* M3 n! ^+ Z    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
7 g, h: Y* x) D4 `6 m    pSCIP->irDriveRegs.bCylLowReg  = 0;
9 J) |; M# d: Y4 V( k, |1 d    pSCIP->irDriveRegs.bCylHighReg = 0;
! C+ r" D6 [$ ^* M; M
1 \2 p- h7 ]$ z- ^+ f/ k$ }% |    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
- u* u) d2 l, l+ b( _3 ]
    // The command can either be IDE identify or ATAPI identify.
# a; B0 K; L7 B    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

0 k" P/ j* \1 b9 `* Z$ k$ k( g    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
% p" ?8 r! g& w! _3 L1 e1 H           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
  h0 o) i& d$ W2 v7 Y! q  w           (LPVOID)pSCOP,
* i* U* s' g: B- v" M( j           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
% |. ]9 K% j6 Q" u9 O- Q9 H1 D# [}
( o- T& a7 i7 B, {//---------------------------------------------------------------------------
5 V) Z+ F% E: m, h- Z+ _// Windows 95/98/ME 代码
) T( h" i3 q4 M1 x//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
    WORD wOutData[256];
# C4 i% C+ e' {( P, q* C    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
* _1 A' P( I8 T: D* E# T$ C2 l3 C
1 \1 n, y1 ^0 |8 ]; q    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
5 g, Z0 M+ Z& {. R  R    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
5 X! G, T) }. U0 ~    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
7 H  ]# ]  u7 u        bool IsDiskExist;
, d, l) @: M4 d+ h$ b- e3 Q! T
! K: b4 g/ g5 q; ?& s" M& u- y6 S% h        switch(nDrive / 2)
: b0 ^3 ~9 m8 s- i- P- W5 }        {
6 V8 t2 @7 x5 G% _) G            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
4 U# h6 }8 I' B, w$ S            case 2: dwBaseAddress = 0x01E8; break;
) B8 q( n+ X4 t- s$ @- ^            case 3: dwBaseAddress = 0x0168; break;
        }
$ t) V' d& O8 _, c  _5 |" x
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
0 B7 [! O0 T+ I* m& u8 W
        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
    }

  b8 C9 I! @2 R/ U" y4 Z$ ^    // 开始读取
$ P" V. g" m0 B7 |; R    for(int nDrive = 0; nDrive < 8; nDrive++)
; g; C, e  Y8 c& U    {
        WORD dwBaseAddress;
" d. C& ~$ H+ C. s, T. D" g0 t4 {        BYTE btMasterSlave;         // Master Or Slave
( x4 c6 k( J! }- U" ]* T1 x        bool bIsIDEExist;
. R' P! y3 y6 `! p        bool bIsDiskExist;
        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
7 y" O' A. Q* B+ R/ Q  q( H            case 3: dwBaseAddress = 0x0168; break;
        }

        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
$ x# t* V  }& @. ^
. |+ R& u  W* H* ^6 \% d' _9 ?        // 进入Ring0
4 R( N2 ]; z$ y8 n        bIsIDEExist  = false;
        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));
( E! K$ h/ s( n% \
! [1 `5 Y* u2 W  V' c# A3 j1 K  \        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
5 `2 r+ _9 r; r+ k# T) o& R' e; T                bIsIDEExist, bIsDiskExist, wOutData);
. P4 Y" B' e3 `, K" M
5 v& D7 W  R6 Y        if(bIsIDEExist && bIsDiskExist)
        {
* n! I) i( Y5 Y& b            DWORD dwDiskData[256];
! V/ F. ?, h9 c3 f( `            char  szSerialNumber[21];
; w4 J! e/ D3 r. q. l3 k  r% y            char  szModelNumber[41];
& H2 \1 q3 E# ^6 ^9 r% R- T6 o
            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];
1 D# X  \% _' O" R
* D7 d1 n1 W3 l; Y# Y9 a# @            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
7 U/ M. t2 v" G' S, p) y' @
            // 取模型号
2 S: B6 _4 T  X+ ?3 ~" |            ZeroMemory(szModelNumber, sizeof(szModelNumber));
3 c  |! D& [1 O            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
5 M0 r: y: {! ?/ a) l, Y
            pSerList->Add(szSerialNumber);
3 d! X1 ^* O: w% `& h0 x            pModeList->Add(szModelNumber);
! c4 K3 u( o0 H/ M% K5 \( u        }
, S2 w' s/ t7 q$ ^( M% b. t    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
9 m$ N8 v6 L6 q' Z2 L) t// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
! Y# w) `+ }- f// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
" C1 ^0 o2 z+ J. I: H2 G//---------------------------------------------------------------------------
, @, g2 a: B4 \  d2 e! z3 M// ReadPhysicalDriveOnW9X_Ring0()
8 ?& n+ G" Y# O; B" @' A) U. `9 w1 Z$ \//
$ l9 L7 h% o( Q0 m( D$ M// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
. Z/ D0 D" T) {; H" {" A: C7 H//---------------------------------------------------------------------------
( B$ o; e1 \+ J) K$ ]void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
    BYTE  btIDTR1[6];
+ Z$ a# D8 h- l    DWORD dwOldExceptionHook;
; q5 I" p/ N: a5 u& d% `0 N    const int nHookExceptionNo = 5;

    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
7 w: {5 P/ u- d& X$ x    WORD  wOutDataBuf[256];

" M1 V3 K/ x& j& a% R* `) _$ G    BYTE  btIsFirst = (BYTE)bIsFirst;
/ h$ B& K1 U' y# e
6 e- j7 n  \( _5 d4 ^' X: r% o! h    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
  f$ Q! Q6 l" f% q1 g* T& y! |    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
6 Q% R1 [' f6 W; `. m    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;

; b: [$ l( _5 ^6 G& J0 J# z1 i9 t    __asm
    {
        // 必须先执行这条语句
        JMP EnterRing0
# x3 S; I6 I) y6 l% q3 J+ s9 M% b
) d& b4 }2 H, k" s$ r/ s8 m/ n        // 定义过程
1 o. D0 I$ c; x* [; R; f        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc

        MOV  EBX, 100000
5 I# N' D  F8 G. t: ]        MOV  DX, dwBaseAddress
3 d8 F  `+ b4 |/ @        ADD  DX, 7

        LoopWhileBusy:
) X6 d1 q, R8 i# o9 L4 d
, M+ r4 g) F2 q/ R( P        DEC  EBX
        CMP  EBX, 0
        JZ   Timeout
2 \; C2 Y$ c6 R1 W; N7 n* X        in   AL, DX
6 E& _) x7 Z  C/ p        TEST AL, btBusy
8 V9 s" D% j/ l5 j) U0 Q7 u' @        JNZ  LoopWhileBusy
        JMP  DriveReady

8 M( o8 [1 }5 h        // 超时，直接退出
        Timeout:
3 e8 A0 c" d- x. I  ?/ s        JMP  LeaveRing0
$ M% H8 ^) R: ]1 X' V& }7 P' I        DriveReady:
1 a' N2 M7 P1 `' K2 ^3 A9 e        RET
        ENDP   // End of WaitWhileBusy Procedure
8 d( ^! I& M: b2 E
, L" i4 `; y  y$ W2 R& n        // 设置主盘和从盘标志
# M" v; o- ?% w; s4 ]3 k        SelectDevice proc
, s; D- b0 a3 _+ q3 Y1 w# I
        MOV  DX, dwBaseAddress
        ADD  DX, 6
        MOV  AL, btMasterSlave

        out  DX, AL
        RET
) D4 {4 I3 E  @$ ~
        ENDP  // End of SelectDevice Procedure

& {; q/ L" N( s        // 向IDE设备发送存取指令
* ]6 E9 X0 V$ B* t" z. q        SendCmd proc
$ j: I) D* [4 m! c4 b1 \
5 e2 i2 n' O9 F* K        MOV DX, dwBaseAddress
        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
        RET
) @8 l4 M2 b; c3 k: J/ _* b! {        ENDP  // End of SendCmd Procedure

        // Ring0代码
6 x* b  n, i0 Q% X2 i        Ring0Proc:
0 n$ l; B# K& E% }2 r* Y8 @; ~        PUSHAD
        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
        ADD DX, 7
9 C, U2 U* }  d% J5 I6 q        in  AL,DX

' W& B$ B  @' q4 A4 ^1 ]        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
% l. i5 y. a4 E# A. |6 R% H        JZ  LeaveRing0
/ V6 R& D/ e$ }8 i, @+ x7 l        CMP AL, 0x7F
        JZ  LeaveRing0
5 T0 R* K6 t4 P
% g# l8 S) l8 V9 z        // 设置IDE设备存在标志
8 q3 Q) B  U1 ^0 X3 Q% ]& h% q        MOV btIsIDEExist, 1

6 b( z% w8 ^5 p% @. X. M5 ?        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
        CALL SelectDevice
8 r! O/ }; n! u) {. A  g% {
( E3 O  D1 a7 }; |, a1 d$ N        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
  R3 [1 E! q% {* @9 n        CMP  btIsFirst, 1
        JZ   LeaveRing0
4 w5 K3 O- [1 w& S7 U
6 I! l0 z3 ^! Z4 @+ o* S# Z* i& m8 a        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy

        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
+ q6 P4 L+ }, W* U" n3 }4 W        JZ   LeaveRing0
  Z2 r% w: V7 I/ C( W
        // 设置驱动器存在标志
9 }4 |& x; p- `# ?        MOV  btIsDiskExist, 1
4 e/ X% |* _, @! P( Q8 t0 l
        // 发送存取端口命令
; g- i; t0 q* P2 c( l        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
6 a* }9 }$ ?1 u        CALL WaitWhileBusy
. o1 V. U( C' b0 J$ d) Y        CALL SelectDevice    // 设置主从盘标识
% w- f& R7 e+ D( {2 G% A- I        MOV  BL, btAtaCmd      // 发送读取命令
5 F: I2 m+ |4 z) N; F        CALL SendCmd
        CALL WaitWhileBusy
/ q+ _6 _( z. O7 T) i
        // 检查是否出错
0 U. m4 j/ n% w! v5 R- g' U        MOV  DX, dwBaseAddress
3 P$ [% f& c, H8 V$ D4 F8 F5 f        ADD  DX, 7

        in   AL, DX

" k4 e8 Z3 e4 N/ w        TEST AL, btBit00
# Z* \$ W6 G( ^1 G1 \& G$ s        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
6 P; \& ?5 V# ^& v/ a$ z        CALL SelectDevice
        MOV  BL, btAtapiCmd
( C; P( k' T9 a        CALL SendCmd
        CALL WaitWhileBusy
4 U5 @6 e8 I# l. }
        // 检查是否还出错
! _8 [4 h) W7 A  k- F$ E+ w+ }        MOV  DX, dwBaseAddress
" ?; U8 R9 l$ K2 Z8 \9 A        ADD  DX, 7
        in   AL, DX
        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回

  r% h+ B/ e1 _: Q5 Q        // 读取数据
' ]4 b* K- E" F9 t        RetrieveInfo:

/ f# `' g% s( y7 K: J! h7 r        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
        MOV  DX, dwBaseAddress
; u/ e0 u& y& i* {* f$ T+ V        CLD
( m7 @! W/ u6 }+ v
        REP  INSW
% u# U# {) [& [2 K8 ?
        // 退出Ring0代码
        LeaveRing0:
  h7 B0 U5 J! v( o
        POPAD
, P& v6 }1 G' O7 q$ t5 ?: `4 I        IRETD
0 d; Z* C( R8 u  A/ m( E
        // 激活Ring0代码
        EnterRing0:
* N9 U, ~! S% J8 U0 Q, ~
        // 修改中断门
4 |. L8 o1 T! y9 \! Z, b        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
- W# v6 y- a+ R0 x/ B1 N        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI

        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
8 h$ P3 L3 Z# G        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX

        // 指定新入口
' m3 y1 J# R+ f5 ?6 `  U, E' j7 Z        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
9 Z: J$ [& C# |& S/ D( a        SHR EBX, 10h
( j$ F* @% e" T3 R3 @5 d        MOV WORD PTR[EAX+02h], BX
7 w+ B" B) l2 k* y
7 ^7 e' i9 {; @1 J6 d        // 激活Ring0代码
        INT nHookExceptionNo
# Z1 d6 B8 X) U
2 Z  S+ t( ~8 j* P        // 复原入口
+ G$ |8 R/ Y; @* X5 g; K2 z1 n        MOV ECX,dwOldExceptionHook
4 A* o; |6 ~- {& C/ Y8 H        MOV WORD PTR[EAX-04h], CX
6 z2 d) B6 I( |6 S7 z. \        SHR ECX,10h
7 B$ c. P% @' @1 T- I- R5 Z6 j& w& `        MOV WORD PTR[EAX+02h], CX
4 A1 o3 A: C, c' Q        STI
    }
7 R8 v' `% S7 k' ~4 v    if(!bIsFirst)
% D, c) `- f/ h: @" y7 ^' \) D    {
        bIsIDEExist  = (bool)btIsIDEExist;
& a  ]9 d) V3 P        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
/ k. ]& Y( w  @/ L& h3 E}
//---------------------------------------------------------------------------
// 调用方法：
" Q; U9 Z! C  O- \; Qvoid __fastcall TForm1::Button1Click(TObject *Sender)
6 [; z6 [# O; o6 o3 N! d{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}
* U# [6 k: T4 k$ N# M) l