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

天云上人

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

1. 
   
2. #include "StdAfx.h"
   ( k+ \' e5 R$ l9 I9 O! j5 l& w
3. #include ".\puiddisk.h"
   6 M+ I) }3 J$ z
4. #define _WIN32_DCOM
   
5. #include <iostream>
   7 x$ G, P3 i$ n! r3 U. P# W
6. using namespace std;
   
7. #include <comdef.h>
   
8. #include <Wbemidl.h>
   6 x9 N0 H7 J9 `7 C% A
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    1 C$ E$ ]) v9 v; k
11. CpuIDDisk::CpuIDDisk(void)
    ! w; l; O- m9 Z: P
12. {
    
13.     GetInfomation();
    ; P  ~9 M0 e& [- Y" b* f5 Q7 T
14. }
    
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    . `2 ]+ z1 w1 f% U4 M6 R
17. {
    # ]# t$ {0 e# V
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    9 @) A1 [1 ?- X
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    ' _: D! v, X# r  L
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    
25.     {
    ) p" O7 {# l$ G# A1 |, `' _0 L1 f
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    - G, L. x1 d: V7 t: B2 m
27.     }
    ' J* G/ d0 o; j! B4 a( k3 a4 ]
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    6 G. `; c! M) u1 o" D0 S
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    + U  M# X! D6 G5 F; v& `: k
32.         -1,                          // COM authentication
    0 o% {- C4 V4 U6 T0 @$ {
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    8 a$ J- `: U2 y: U
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    6 @4 [+ D! \2 E
40.         );
    
41.                      
    6 l/ F* z, H; |( e+ g; E! o
42.     if (FAILED(hres))
    
43.     {
    
44.         CoUninitialize();
    , x# ?* F% F7 \' X
45.         return 1;                    // Program has failed.
      h" _5 l6 I5 `3 B+ l/ T  {4 N
46.     }
    
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    2 ~5 G( o$ }6 k) U5 R
49.     //步骤3： Obtain the initial locator to WMI
      B% z  D) o3 G; l6 ^
50.     IWbemLocator *pLoc = NULL;
    8 y! D- D- i5 k4 _" @# P
51.     hres = CoCreateInstance(
    ! \1 J; i) i$ x, F
52.         CLSID_WbemLocator,            
    ) b2 z5 f( L9 j' X; o7 {0 g
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    % F: S  z1 V; l. M% Q0 b
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    : @) N- s4 _0 ]+ A6 u( j, q
56. 
    $ U* o) }: G6 ~! A3 N
