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

天云上人

代码框架，你所要做的仅是修改WQL语句，具体可看MSDN。以下代码为简介起见，一次返回所有的CPUID或硬盘厂商系列号
" l& \. x1 [* ~" J

1. 
   
2. #include "StdAfx.h"
   & x* A, H$ m6 ]& b
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   3 W& M7 Q0 `' Q, Z( {  K& W
5. #include <iostream>
   , v  p9 `& p/ f
6. using namespace std;
   7 f- K( `& n9 B2 S) c6 O! ]2 E
7. #include <comdef.h>
   
8. #include <Wbemidl.h>
   ! s0 P9 @" `' P! A
9. 
   ) Z& M, B7 H1 L0 f6 a9 j2 p4 [0 i
10. # pragma comment(lib, "wbemuuid.lib")
    : E8 @) s; ?) q: ?$ H1 U
11. CpuIDDisk::CpuIDDisk(void)
      m9 P4 v) L, S+ [
12. {
    
13.     GetInfomation();
    
14. }
    
15. 
    9 {* ?+ X1 G' o3 ~
16. CpuIDDisk::~CpuIDDisk(void)
    - v% d. j! H5 |3 R- W
17. {
    / {9 [- T" i) z- O9 D8 v
18. }
    4 X" O" ^, O6 L6 J' o, {9 e
19. int CpuIDDisk::GetInfomation(void)
    % v% h7 D6 r- a7 }/ Q5 x
20. {
    % M4 N/ x' b& [* a1 F- M
21.     HRESULT hres;
    $ l3 v+ w  h5 i$ l- J
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    4 p- g6 Y* p$ j8 D: q  v
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    / r! `3 ~. I" l! Q' d  I- s9 A
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    : B, ^; y7 S* P) {' l! e
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    , g) \3 i" r% m+ y6 o% i
31.         NULL,
    
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    - ?! a& z( S8 P
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    1 H; y& k8 ?4 u9 `5 u" A
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    ( C  k5 M0 s9 c2 J2 G9 N# }0 c" f# [
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    : \% x' V+ V, y1 \9 z$ i' D, p+ S: B
40.         );
    + P! D- W2 [# p3 Q
41.                      
    0 R% W) g' [7 g( z8 |
42.     if (FAILED(hres))
    , @' w' |0 p* q8 @2 ]
43.     {
    
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    2 u$ j0 a/ H+ h! W, e
46.     }
    7 M: V) s( X# E" u" b
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    , y2 ^$ h" t2 n% @9 u
49.     //步骤3： Obtain the initial locator to WMI
    3 |7 R  `/ {# ]* u7 d
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    
52.         CLSID_WbemLocator,            
    
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    3 ?, |  D) S( q$ z1 z% Z
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    + p* W. ?9 ~; q: w/ C; G3 C
57.     if (FAILED(hres))
    : i9 W# X/ O! ~* w
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    3 Z5 @: p) f( O2 i
61.     }
    " u, r/ T' b3 P) q7 t
62. 
    ' e1 A5 K, T! Z3 R
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    . R# n7 k( Q" B2 e! q  z$ p# h) A
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    * C# ]& ]% ]/ Z0 o9 o5 S
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    / u' S# {4 H" |" {) W
70.          NULL,                    // Security flags.
    ' L8 ^9 M( V! ]2 j5 k$ \  g
71.          0,                       // Authority (e.g. Kerberos)
    ) s; K4 e7 i! ~' a% h
72.          0,                       // Context object
    / Y/ J1 I% e( M
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    
75.    
    / n5 J. `9 z8 f; E
76.     if (FAILED(hres))
    * E. r- Q4 A* W' U% {' ?# i' O5 T
77.     {
    5 e- r: F# z4 p: J5 v0 w2 E1 j
78.         pLoc->Release();     
    " Z1 {( |* X8 ~: o. o3 K1 j( X8 a
79.         CoUninitialize();
    9 F0 \4 Y/ i4 S( f# K+ `+ O- }. `
80.         return 1;                // Program has failed.
    2 c% p: i1 [# X' u& j3 M
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    9 X3 X& `/ l, b( h, Y3 a; e: |" h
83.     hres = CoSetProxyBlanket(
    , A# ^  n8 ?/ Y/ M8 u
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
      n" v* o; |' o2 {- P
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    5 ^4 H& R9 e9 p9 _1 F5 E  B: {
92.     );
    
93. 
    
94.     if (FAILED(hres))
    
95.     {
    
96.         pSvc->Release();
    2 y% C" K, p: u  ^4 G2 B
97.         pLoc->Release();     
    
98.         CoUninitialize();
    . n( {  M! w, G5 ?; K+ v- G, Y
99.         return 1;
    8 g6 [/ D* R  {: ^& ^/ `
100.     }
     
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     " _& |+ |* V, H" z( Q3 w$ j
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     # F2 L  w* A! Q; z+ m! X
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     ! h" O- s$ T8 {6 F
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     2 U. k0 \2 A2 l/ e% G( A
110.         &pEnumerator);
     - G/ b  ]: A; ^9 r8 u
111.    
     ( T8 ~" w0 F0 o9 g$ j
112.     if (FAILED(hres))
     
113.     {
     1 o; |' S& }$ R: f( L. V9 Y3 C6 X  J
114.         pSvc->Release();
     : u7 ~* [2 j- x" t+ L
115.         pLoc->Release();
     4 p4 V" C$ }3 h' N
116.         CoUninitialize();
     
117.         return 1;
     8 H9 d' c' A: c0 Z# p3 ?# b
118.     }
     : F7 _% l2 T. M1 P+ p0 o
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     2 B/ F5 U7 H3 @2 n( C
126. 
     
127.         if(0 == uReturn)
     
128.         {
     
129.             break;
     
130.         }
     
131.         VARIANT vtProp;
     8 h3 f7 J9 X: _/ r" c6 o
132.         VariantInit(&vtProp);
     , t- }- U5 b7 a: v+ m2 ^8 v( ?' g
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     5 \2 d( G" v2 c
135.     }
     
136. 
     : G0 |' Z1 x/ r# C4 X7 X+ E% l
137.     //计算硬盘系列号
     ( W, y  n  c" h
138.     hres = pSvc->ExecQuery(
     $ Q$ `8 a/ n" d7 a* q% _. @+ I9 E
139.         bstr_t("WQL"),
     ) h9 T" |9 |, [% Z$ `# n
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     6 e8 H4 w: _- j7 J* L
143.         &pEnumerator);
       R- o" J6 A( k9 m
144. 
     * C* P" O4 R3 _7 x
145.     if (FAILED(hres))
     
146.     {
     
147.         pSvc->Release();
     
148.         pLoc->Release();
       R" M/ f" X/ Y6 C* R
149.         CoUninitialize();
     $ P+ ]# Z% m' M' A
150.         return 1;
     0 y& G6 l0 R1 v) q+ C7 T
151.     }
     
152.     while (pEnumerator)
     
153.     {
     0 M1 s) G8 ~" Z
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     $ f; x5 f! @: |; U* b+ N, m
155.             &pclsObj, &uReturn);
     
156. 
     
157.         if(0 == uReturn)
     
158.         {
     ) P( C3 \1 I, r, ~4 O# o. }6 F1 s
159.             break;
     
160.         }
     ) V4 L" h7 O2 o, l
161. 
     
162.         VARIANT vtProp;
     " {2 k* e& Z0 Z7 w
163.         VariantInit(&vtProp);
     * c/ h6 f2 V1 e1 p/ b3 I
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     5 ]9 [/ S% }0 R
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     9 \: C& P0 |# ?
166.     }
     
167. 
     : H5 c( G- l6 Y+ d1 {9 n
168.     pSvc->Release();
     7 p9 u- L4 t0 K0 r
169.     pLoc->Release();
     3 j( e3 Y. E/ r) ~7 s
170.     pEnumerator->Release();
     6 @+ o5 P2 ~' m& u% ]0 ^
171.     pclsObj->Release();
     
172.     CoUninitialize();
     
173. 
     ( I8 t1 a- {4 }/ Q9 Y9 f
174.     return 0;   
     
175. }
     

复制代码

天云上人

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

# z6 x* Y5 n$ C7 U# p#include <WinIOCtl.h>
#include <stdio.h>

8 U2 _6 b# @9 r% S#pragma inline
//---------------------------------------------------------------------------
% V9 U3 O8 M2 O# k// IDE NT/2000/XP专用变量
- _- E9 i. ^# {  c* C# C3 g#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
/ J- f9 f( _* b/ V8 g3 }- F
- c" Z8 H. r* b$ Zconst int MAX_IDE_DRIVES = 4;

1 b% H" Q: H; B8 U// SCSI专用变量
: p" R0 U$ W5 C9 fconst DWORD FILE_DEVICE_SCSI             = 0x0000001B;
const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

* K/ B. i' L; {5 I. xtypedef struct _SRB_IO_CONTROL
{
& i. y: U( ^7 f9 p  D7 ~* n% j- ^    ULONG HeaderLength;
5 k2 e& P5 N5 A3 x+ W2 {0 R+ S    UCHAR Signature[8];
6 e. ^7 i0 E1 B    ULONG Timeout;
    ULONG ControlCode;
    ULONG ReturnCode;
    ULONG Length;
+ b& B; D2 u' S* B* d0 ]}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
# N$ W& c9 b" x, U! Z
// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
$ U+ ]& o( j5 G/ E// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
/ ]: z0 |& D, _5 R7 ?- z        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
% v3 {  g5 n4 @9 svoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
8 A6 K- ~5 Z7 U7 I2 e# t        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
; b3 ~5 r; a& N" g; D( x! y& y, B! g//---------------------------------------------------------------------------
# O  W2 m& q) I( {3 X: [7 R3 r! A3 ?// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
    switch(Win32Platform)
    {
) L8 O( t3 F5 G, H) [! J8 o        case VER_PLATFORM_WIN32_WINDOWS:
/ d! J, O( n" a5 }* i% }. Z; }% E            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
% a% o8 d' D* ?2 Y6 G  {        case VER_PLATFORM_WIN32_NT:
/ c" z' m5 h$ d& R            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
        default:
( h, v1 x" `) ^/ W: u            break;
2 `& ~1 n# `: S# d    }
* }* ~4 |9 l; h0 S, O}
//---------------------------------------------------------------------------
6 |, p9 U2 j# L; w// ConvertToString
4 a, u* s0 I; C' ~, S+ S, cchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
4 g8 @) q2 H/ h& g+ a" _; \% o{
    static char szResBuf[1024];
    int nIndex = 0;
    int nPosition = 0;

    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
. r3 L& J1 U1 d0 K: C8 B: ]4 s) V    {
& S3 p, |1 d9 }8 _        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;

) |' A4 b5 c, l. f$ o/ x- T        // Get low BYTE for 2nd character
; c( h( s5 b# v7 n4 w/ r* F        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
/ A& ^" p; e$ R$ j1 }+ a    }
$ T# k' H8 w& _9 r, p6 Y
    // End the string
$ X8 P/ k- ^2 L( w    szResBuf[nPosition] = '\0';
0 w! ~' g7 U& @" J
1 C6 l+ ~: E  L5 |! r$ l0 s0 ^    // Cut off the trailing blanks
+ g- M% j0 f% |: f7 ?    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
2 k% O& E4 F. k& B0 M* x- h        szResBuf[nIndex] = '\0';
6 ^5 F* _- e. h! e; x8 \" n: S4 a/ S0 W
' A7 C, I" h8 @6 [    return szResBuf;
9 O4 U. A% \6 z& c}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
4 @2 Y5 p. @; H, o) Z0 H// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
) X( Q" T( l. o8 P) _7 ]( h. x8 r{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
# L2 h  E# X% r5 h
3 s$ ?6 m$ e8 |3 {8 {    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
' f8 i# U- B, n4 X        char szDriveName[32];

        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
" K( z& t- u# E0 E( U                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
, R& j* ]* n9 ]6 ~  a( {                        OPEN_EXISTING, 0, NULL);

9 F- `, G6 o! E; P$ \* N        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;

& |# A* `- Z9 _7 ^( O: Z            // Get the version, etc of PhysicalDrive IOCTL
: {1 n& l9 h3 l4 v! T9 v, U7 d4 c            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

2 c+ y2 s$ r$ T6 p+ R9 f! J# b7 j            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
, m# a8 v3 x# ]0 n6 T            {
                continue;
6 y9 m: w3 b! ]" r! J            }

/ R( A5 C& v8 j" ~# D1 h1 v            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
/ j% f& |) O5 V& b1 e8 y" J                // IDE or ATAPI IDENTIFY cmd
$ x0 K8 k% Y8 Q9 f8 D+ h! \                BYTE btIDCmd = 0;
                SENDCMDINPARAMS InParams;
                // Now, get the ID sector for all IDE devices in the system.
                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
% B. V/ O  r1 C3 r
6 W9 d+ v9 J# R0 N3 Z                if(DoIdentify(hPhysicalDriveIOCTL,
( J# I/ K/ o; J, Z' a                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
                    DWORD dwDiskData[256];
- i" v4 t( g( Y! z  C2 ]  {                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
( B8 {5 P% F$ q( Y) v& I! A( B: I                    char szSerialNumber[21];
- |% I( P7 h; V7 n  X- t9 J, d                    char szModelNumber[41];

' m. x+ W2 R( F7 V0 l                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
% H( H( g* L, G6 }  E! b6 M- V. Z                    for(int i=0; i < 256; i++)
% F3 {( ~/ V$ t0 }4 {  t& d                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
2 }" L& K; f9 x& \                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
: H+ Q6 M' h( {2 M6 y
9 j4 Z" F" p6 {; Q9 s                    // 取模型号
1 X' |4 [1 n8 x! t: {# O. W7 e                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
4 l* b; l0 n2 ^8 k$ l
3 z+ Z- c1 B) x9 `0 Z! H7 ~" }                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
7 u& i! m6 r, z                }
' `: j5 P) _0 U; ^# _7 w4 c            }
            CloseHandle (hPhysicalDriveIOCTL);
0 d9 z$ Q, `3 i' k4 V) N        }
7 \& h1 p( `) b! Y" \# M    }
}
//---------------------------------------------------------------------------
// DoIdentify
/ c- i% A, T5 W7 F5 g" Vbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
) w  q9 k# |2 |* u. k{
6 s, v$ B: `8 a3 e& Q7 }- S* R    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
: z( N' N1 J2 D; A  y    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
4 }! L9 C- y5 i    pSCIP->irDriveRegs.bCylHighReg = 0;

* E0 n9 A# E* l* s) O5 U# P    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

    // The command can either be IDE identify or ATAPI identify.
$ g7 z# S4 S7 u; ]    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
( ^2 n. Y$ t2 {    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
  _6 \! E1 E9 Y; |% d6 ^           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
/ ]3 G& j/ E% |: p. V           pdwBytesReturned, NULL);
0 p6 b* F& o" s, Z# T, P5 n}
3 x  ~1 I5 P0 r( \% x//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
( X6 o, f9 d& P3 L// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
% Q2 K1 L. ?& O( z{
2 M5 x' _- ?3 q; X" s2 p    WORD wOutData[256];
: j5 i" ]$ m4 A    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

' r% X7 F( ^9 g6 Q    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
0 z. _3 c9 \" \# T# l6 j    {
5 g7 v' X0 {; j2 l" r        WORD dwBaseAddress;
# P9 `0 D/ X) P) W/ D5 J6 ^1 {( x# ]        BYTE btMasterSlave;         // Master Or Slave
  Y/ ^; l7 p9 y- o0 z* `7 C0 T        bool bIsIDEExist;
        bool IsDiskExist;

        switch(nDrive / 2)
# e( s4 E$ x+ v/ z        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
* V5 G# m& B3 h% M            case 3: dwBaseAddress = 0x0168; break;
, N4 V( S; ]3 i3 X+ @. W4 t; \        }
  k2 M+ L+ e0 c( v- |
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
# q* u, q$ Y) Y1 M! D* \, W                bIsIDEExist, IsDiskExist, wOutData);
    }
1 N1 I# p# w8 s3 ]
    // 开始读取
  b" Z5 S( U; x5 x    for(int nDrive = 0; nDrive < 8; nDrive++)
; _- C9 v% [# {    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
# L2 p) [) D6 n( u" n+ _        bool bIsDiskExist;
1 K" v8 Q7 ?- X! p& K  h7 f        switch(nDrive / 2)
        {
) {9 d' H: S& i6 }) J4 X            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
& g; u% o0 J' U$ n1 i) g            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
1 F) Z' k2 |$ o6 D6 A- O        }
' Y* i: h$ U# d2 }, H0 o
2 y1 X* ^3 O( c  w6 g; i5 y4 W        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

        // 进入Ring0
        bIsIDEExist  = false;
        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));

, [- S6 i3 U2 L4 b        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);
2 }1 s+ n4 n/ K( i# ]
        if(bIsIDEExist && bIsDiskExist)
        {
* R; D& R: q& c1 ~( H            DWORD dwDiskData[256];
            char  szSerialNumber[21];
6 i# p9 }- b. ]2 l            char  szModelNumber[41];

            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];
% b& _! ?: s+ B
            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
3 d/ A" W8 a! d) o            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

' G/ \" D/ \7 h3 L            // 取模型号
0 t) t# g. {1 W0 \6 |            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
; F/ b. K8 g! Z2 J) z; |
6 g( W* U' X9 S: @# }3 F            pSerList->Add(szSerialNumber);
/ j4 C% t2 k8 F' W; a            pModeList->Add(szModelNumber);
% |6 S' g3 ]" E% y        }
    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
! c2 U& s0 H* I6 z8 F}
  I  X( _  k+ x# t1 u* z1 I9 f//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
. x* z2 Q& Z6 I' e5 O  Q) \// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
/ Q8 k) ]  v' B' `2 A$ q4 l! a" G9 {//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
6 P9 R. l6 Q5 j9 ?! l' B// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
3 c7 d+ ^- I/ f; c! T    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;
  j- u, ?3 A2 b" o
1 o) M# W6 U. C) u+ L9 v4 Z    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;
! F+ y3 i3 W8 F
    const BYTE btBit00 = 0x01;
, T+ p' {( F; K% A    // const BYTE btBit02 = 0x04;
! @0 F) i# d! d, Q; Y0 z' z    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;

- `# o( y# a! j9 t8 P# I- l    __asm
, q& z& K$ l  r( X/ M" z' X. Y    {
        // 必须先执行这条语句
4 U. v) r' {0 y) D( a2 |8 [7 C5 m. M- N        JMP EnterRing0
+ D, M7 P! p3 N
        // 定义过程
& V# d! ~0 a$ W" H( q: {0 V- I        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc
8 b- c( [! h7 @4 k6 l+ C3 n
        MOV  EBX, 100000
$ x/ Z* |0 B# h3 O& |        MOV  DX, dwBaseAddress
5 L2 r. a) W, J; b7 ?        ADD  DX, 7
) `& _1 F" k0 V- z, Z
        LoopWhileBusy:
" K( d0 F0 f+ z6 `" w/ ^& N' v
        DEC  EBX
8 t/ K3 z' R# z; C, b        CMP  EBX, 0
        JZ   Timeout
$ D/ r: a0 k; D9 @8 W+ M5 |        in   AL, DX
  ?' B6 j, r; A6 Y) F5 }! k* J; b. K        TEST AL, btBusy
        JNZ  LoopWhileBusy
/ V' D" e( Z/ x1 D/ L! Z        JMP  DriveReady
2 T6 F( p' ~; z! M" V5 U6 w
  R8 v8 D8 v/ i        // 超时，直接退出
        Timeout:
        JMP  LeaveRing0
        DriveReady:
0 M# X( l0 Y: D# ]        RET
& S+ h  c& R% r) k) l        ENDP   // End of WaitWhileBusy Procedure

+ z6 m: G( Z$ C; i4 ?+ `        // 设置主盘和从盘标志
        SelectDevice proc

% z9 ?& G1 }1 \        MOV  DX, dwBaseAddress
- h" U9 w8 g2 v        ADD  DX, 6
        MOV  AL, btMasterSlave

1 O% M1 Q, J8 D% r1 M3 L        out  DX, AL
& u: J( D) ~+ M# `        RET

5 t6 H; ]5 x. h1 e" c- F% n- h        ENDP  // End of SelectDevice Procedure
* ?, n6 ^( h. N% O( C
0 |! p/ I# @2 h3 b) _0 Z        // 向IDE设备发送存取指令
        SendCmd proc

& X( o( Z6 M: O- T. z        MOV DX, dwBaseAddress
        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
        RET
( |9 C" q6 ~2 d: k7 t        ENDP  // End of SendCmd Procedure
+ \/ j" ~% d9 y. W9 [( Y
' E' d% H7 @$ b/ d        // Ring0代码
        Ring0Proc:
        PUSHAD
        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
+ _8 p- S; ?( p        ADD DX, 7
        in  AL,DX

( G0 S9 {# b8 v. d; w        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
) v- J$ w+ ~* [4 r+ ]. k        CMP AL,0xFF
        JZ  LeaveRing0
        CMP AL, 0x7F
5 V& I7 y; D0 M; V  X* N        JZ  LeaveRing0

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

* v1 V/ k3 y: J        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
2 ]2 t1 Y1 {% K* Z7 Z9 v        CALL SelectDevice
7 S1 |# h1 F& i2 r* t! `' s
        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
7 s( L9 y# M- e% J        JZ   LeaveRing0
; h/ r4 Y4 O& f3 ^) j2 V" R' g5 F
, k' ]9 N5 s! x( ^9 }0 o& l+ _+ p        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy
5 Q, ?. l% C. f% n4 [$ z
# M+ Z5 Y& @" W1 ?. ^1 S9 \        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
9 j* N4 g; T. t  r        JZ   LeaveRing0

. ^3 R7 r0 f6 S        // 设置驱动器存在标志
; a) s$ f, m0 O2 e        MOV  btIsDiskExist, 1
3 E- w) I% e- Z. S, X' h1 S+ f' S! L; L
  h2 Y9 D: e; m$ z        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
/ ~( s1 S+ p; }7 Q        MOV  BL, btAtaCmd      // 发送读取命令
% }/ X# d8 D9 G( t$ }: N$ Y        CALL SendCmd
        CALL WaitWhileBusy

        // 检查是否出错
8 N2 Y% B  ?$ p) J        MOV  DX, dwBaseAddress
% G, x' i6 t: b6 c9 F( ~        ADD  DX, 7
: b" x5 N( k4 A" Z. ?7 ~/ ^
8 J( N' q* S) y+ G        in   AL, DX
- j- s0 T8 I. Q" \3 `
( E6 P: H* d* z+ |" W" S$ j5 t, l, j        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
" p: o) e6 h6 V0 L* v9 y
        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice
        MOV  BL, btAtapiCmd
1 L) u* n, D- V$ o" P3 `        CALL SendCmd
1 ^% ]- u2 D. O/ I+ |& R        CALL WaitWhileBusy

7 F/ O9 U6 W# Q1 e+ _        // 检查是否还出错
. N. U* b6 ~0 N0 Y2 w4 p        MOV  DX, dwBaseAddress
6 j* [- I3 @4 G+ M( o4 f  a        ADD  DX, 7
* [+ x9 M' l4 X. w* x        in   AL, DX
9 z9 D% m. Z4 p8 |" E& v        TEST AL, btBit00
; Y! N; L  J) I* \% P8 E        JZ   RetrieveInfo   // 没有错误时则读数据
$ Y  K, K$ `# l4 h( x3 @* }        JMP  LeaveRing0     // 如果还是出错，直接返回
) a2 m% e8 J8 G* A; ^" ^7 O
1 n$ \( r: L$ |9 x! ~        // 读取数据
  h/ j: E) i. H$ e$ j2 I+ k        RetrieveInfo:
8 a0 `6 z2 v. r, X' v# P/ e
        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
        MOV  DX, dwBaseAddress
# m7 _  I4 {9 i8 \/ s" @. Q        CLD
+ r% s3 H  N3 S$ W' N( \
' K- W/ `$ E' K/ w        REP  INSW
& q; `/ n9 @6 b3 T
9 |" p8 G8 n+ Y6 O; e        // 退出Ring0代码
        LeaveRing0:
. N# i# m' w9 T8 U1 s0 _# t8 p
        POPAD
7 Z1 m/ z  x1 }1 D  e+ A1 E        IRETD
- W: y& ]. ]! l/ n: s- Z
        // 激活Ring0代码
        EnterRing0:
. G4 n! k9 K2 _; {/ x. J
        // 修改中断门
        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
* E( F/ S9 D: [9 |) C; e        CLI
- z! k' ?, v; Q  A4 v
        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
6 g$ U- ^! N. n, g$ c0 G+ O3 x& E        MOV CX, WORD PTR [EAX-04h]
; `! S3 s+ B! V/ R& o        MOV dwOldExceptionHook, ECX
2 f# W# T4 U6 g, w& m" k- J
4 b; B9 K: t' T/ L3 _        // 指定新入口
: H+ s: W8 i) h- p, U        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
5 t) o' s7 x5 u$ R5 n        SHR EBX, 10h
# m( S1 s# p0 k, B( }: k        MOV WORD PTR[EAX+02h], BX
* y' a& T8 x8 @4 n
        // 激活Ring0代码
        INT nHookExceptionNo

4 J! n$ l9 J" y! P7 u3 W# N        // 复原入口
' U1 S4 t% I* E1 E        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
+ ^$ W# a  b! c! ]; Y( M# e        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
$ o0 O) d+ k7 d+ G. n  c2 I0 f        STI
    }
    if(!bIsFirst)
- r% r$ \3 E; Q* _    {
        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
$ g$ ~& `$ q2 ]- ^. g1 W        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
8 I! E8 a% D; K# Y- ]    }
}
. R: Y0 g3 G2 X0 V2 t//---------------------------------------------------------------------------
6 L6 j! F& R+ n/ q0 D1 K$ V// 调用方法：
4 \9 x6 x" E  i  }) J+ e4 Ovoid __fastcall TForm1::Button1Click(TObject *Sender)
  ^3 J9 X/ Y) J( f{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}
6 C# W! i8 X# Q