57.     if (FAILED(hres))
    
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    
62. 
    & s4 B+ o. S4 v6 o
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    , o% L; p  [: B# f6 Y+ `
64.     IWbemServices *pSvc = NULL;
    
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
    7 l. z( [+ L2 p
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    ! Y% Z; J. D7 e1 c0 i6 h4 y
72.          0,                       // Context object
    $ E/ w+ G% V3 A6 o/ N0 ^  _
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    % P$ `' q- H& ]& E; `/ D: [
75.    
    
76.     if (FAILED(hres))
    
77.     {
    
78.         pLoc->Release();     
    
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    ' H& x2 ]# M' Z$ e
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    ! `' H3 W6 G0 A. b% k% l' G
83.     hres = CoSetProxyBlanket(
    2 ]% c; m) @7 i9 P2 p
84.        pSvc,                        // Indicates the proxy to set
    6 E. O! O2 w; _% n3 w( K( |( U9 u
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    5 @0 }7 K0 X3 ]& Z3 d6 b
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    : c1 Z1 ?# M# E# n" k
87.        NULL,                        // Server principal name
    1 h  h2 t5 p! V& G) l& I/ F0 |) F) J
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
    4 |/ A  M& c8 u& M6 n
91.        EOAC_NONE                    // proxy capabilities
    % P4 f: o: n3 G. }. M, Y
92.     );
    
93. 
    
94.     if (FAILED(hres))
    
95.     {
    
96.         pSvc->Release();
    
97.         pLoc->Release();     
    
98.         CoUninitialize();
    
99.         return 1;
    ' u# s* v2 D  J: @$ @
100.     }
     / B7 c! x& y3 p) d1 k
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     4 h4 w1 a% L5 I" c% Q. {" |* U
103.     IEnumWbemClassObject* pEnumerator = NULL;
     * t$ _( t$ W5 l% b3 T
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     $ ]' n3 y/ `  z6 _3 E9 c' C7 V9 Y
106.         bstr_t("WQL"),
     ; Q; ?- _! Z/ h& `
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     - l; ]- C$ {; q4 ^( h
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     4 \9 B5 e6 i( ~
109.         NULL,
     ! Q* @; G( _9 Y+ z$ F- a8 v0 D
110.         &pEnumerator);
     1 G, R2 Q* O+ E) p( X8 n
111.    
     . L3 d6 H- M4 J/ ?
112.     if (FAILED(hres))
     
113.     {
     
114.         pSvc->Release();
     + q5 |/ e& n) u: Z! ^: ~
115.         pLoc->Release();
     
116.         CoUninitialize();
     
117.         return 1;
     
118.     }
     
119.     // 步骤7：Get the data from the query
     9 ?- I$ J3 t$ M3 w( [  c* o8 P; j
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     % D4 p8 u3 R* R6 y% V6 }
123.     {
     + B* }' |2 R- |0 r+ i# F9 v* P
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     " e' x" r: u) q: C3 R
125.             &pclsObj, &uReturn);
     
126. 
     , O6 U2 A. _# ^' E7 Y* ?
127.         if(0 == uReturn)
     % H" W; C" _0 R" I
128.         {
     
129.             break;
     $ n7 Y6 w5 z6 @/ f5 [
130.         }
     
131.         VARIANT vtProp;
     ! Q  m7 y% a* F4 m/ y, |
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     + q+ l: [1 Y- q& V! _! d$ c$ P2 j
135.     }
     0 Y# a) o0 i- e8 N
136. 
     
137.     //计算硬盘系列号
     $ j! C' p$ E* \& c- G6 S
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     5 y2 A- o$ ~  h$ a7 ~  Q- _
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     ) l' ?- I; M" E2 U$ W& \6 E9 n
142.         NULL,
     / D' Z' H; v+ i  p
143.         &pEnumerator);
     
144. 
     
145.     if (FAILED(hres))
     
146.     {
     2 N( E( {* \0 n) U4 ?
147.         pSvc->Release();
     
148.         pLoc->Release();
     
149.         CoUninitialize();
     $ A; _, w* J) c  `$ O* e4 c
150.         return 1;
     
151.     }
     
152.     while (pEnumerator)
     
153.     {
     8 f! w# v9 b0 F4 L
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     
156. 
     
157.         if(0 == uReturn)
     9 y* \  J3 b$ t) G. _9 U! A  l
158.         {
     
159.             break;
     & }" x/ |4 p! c% N) E$ k+ O/ r
160.         }
     
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     2 b) a: ]' I# M1 V
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     7 A! a( Q$ I* A/ n
166.     }
     
167. 
     
168.     pSvc->Release();
     3 }, W: _* H; ?. r9 Q/ Q9 C3 |
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     ( G" F$ A2 l+ x7 Y1 |
171.     pclsObj->Release();
     8 ?0 c, u- H5 @% C8 a% D1 ?/ x$ c
172.     CoUninitialize();
     
173. 
     0 U: ^1 h# H) i- |  k5 V
174.     return 0;   
     
175. }
     0 f! q. D. l! k

复制代码

天云上人

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

#include <WinIOCtl.h>
& a9 l5 [- W- m" s" O#include <stdio.h>

#pragma inline
! A; \( l% {1 n/ z/ `$ T//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
6 j: ~! t2 L+ E6 B# A! g#define DFP_GET_VERSION         SMART_GET_VERSION
- f. V8 y  y/ u. a#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
/ J/ W+ D4 H$ H#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
3 J: Q; d7 |) s) x+ D
* n5 ^, q' t+ @" n- p( K! [const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
1 s* e% u9 u- B( o/ N
" ]: v) B; k: o: u5 c  D. oconst int MAX_IDE_DRIVES = 4;
" w7 s7 H/ l& ], P
6 }) l8 H3 ?- ?/ I// SCSI专用变量
1 n- E  s) S; |5 iconst DWORD FILE_DEVICE_SCSI             = 0x0000001B;
const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
7 ?/ b/ i5 k' x$ j% Z. ^6 \# h5 gconst DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
% e6 m, S7 c% X; i: dconst DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
+ |6 c8 }: w5 A1 `* i! ^, k# A5 w  Z
typedef struct _SRB_IO_CONTROL
' s7 ~# p" C! D: u* A  v{
    ULONG HeaderLength;
    UCHAR Signature[8];
    ULONG Timeout;
# a; @' H& D  q5 k    ULONG ControlCode;
    ULONG ReturnCode;
    ULONG Length;
7 a; h5 }" T, c& g}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

* M( F* R6 x! l+ M% V// 辅助函数
, P# K1 m. L$ `6 j7 n7 zchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
2 Y+ U3 I8 A! }& q3 M$ X        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
: L7 U8 G/ @& R2 Vvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
2 b6 c4 S- ~$ a8 V& V8 hvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

// SCSI读取函数(for NT/2000/XP)
/ H$ i6 z% A! v+ BString __fastcall ReadIDEDriveAsScsiDriveOnNT();
0 w# Q# r  X; z/ K/ K( a//---------------------------------------------------------------------------
// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
; q* k9 `: |2 C' |9 G{
    switch(Win32Platform)
% |+ I- B( q+ ?. i9 K& R    {
  \/ `+ V0 g$ p        case VER_PLATFORM_WIN32_WINDOWS:
            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
        case VER_PLATFORM_WIN32_NT:
" B+ O) U* Y  ~# w            ReadPhysicalDriveOnNT(pSerList, pModeList);
5 r0 p4 q1 E$ K. M( \, j            break;
6 p0 o9 U+ W7 }: m3 W  L  y, P        default:
8 M# B- Z' y; t! X            break;
    }
}
//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
& c  Q* P3 u; `8 }8 I* ~{
    static char szResBuf[1024];
    int nIndex = 0;
% Y- _: g3 z; q9 j& K  |    int nPosition = 0;

    // Each integer has two characters stored in it backwards
0 H' C5 [8 z2 n/ p( a+ I! H' V    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
+ O$ K) D' f9 S3 `    {
        // Get high BYTE for 1st character
) r6 `% ?8 p: n- g1 y        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
$ U% V+ X$ y  ?7 u        nPosition++;
. S, L- [5 d% B$ j
        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
( T; J8 C0 k9 T" q% Y+ q- Y        nPosition++;
6 ^  e) E$ j! O! Q: [- `1 b    }
" ~) K  k% \+ h$ Z
    // End the string
& u- F' T0 k1 A$ `    szResBuf[nPosition] = '\0';
6 X: v: v& A2 c0 A" }3 a$ Y
    // Cut off the trailing blanks
5 l# Z4 j) ~; _) O: {    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';
2 A. D$ T& t& `
; `% U- R4 G. E* o' U& B: W    return szResBuf;
( F% p  v4 K# {, h' f: b}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
) @- {: N) J7 l* U7 C( {//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
" M/ b# p; ^. `# K. z; H5 |void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
* W0 e( b* {$ X: N' `    // 输出参数
# \+ U! _0 c- [. [, K+ x! E    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];
' b( B: i; l& u' b6 j
) Y0 r( a$ q7 V8 A3 o+ i! |8 d  Q        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
8 R! C( u: p* ^* }1 R# f; R        hPhysicalDriveIOCTL = CreateFile(szDriveName,
. Y4 k( k% V) `/ d2 N# @                        GENERIC_READ | GENERIC_WRITE,
% l" ?4 N0 a. \% W                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);
; i0 J$ M0 W) c1 T4 P
        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
0 k( D6 j* ?/ I0 j; ^( B5 ^        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;

" _9 m& y4 l' B! l' j8 u( Z7 E            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

: C, k! h( v9 a; C6 l) X4 Q- Y            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
% e- ?% o; U, O: V0 \5 J; ~! e                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
4 y1 _9 |. ]1 ]0 u0 \( h            {
! S( x7 _3 p* a  E. m, J& R                continue;
9 o9 D' J" |' Z; ~, h            }

            if(gvopVersionParams.bIDEDeviceMap > 0)
# n( s* n% v% `            {
$ c- R6 C$ O& O' }" T& v6 d                // IDE or ATAPI IDENTIFY cmd
                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,
. j" C# X$ ^  P2 u- F0 b                // otherwise use the IDE_ATA_IDENTIFY command
/ |: Y1 S% d" y3 t% R6 V                // 具体所得结果请参考头文件中的说明
" @3 _9 _0 P' W- ^; B) ]3 K                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
5 A. }3 ^% H  l6 v; A  S. `                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
8 J: Y* H7 u0 y                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
9 S# u8 D% Q/ w                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

4 @3 |- Q) q, s) W2 i; e                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
1 c1 r+ n4 E# i1 O- V/ r                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
                    DWORD dwDiskData[256];
  y2 r: A; X* N$ s: I7 G- J' A                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                    char szSerialNumber[21];
+ L% u+ M+ K% A7 g' S3 _8 t. \; t                    char szModelNumber[41];

. \5 W2 N. D: y# n: h                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
) B9 W3 |2 a' Z+ t* _                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
7 D0 J7 M5 a5 z, A9 j
                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
5 w3 y& o  p6 r* c! S/ G3 E/ p" @. x                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
4 p% U( I1 X: R9 b% B
/ Z% l" t$ N6 Z% W                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
                }
            }
& G8 x) @8 o& m+ h            CloseHandle (hPhysicalDriveIOCTL);
- w( {2 E2 F. S8 K" `. O1 K        }
( _8 r7 p' I1 c. j) g' v+ b1 @. G    }
  [" S2 N! S, P) d. H/ y# Z2 s5 U}
//---------------------------------------------------------------------------
; f3 d0 B& L6 |/ o// DoIdentify
6 T8 _: E* h0 l2 c: o- Xbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
! f4 Q% A6 W& T4 {{
6 y, R+ P0 s3 P8 N    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
* h$ C+ g2 K6 ?1 d# G    pSCIP->irDriveRegs.bFeaturesReg = 0;
& ~0 F) s# w! |( B4 g; e    pSCIP->irDriveRegs.bSectorCountReg  = 1;
' _! t# W5 v7 i$ M2 e    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
' _' k* r; a' n" Z3 }/ ^    pSCIP->irDriveRegs.bCylHighReg = 0;
- `* y# a. w  d' h6 r
  N; d1 Y  U  S+ x    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
3 T4 W8 r; s% [0 x4 o/ V9 ]* M) `5 @4 d    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
& L" X* O( r/ O& K" ]5 _    pSCIP->bDriveNumber = btDriveNum;
- w0 f# K0 p; I! B( p    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
5 I1 n! A- X1 g1 K0 \           sizeof(SENDCMDINPARAMS) - 1,
" f4 g# P) D) _* w# n  s! D           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
( U. G% K3 b% {}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
7 {9 Q/ e& ^+ q4 M// ReadPhysicalDriveOnW9X
9 N: P  w: @$ S6 n. Kvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
0 y6 s- j' q2 ?" }8 V. ?    WORD wOutData[256];
  C; U8 V4 m3 T) n/ g  x! H    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
$ q% f7 _+ {6 e5 `- o6 ]    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
+ Q& |" p7 \2 S4 x1 v' a4 Z        bool bIsIDEExist;
$ J( d% y- A$ f! W$ H        bool IsDiskExist;
/ o" C1 y0 H# R* \2 F3 Z
7 J/ i  c5 z. y/ Y) I; M9 G        switch(nDrive / 2)
* }5 F* D0 {) {8 q8 F        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }

$ G2 E  q3 @2 f, l5 `% h- ]        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
! `% M( R) ?$ J
. d0 p/ r4 {* C        // 进入Ring0
! L8 v& ^5 [* @8 r! D% i6 l        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
- r3 }$ T: i6 J% [                bIsIDEExist, IsDiskExist, wOutData);
    }

    // 开始读取
    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
% B2 X3 q+ g) R$ L8 W        BYTE btMasterSlave;         // Master Or Slave
% c  S5 {8 }1 k* T) u        bool bIsIDEExist;
        bool bIsDiskExist;
1 h/ W+ I1 Y; @( _8 n; C/ F8 q        switch(nDrive / 2)
, r  S& ~  I0 F4 q" n8 o        {
5 V* n/ \% v+ h, K; c            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
( K3 l1 x' V# j4 v* K% t2 l            case 2: dwBaseAddress = 0x01E8; break;
: ^% n5 z. F& K: s# a# ~5 d! o4 ]            case 3: dwBaseAddress = 0x0168; break;
        }
& q6 ^! Y. e8 ?8 c; J- m
, H& x0 E7 V/ ]3 c. P; A; ]8 c: X3 P        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

0 V' i" ]9 V; B9 a7 ^        // 进入Ring0
1 N+ r6 m6 e  e1 a' z6 W) }) ^        bIsIDEExist  = false;
        bIsDiskExist = false;
2 b6 U/ C! A. s: H, p, f        ZeroMemory(wOutData, sizeof(wOutData));
% P5 U+ @/ w. K# L# |
$ w+ C( M" [2 r$ i        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
% E# a+ a5 b/ y% p% q                bIsIDEExist, bIsDiskExist, wOutData);

        if(bIsIDEExist && bIsDiskExist)
        {
            DWORD dwDiskData[256];
" R6 c) p# r, t- l6 w: a7 Z5 E5 a            char  szSerialNumber[21];
- g; M6 }# O2 t! f& x, L* N            char  szModelNumber[41];
, \0 H4 ]( t- a. j
! k* }7 [' P3 o; L: S            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];
9 L+ z' b0 A! s3 T0 }3 B
            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

0 L: E5 j$ o& ], H: [, o            // 取模型号
! D9 k* q, E# n' j' s- c: A- P            ZeroMemory(szModelNumber, sizeof(szModelNumber));
9 E2 S! C: P/ b            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
. y" O0 l& r. d- H  W
            pSerList->Add(szSerialNumber);
. s+ H" C) H7 ]! v5 Z            pModeList->Add(szModelNumber);
' U4 H5 j& E9 c; O        }
    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
$ Y$ f% O1 i3 J( _+ n0 ]! Q* c//---------------------------------------------------------------------------
& R% x1 F$ k8 Q8 A" J, L- S// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
- _; r9 z8 E! N& K  T// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
7 w+ M4 S( u% T. V2 t1 @// ReadPhysicalDriveOnW9X_Ring0()
4 m4 \/ @. |! h! T- c; J//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
# f+ J7 S2 A  j+ f* D4 G8 h" W) y// btMasterSlave = Master(0xA0) Or Slave(0xB0)
- X- _' ^  ^1 c//---------------------------------------------------------------------------
8 G8 I5 k# E& \/ B$ ~void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
" R& v0 m' `9 |% e; S    const int nHookExceptionNo = 5;
$ Y3 k- \5 D+ [5 s- ^! `" W; z
    BYTE  btIsIDEExist = 0;
* i. {, Y, a2 I: R7 ~' c, v    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;
* O% X3 b5 d3 U, `
$ x: c& u( }: h& F( ?. [3 C/ O4 Z    const BYTE btBit00 = 0x01;
  k$ Q0 ?, d' J, p' Z' |  Q' w    // const BYTE btBit02 = 0x04;
$ Q5 o5 g" w( [9 m    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
) C/ P0 a7 S/ [$ {( o! \, m    const BYTE btBusy = btBit07;
0 l1 ^9 d+ l0 m- \3 }    const BYTE btAtaCmd   = 0xEC;
( v  L' U& ~% ]9 y! K( I    const BYTE btAtapiCmd = 0xA1;

    __asm
0 c& S  U7 `* \$ k: m8 \: U9 `    {
; @, Y8 e- _0 C1 t$ w        // 必须先执行这条语句
4 W1 r; d/ K* [$ K" q        JMP EnterRing0
7 M+ Q/ G% {- w
        // 定义过程
7 N) Q% ]+ }0 j2 b1 V( @: F        // 等待IDE设备直到其不为忙为止
. e# J# S* X0 |3 u8 Y. A4 v3 }' i        WaitWhileBusy proc
+ O+ S" u# ~1 F# E+ T% k) R' {5 b
        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
        ADD  DX, 7

$ _, t8 C3 n, P1 W! f4 O        LoopWhileBusy:

) y) V/ `# V2 k& W+ f        DEC  EBX
        CMP  EBX, 0
        JZ   Timeout
        in   AL, DX
4 e) b; a2 J7 s  o        TEST AL, btBusy
( h' _# l/ P" W$ m        JNZ  LoopWhileBusy
        JMP  DriveReady
8 Y) y/ s) z, D
7 u5 s0 X% x/ }" {        // 超时，直接退出
& d8 N+ `- v) I5 X* b        Timeout:
        JMP  LeaveRing0
. ^0 l; I) `" A/ R, G$ P- J! K        DriveReady:
        RET
        ENDP   // End of WaitWhileBusy Procedure
* d4 @+ M, B) ^5 Z8 a, ^* X
        // 设置主盘和从盘标志
        SelectDevice proc
4 C& w! f& e0 m+ ^# Q5 F
        MOV  DX, dwBaseAddress
        ADD  DX, 6
2 q/ u2 f$ y' h, i4 e0 w        MOV  AL, btMasterSlave

        out  DX, AL
        RET

        ENDP  // End of SelectDevice Procedure
9 Q0 k& }  c5 J6 v# y: t2 P( h6 V$ C
9 {' B' Q6 P$ r& B1 M' a        // 向IDE设备发送存取指令
        SendCmd proc
: B+ }$ @4 f1 e+ f3 d( w# t
        MOV DX, dwBaseAddress
        ADD DX, 7
! d& I6 N3 U: m: m/ G) ?        MOV AL, BL // BL是主从盘标识，在过程外设置
9 i" d+ W8 \4 Y; F5 L* _! O- K        out DX, AL
        RET
        ENDP  // End of SendCmd Procedure

5 l5 z7 A, g% k. q. M' H9 K        // Ring0代码
8 h! }) j, `  H0 {' f# }        Ring0Proc:
2 M3 _6 L* h& D8 D2 O; O6 _        PUSHAD
8 `7 u5 D6 O6 j# `1 z2 W& i        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
: ^& U  c( |( Y/ K8 c, Q        ADD DX, 7
1 f  K# V  L$ ?3 G        in  AL,DX

7 t/ U+ M3 O0 C- m" G7 @7 H        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
$ O+ a6 D& Q9 i$ M9 u( r        JZ  LeaveRing0
        CMP AL, 0x7F
* O" p: l, \! Q1 H/ c        JZ  LeaveRing0

        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1
/ }; V; _# R+ B! y
        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
$ x' w1 z$ s  a# l        CALL SelectDevice

* V8 _4 L. t4 E* m        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
* s% m" c" D0 v& S) H, X        CMP  btIsFirst, 1
' R5 t( c! K: B" W5 d6 i5 r; V        JZ   LeaveRing0

: z$ E$ d! s( V' `        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy

        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
! I. A7 I+ @" Y9 p+ Z        JZ   LeaveRing0
. H" ?' N& i; l. ~+ K
        // 设置驱动器存在标志
) S9 T3 D9 q8 i; v6 a        MOV  btIsDiskExist, 1
3 l- {9 ?2 P3 V# o9 @& ~
1 i6 h% B1 \1 f        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
' G4 h" }; o- J9 E0 v5 d        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
        CALL WaitWhileBusy
6 `7 c( M- A  b5 T3 [  {2 x
5 i: o& j  D+ ]% q5 P+ ~) j6 J        // 检查是否出错
7 N) n+ X3 c/ o8 Z1 G        MOV  DX, dwBaseAddress
: \! g7 w1 H; W1 g7 @# e        ADD  DX, 7

        in   AL, DX
/ R: P( S, Z" M; r9 C# `
9 a: j/ T, B3 l! I        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据

% b, G. g& Z+ `1 k        // 如果出错，则进一步尝试使用ATAPI设备命令
, P& G4 b; Y: q7 P6 ]7 L) F% D  P2 @4 q        CALL WaitWhileBusy
1 Z2 z) ^8 a( {  l) G7 g        CALL SelectDevice
! j; Q3 V+ E4 e1 h3 C6 u! C1 ]& e        MOV  BL, btAtapiCmd
        CALL SendCmd
  S3 _# m  k, R' C# F8 G3 s        CALL WaitWhileBusy
" o- n4 e; k- f* I/ Q( H$ X
6 M' U5 {) M2 D/ q$ L        // 检查是否还出错
; u, q: k- K7 ^" L        MOV  DX, dwBaseAddress
; |" z8 D$ b$ u: A3 |4 a- [1 I        ADD  DX, 7
7 w0 w- i1 L$ \        in   AL, DX
+ i# }. o. n$ T6 L% X3 E5 n! F1 @        TEST AL, btBit00
/ F* g" g9 N( l% o        JZ   RetrieveInfo   // 没有错误时则读数据
; ]0 x7 J) f8 k0 {( U1 q9 q( B        JMP  LeaveRing0     // 如果还是出错，直接返回

        // 读取数据
( [- _. y" v+ E" ?' {" K        RetrieveInfo:

' p: {; f* ]% \" a# V        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
4 }% ?7 I' @: u( }        MOV  DX, dwBaseAddress
        CLD
; Q2 n8 V6 w7 ^' ?' y( a. S
        REP  INSW

        // 退出Ring0代码
        LeaveRing0:

- E7 W0 @( [; `( J' l" z        POPAD
        IRETD

# q8 Y! l3 ?! C7 v' \$ E        // 激活Ring0代码
        EnterRing0:
' a- D" m5 A/ U; p' t& o* m
        // 修改中断门
; a0 ^0 H2 j4 ?  e6 z        SIDT FWORD PTR btIDTR1
. |; d0 i# s% F  K+ P        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI
* e8 P4 T& `3 E$ C0 Q1 U' h
        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
7 X% Z' ~4 c1 i" h$ J% e/ \        MOV CX, WORD PTR [EAX-04h]
0 d+ R* d( s3 w# Y! o8 z  j3 {        MOV dwOldExceptionHook, ECX

        // 指定新入口
: |! W8 ], W# F$ t* y        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
6 a5 x1 U0 R) V3 C/ e        SHR EBX, 10h
5 h1 l; ]! V) x& B' q6 V        MOV WORD PTR[EAX+02h], BX

' t# x+ x$ }' P: E7 d9 Q' q5 k        // 激活Ring0代码
3 F3 b. M$ P, b+ J        INT nHookExceptionNo
+ G0 q; k- F( W
8 v- y5 E0 c. J. I        // 复原入口
        MOV ECX,dwOldExceptionHook
- t% x' J0 H7 F& X) r& X        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
. H/ \; S! ^. i& }1 e7 s6 r        MOV WORD PTR[EAX+02h], CX
1 G8 r. _0 n2 [; H5 T        STI
    }
    if(!bIsFirst)
5 J7 X0 G/ `7 [5 _    {
        bIsIDEExist  = (bool)btIsIDEExist;
" n8 G* \. I1 K, p; B8 U        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
}
4 s, w, B& L3 I% r8 A; [7 Z//---------------------------------------------------------------------------
// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
9 {9 L. T, D! F5 Z, t3 P7 a3 ^}