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

天云上人

代码框架，你所要做的仅是修改WQL语句，具体可看MSDN。以下代码为简介起见，一次返回所有的CPUID或硬盘厂商系列号
' `& [. u# Q1 a2 f7 _! x9 X- _

1. 
   
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   ; u$ y" l6 ?) g8 Q+ l% G
5. #include <iostream>
   / r. O$ g  {/ z6 ]! R
6. using namespace std;
   
7. #include <comdef.h>
   4 |/ z5 E. V$ N7 W; @
8. #include <Wbemidl.h>
   5 x4 n8 o# C. Z0 g
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    2 @' S2 u* D3 P! j# w* t/ l
11. CpuIDDisk::CpuIDDisk(void)
    8 p6 p! Z% g5 v) B
12. {
    
13.     GetInfomation();
    
14. }
    ( o; v5 L: ~# v# g9 @1 Q
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    " Z. ~2 [. e* z
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    . \; |* _% ]" i/ [8 c1 J- t
20. {
    
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    : |# w( K& m4 A
25.     {
    ; A1 @1 t3 h' O# c! j2 `
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    7 i6 p: P$ L! ]* Q- r6 f. R
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    % V' `& u* o6 i; B( T# Y
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    . V4 g4 u8 R2 P4 V$ @! j9 Z
32.         -1,                          // COM authentication
    , i8 N3 Q) o1 f7 X1 l/ Z# ]
33.         NULL,                        // Authentication services
    " L( s' ]; Q) |' O7 E. g# d' [, J$ d
34.         NULL,                        // Reserved
    ! }$ P7 x! E3 W$ |' H) Y# @! o' N
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    + V- }8 e) {" Z4 a& I8 I$ T
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    ; p/ p9 X8 Q: j  c# W
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    ( w, n: q4 ?, j
40.         );
    
41.                      
      E6 m( x4 {. m2 I" t5 w
42.     if (FAILED(hres))
    4 W' D. O) B( z: ?4 t. q
43.     {
    
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    
46.     }
    
47.    
    - {9 t/ m6 s2 B2 d4 R- k3 f; P( S
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    ' u: `- b2 u1 a2 }% t6 ~
50.     IWbemLocator *pLoc = NULL;
    % v% c# e' x3 i4 e* G1 m% N
51.     hres = CoCreateInstance(
    7 y; w" C* f$ P6 v1 R! b
52.         CLSID_WbemLocator,            
    
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    - _0 r0 ^' H& N! ?( [$ W( D
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    / |3 n8 Q+ z! q: |* l# G3 B( H
56. 
    # s1 E+ B" V  p0 r0 w6 C2 l
57.     if (FAILED(hres))
    4 u1 z5 A3 G/ `$ _8 S
58.     {
    . J; N; W& q2 s, U, g; v. h( C
59.         CoUninitialize();
    3 T- P9 V( }. [% F8 ]
60.         return 1;//Failed to create IWbemLocator object
    * [7 L! S+ u( O0 f7 {8 `
61.     }
    3 _; E% J- O5 s: L- I- m; X5 B- S
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    " Q5 |- ^+ \- A1 s) r
65.     hres = pLoc->ConnectServer(
    . E! O& u- I1 [% j0 N3 R8 S4 A
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    . V9 n6 q$ x' N) r* g2 S1 |* M
67.          NULL,                    // User name. NULL = current user
    , T$ F+ W9 k* I
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    # l5 N. s& ?; o' D
71.          0,                       // Authority (e.g. Kerberos)
    4 j! T+ z' Z2 W
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    , L$ [! M4 l0 _, }4 \) f
74.          );
    
75.    
    
76.     if (FAILED(hres))
    
77.     {
    1 Z" U" J5 v1 B" W+ o# ~. X) G
78.         pLoc->Release();     
    
79.         CoUninitialize();
    - |0 q' t3 r) Z# C* S* V
80.         return 1;                // Program has failed.
    
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    
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
    9 M& v2 u7 b( C1 I9 R" c
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    
93. 
    
94.     if (FAILED(hres))
    
95.     {
    
96.         pSvc->Release();
    
97.         pLoc->Release();     
    . N7 W6 e  L. n# E
98.         CoUninitialize();
    
99.         return 1;
    7 p" g1 a) {8 `' z6 U, ?6 ?! l
100.     }
     
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
       V' P) K0 `1 P; Z8 [1 j
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     0 W; |: S+ K; I* m/ H( F# g
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     
110.         &pEnumerator);
     0 ^. ^9 t7 K/ `# ^+ ^
111.    
     
112.     if (FAILED(hres))
     # _% Y0 e, o( b3 O4 a& |; t2 ?; U
113.     {
     
114.         pSvc->Release();
       \% G& i/ Z/ i- s
115.         pLoc->Release();
     4 t" |7 d( L9 `% G$ a) Q
116.         CoUninitialize();
     $ N% D; j1 Y" j
117.         return 1;
     ' p$ D- Y/ J' u( i
118.     }
     
119.     // 步骤7：Get the data from the query
     ' D+ N! y5 R2 T- p5 Y) M! y
120.     IWbemClassObject *pclsObj;
     9 E+ m8 x' O' M" o
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     
128.         {
     ' S+ {4 [% X* z. u2 c$ I. @, I1 y( E; U
129.             break;
     
130.         }
     
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     ) Z; d2 {  b7 G2 i! f$ R
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     9 V( j" U1 ]7 q  T7 D
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     
136. 
     
137.     //计算硬盘系列号
     
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     % ?; J' i, e; y4 I+ H  D
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     
143.         &pEnumerator);
     ( ~: K, v: S$ |8 `% i; F
144. 
     , o' i, j- D, v( c! j7 M9 D
145.     if (FAILED(hres))
     ' r* R/ _/ N, X3 r9 i* `/ E5 I
146.     {
     
147.         pSvc->Release();
     
148.         pLoc->Release();
     
149.         CoUninitialize();
     
150.         return 1;
     7 r0 x9 Y1 ^: [3 d  [2 o& y
151.     }
     . y' v- b4 m2 P  E
152.     while (pEnumerator)
     : \, [' P0 H) P6 K; ]
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     * j6 L; V: Q5 v( e) R* \; z' P
156. 
     
157.         if(0 == uReturn)
     3 y4 ?6 _' U: s: `, u
158.         {
     
159.             break;
     
160.         }
     $ p# O# |1 ^' h7 q+ ~
161. 
     , [) F; x0 r' u# _
162.         VARIANT vtProp;
     # y  n% Y) p. o
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     % y. C7 j% M' a0 Z/ m$ C7 t
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     . m, G; J+ ~3 X$ h
166.     }
     
167. 
     6 |6 i2 n' H4 b. N- C3 H
168.     pSvc->Release();
     % X; p, d9 B+ ^
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     9 M/ G5 }. L0 x+ W, {) u
172.     CoUninitialize();
     ) S' p% p. d5 T- ]& q3 ^" e5 l) }
173. 
     
174.     return 0;   
     , m" H9 r* o, j# b8 f
175. }
     4 N5 f; Q( X5 Y. u- Z+ {+ ]

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
  k+ S5 N: s" q$ L% H. ]2 c" B0 Z
: I5 _7 `# K4 l6 v. f  p1 d5 \3 i% m#include <WinIOCtl.h>
* R2 g: Z0 B* c# q8 ~3 s6 O#include <stdio.h>

4 |! o  w' z: d#pragma inline
3 y4 z7 E+ t! l//---------------------------------------------------------------------------
+ @9 h, e" G( t# o. @* u- c// IDE NT/2000/XP专用变量
#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
) n( a  L* E0 ^, o! [2 [: F. ?
const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
4 S. Q2 j( B2 {) ]3 f% ~1 |const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
) w( m) |0 S6 z1 x
const int MAX_IDE_DRIVES = 4;

! k3 M; ~  L: D5 e// SCSI专用变量
  w$ a; R" K- }const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
) w5 X) U; f6 C  H( Aconst DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
- z% E$ c# V, l$ |7 A! p3 p
5 x  g0 w0 }& f# q* Itypedef struct _SRB_IO_CONTROL
, P) }8 n1 E4 y0 d- N6 N8 g{
    ULONG HeaderLength;
9 Z( c: f/ ?9 o5 T9 R    UCHAR Signature[8];
    ULONG Timeout;
% E+ s# }$ W0 E, A# D0 T# e3 x    ULONG ControlCode;
    ULONG ReturnCode;
    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

// 读取的主函数
0 I3 i" _& R. dvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

// 辅助函数
+ ?, T$ J* S6 B3 a. }  W: echar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
/ v8 J$ l" g2 \3 o+ p1 y1 E4 F. {7 ~// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
: @2 `. O8 F: E4 v" J        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
7 Z) g& J$ ]" R0 G" k; R        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
- _" [9 r% d3 h6 |) Y+ G/ q2 yvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

// SCSI读取函数(for NT/2000/XP)
2 t1 p6 u6 r$ A! K+ w& q$ V" D4 zString __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
8 s1 ]/ B, ?2 P0 S' Q2 h7 F# l: `void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
    switch(Win32Platform)
    {
        case VER_PLATFORM_WIN32_WINDOWS:
; s1 D) w0 ~+ x            ReadPhysicalDriveOnW9X(pSerList, pModeList);
- K5 o. G1 v1 O1 H1 T* O, b% B            break;
        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
* |2 P( P+ y, t+ A7 `        default:
            break;
    }
$ r3 Q& ^8 K. }# j7 D}
& _) G' h% [. b, J! U//---------------------------------------------------------------------------
// ConvertToString
: z" l0 H2 v; D$ c3 g0 Echar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
    static char szResBuf[1024];
* M  c2 B* u. d% l7 ?    int nIndex = 0;
2 Q2 q) P1 r) s3 k    int nPosition = 0;

    // Each integer has two characters stored in it backwards
- c- E7 f' d& |) A4 t4 \7 Q    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
        // Get high BYTE for 1st character
( P2 y( m2 m& H        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;
" X2 l% {6 r. [1 x; ]
        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
    }
/ B0 I4 c7 `, [2 q* j
7 J9 g: N2 r# p3 A5 W1 w4 l5 X: }    // End the string
+ G" g; V) q7 c; J' H5 e( a) c    szResBuf[nPosition] = '\0';

    // Cut off the trailing blanks
9 r( \0 A1 }2 [8 A    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
" N8 D+ b/ m6 {- [        szResBuf[nIndex] = '\0';
( p* F# H3 j3 f' z" O0 Z
( N2 r; E7 A. U    return szResBuf;
}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
5 M' O8 m" V6 K% {: E* I7 o4 M//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
- B& Y+ L# U; u- V  L( ^2 {    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

3 ^3 J# m( i& R% z# d5 S    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
# M* O; \" }. s' h6 l; N    {
        HANDLE hPhysicalDriveIOCTL;
9 d0 \- p. ^9 Z6 a  x  ~, w; Y        char szDriveName[32];
8 {' G+ ]$ k$ C& W+ I  K$ r
        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
; Q6 l- I$ i" E; z+ g  A0 X# |        hPhysicalDriveIOCTL = CreateFile(szDriveName,
2 i8 v3 r/ k4 B# Q7 h9 J" w7 ?7 z                        GENERIC_READ | GENERIC_WRITE,
' N1 x/ n$ m( }3 [+ U                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
0 v# s+ {0 D' U1 F                        OPEN_EXISTING, 0, NULL);
$ M" Q& ^8 H- W8 V  v
2 U* d2 d! B7 N% V8 @7 R7 O        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
5 ~1 A- U9 R4 q/ z            DWORD dwBytesReturned = 0;
2 o0 W: v$ A0 f/ @$ ~            GETVERSIONOUTPARAMS gvopVersionParams;

: E- h0 K8 @5 u% X4 [: o9 L            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
$ r. E0 H: p, Y7 t% ]
6 x; x9 M3 G# y; B            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
  a0 f( G) {( J3 Y; c                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
; g9 {8 n' ]# T; j8 W                    &dwBytesReturned, NULL))
+ y" `- D7 d+ Z" |$ R4 S3 Q2 n/ N            {
                continue;
            }
; r2 c9 k  h; x3 h. v
2 U% [5 D' n8 F7 W9 e7 ?& n- T3 ^( d            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
6 P1 O# w) }8 M3 t; O# n                // IDE or ATAPI IDENTIFY cmd
7 A* t: p- _0 z7 i                BYTE btIDCmd = 0;
( h# m3 a+ m& o8 V3 k  {- s) H                SENDCMDINPARAMS InParams;
, ]  c" E: z+ T0 E3 b# B' `3 Q                // Now, get the ID sector for all IDE devices in the system.
                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
+ D* B$ S5 ?7 ^                // otherwise use the IDE_ATA_IDENTIFY command
; Q0 A+ b7 J1 J- A/ P                // 具体所得结果请参考头文件中的说明
2 E- L7 W, r- [; d6 [                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
' v; X) ^: ?! R- ?, g# _. o, c7 [                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
* V3 M& A# h: K6 Z7 M1 |                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
( m/ B  I( f8 |1 s! B) |
                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
) L8 i$ |  M4 N3 }( q) k3 X                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
6 L$ E5 T9 u7 Q& b$ C/ u4 _$ u2 t7 J                    DWORD dwDiskData[256];
4 X9 u4 ^9 ~/ w* Q( g& ]                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
# @  X; I% h# Y, w9 s8 j6 i                    char szSerialNumber[21];
                    char szModelNumber[41];

                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
# A# ^# m: h- V' P% G                        dwDiskData[i] = pIDSector[i];
! B4 u! W! M! v0 T/ w7 h                    // 取系列号
1 ~; w; }3 s6 f5 k                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
! r* Q* J& M4 e0 d% @% _' [: w0 p                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

/ g+ l2 B" |0 Z7 t: n, g                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
/ o$ K) n2 m& Q/ g1 V+ v/ p                }
8 ^4 F% r, ]! \! r. h& b  B            }
4 w) ]4 L: T/ s9 C3 x& h. `            CloseHandle (hPhysicalDriveIOCTL);
        }
7 U  ^% b# W1 ?& q    }
3 V5 X2 D0 t/ X+ @}
5 o' P7 x7 U# s$ S0 U$ v//---------------------------------------------------------------------------
/ N) y& l6 g/ R// DoIdentify
7 Q7 ^/ x& w* H5 y  p: X) lbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
. R6 ?( `0 @% l4 p" ]              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
' R' x5 p0 t3 W1 L  M              PDWORD pdwBytesReturned)
$ ^3 j1 W9 E5 W, F  Y0 k{
1 t1 _6 S( ]1 l1 J6 H6 ?+ i4 s+ x& b7 p    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
9 ^/ E3 p* V2 s  l  A, \6 I3 |    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

% T& K1 ], \9 n& W* `8 D    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

- Y5 s; V1 Z$ s& ?# ~    // The command can either be IDE identify or ATAPI identify.
) d) \! l/ r0 x! A- e2 j    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
- v1 G& l5 U$ B, P6 s    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
9 t9 I' [; `. P; u+ t5 R           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
+ W; f! N+ r3 E) W. \{
    WORD wOutData[256];
% H; k( L9 M3 ?, n    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
: m1 ?; l0 ^( Y3 C/ j( b& J
  p" J/ `% ^1 J5 ~2 b; w. P# u    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
2 H# U( j0 M: o0 ?1 z    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
5 C5 l, G- j+ |        BYTE btMasterSlave;         // Master Or Slave
3 g6 {/ q  g* Z+ I        bool bIsIDEExist;
" ]! j' Z( l4 R4 K' N0 M. q( j        bool IsDiskExist;

! Z9 w% H, W# j" O% P; h        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
( X2 W# {; Q# W1 H            case 2: dwBaseAddress = 0x01E8; break;
5 h+ T& s1 z  x9 b; E( O            case 3: dwBaseAddress = 0x0168; break;
        }

5 x. H" n( y/ C" k        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
/ P( A; V# m% J; B% Y" O0 x
: Q) _: M% d. {0 }+ Y        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
* B# B6 Q6 c. n                bIsIDEExist, IsDiskExist, wOutData);
1 k1 M2 q( z' p  ~/ M4 S    }

    // 开始读取
3 J" M" p1 i' Y* T" F- ]    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
, x0 g4 B( u3 N+ k5 L& O        WORD dwBaseAddress;
! R( ]7 Z5 S% n9 R        BYTE btMasterSlave;         // Master Or Slave
5 P6 `' c+ [) ?        bool bIsIDEExist;
7 C4 K' D3 `6 ?  ^1 C6 [) W) ?' I        bool bIsDiskExist;
        switch(nDrive / 2)
  k6 _, Z3 r' ?        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
3 p8 F* m. H# f$ `* `3 q            case 3: dwBaseAddress = 0x0168; break;
        }

        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

        // 进入Ring0
        bIsIDEExist  = false;
        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));
) A( \7 g, Q. k( s, f4 u  d* R: W. N
        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
! I- ]9 [) {& ^* H* H6 Y! T                bIsIDEExist, bIsDiskExist, wOutData);
- `' d0 Z' r8 r, p( W; M, s+ w' S
( t) c  ]2 i; t4 o% ?8 u0 X        if(bIsIDEExist && bIsDiskExist)
7 b& j+ R- E0 I        {
            DWORD dwDiskData[256];
" G" y' }; w1 G# A! L# A8 k  l            char  szSerialNumber[21];
% I' `0 w* `' i) y& e- U! X! j            char  szModelNumber[41];
% T/ M. m+ k  T, b. V6 A: h; a2 x
( A6 k' }( q6 `, c            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];

% D7 J7 E* p+ ^% y$ B            // 取系列号
" a4 ?& x% A6 d! o( W/ h            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
. Z3 N, c5 {) G1 T5 {) H
            // 取模型号
+ o6 u# W: t; x4 L            ZeroMemory(szModelNumber, sizeof(szModelNumber));
$ e3 W  V4 l' |            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
        }
    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
! R8 C; c" \& W9 p  u( S7 V//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
" }, \& A4 Z, b// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
% U- U# T  \0 A; i' R# ]. Y  m//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
5 ^5 r' C  i  ?  o* d// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
: G9 g( D1 H2 N/ zvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
  h8 n$ ]& u' q2 r' s        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
1 m" S# H; |, @. ~4 T. b{
8 S. q: ~  D5 ~* \2 u7 Z# V( l    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
% R, D6 b8 f2 ]: F/ h    const int nHookExceptionNo = 5;

    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
6 q! K! W, B) k$ T    WORD  wOutDataBuf[256];

/ M) E) E8 r' S+ X4 Z    BYTE  btIsFirst = (BYTE)bIsFirst;
! O  P4 O+ x- t  l* F
    const BYTE btBit00 = 0x01;
8 I  d# S  D  r  k    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
# e/ M" I  e5 y0 S1 p" V4 [    const BYTE btBit07 = 0x80;
" A% p6 t3 A1 I+ B7 ~% Y1 T8 T    // const BYTE btERR  = btBit00;
1 _3 T8 n' W6 Q# m    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;
" T' G$ i% Z+ Z
    __asm
* [6 d9 k: i8 c; e# b" `    {
$ t+ m/ i/ }4 c* k4 s        // 必须先执行这条语句
( E0 W2 a/ E) l( f# }+ V7 ]$ o( X        JMP EnterRing0

3 V( {8 U, a3 `2 _) n) I! R1 x1 f3 }        // 定义过程
        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc

5 l* S, d) d( P9 U$ d        MOV  EBX, 100000
" @- i3 [" w  I& \        MOV  DX, dwBaseAddress
7 B+ `4 k% K0 V, j        ADD  DX, 7
2 K' F; o5 S3 N, O) W3 e& e
0 g  C! G* ?) U        LoopWhileBusy:

        DEC  EBX
        CMP  EBX, 0
/ x& B! R( Z2 N1 X7 R( c* N# @        JZ   Timeout
        in   AL, DX
        TEST AL, btBusy
8 ?$ V1 p9 B$ F7 H        JNZ  LoopWhileBusy
        JMP  DriveReady
- ?0 |7 z- ]. {0 x$ H. \
        // 超时，直接退出
        Timeout:
! y0 S1 c7 G- r5 A        JMP  LeaveRing0
9 k  R% e  `5 l        DriveReady:
" s# F4 [, z- X7 \2 ~; o        RET
        ENDP   // End of WaitWhileBusy Procedure
8 P+ Y9 Q3 I% o1 a
3 w; F, ]+ @4 t3 M! s$ E; n: _        // 设置主盘和从盘标志
        SelectDevice proc
* x6 K" D/ @* c7 C1 F  C6 \
/ O& u" N9 l; p        MOV  DX, dwBaseAddress
        ADD  DX, 6
( r* Y- }& A6 u7 M* j5 j4 f: {/ W        MOV  AL, btMasterSlave
9 C0 U& H( J  \. j  d$ r
        out  DX, AL
        RET

        ENDP  // End of SelectDevice Procedure

        // 向IDE设备发送存取指令
2 V- ^5 D. z4 Y- L& W5 K; C        SendCmd proc

        MOV DX, dwBaseAddress
        ADD DX, 7
  U+ W2 |. s2 W+ s3 W0 g/ y        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
        RET
        ENDP  // End of SendCmd Procedure
, b6 v6 [3 o' O. w  }
        // Ring0代码
/ W3 _% p& H5 e5 j+ x$ j3 t& P, A/ b        Ring0Proc:
% L* j4 C; d. k  ]+ o        PUSHAD
        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
" E" \. N1 U) |5 y        ADD DX, 7
        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
8 S; u  D& f; T: E* w4 ~        JZ  LeaveRing0
" w- b5 _2 |  [; J. h1 i2 ?        CMP AL, 0x7F
: G7 @( a0 l! S. l/ e& t+ t+ J        JZ  LeaveRing0

( J  B3 ~, ~) r& j9 d        // 设置IDE设备存在标志
" ^! i# u* A4 {6 B        MOV btIsIDEExist, 1
& k6 H9 S& F* B1 ~) p
) p9 s* u/ x# V! c/ h0 v1 T" \, s        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
/ H- \1 M( H* h        CALL WaitWhileBusy
        CALL SelectDevice

: R6 Y$ O: v% ~8 n( A        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
1 `, x! `9 Y5 T; y8 O# W        CMP  btIsFirst, 1
        JZ   LeaveRing0
" ^; z& b  K9 V$ s
        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
, [: O. |' w. ^        CALL WaitWhileBusy
* M9 i( q4 z* V+ n7 u
        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
        JZ   LeaveRing0
; T+ R& t$ l, ~: ~# T! x* {
        // 设置驱动器存在标志
: Z$ I4 x4 [5 J& X" o+ X4 r1 m        MOV  btIsDiskExist, 1

        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
1 K  e3 I, o+ x        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
/ B' g: O/ h: r        CALL WaitWhileBusy
- @- i1 X& L- @" M1 S0 Q% b7 P8 _        CALL SelectDevice    // 设置主从盘标识
- s! Q1 U" K  U: q        MOV  BL, btAtaCmd      // 发送读取命令
' m+ O6 H$ Z' T, d  j" A# w3 l        CALL SendCmd
        CALL WaitWhileBusy
, a0 x$ W9 }! |8 p# P
        // 检查是否出错
; m/ w! i, q$ \8 ]6 S& J        MOV  DX, dwBaseAddress
% S# n! g5 M' m        ADD  DX, 7

        in   AL, DX

4 m9 P$ c: t% Z7 y9 d, o+ x        TEST AL, btBit00
6 v9 _% W6 U: [& T& K; C- _        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
! v' o$ w  F! i, r5 P( e7 J5 h: U        CALL WaitWhileBusy
        CALL SelectDevice
" q% x' Q( q  r' E        MOV  BL, btAtapiCmd
        CALL SendCmd
' n2 g# U$ }+ S' P0 V2 s$ U        CALL WaitWhileBusy
+ n; q6 ]! a3 O2 v% q
        // 检查是否还出错
+ X2 I+ T0 B3 p3 s& @. I        MOV  DX, dwBaseAddress
        ADD  DX, 7
: [) U4 L9 K0 g7 V) z        in   AL, DX
! o9 L5 Q, l( r6 F        TEST AL, btBit00
5 C, F4 ~9 h- w1 m3 [3 @6 A' C9 ^5 u        JZ   RetrieveInfo   // 没有错误时则读数据
; D. R; v+ w7 I7 {$ R        JMP  LeaveRing0     // 如果还是出错，直接返回

        // 读取数据
        RetrieveInfo:
% `" b3 v% F3 N8 P5 ]2 O/ |) w: \
        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
        MOV  DX, dwBaseAddress
& E3 a0 ~. A4 ^/ I$ V        CLD
) W% Y4 m5 [2 p* i
% Y+ W8 ^7 b3 k; a        REP  INSW

! p. `, \4 X, V( E0 W3 r/ X, x1 D+ S        // 退出Ring0代码
# o( L: u4 Q( G+ @        LeaveRing0:

5 x5 H8 W- l. k4 x6 a6 {0 q; V4 m5 \        POPAD
: @' t0 q! W# I! X7 S6 j        IRETD

' q* m5 P& q" A        // 激活Ring0代码
* [8 p! Q7 E/ M; P$ g- }        EnterRing0:
2 x4 |* h& c5 u. R, Z
        // 修改中断门
2 ]* M* P/ d* z        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI

! k) b7 x: j3 |4 Q  t) ~        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX

        // 指定新入口
        LEA EBX, Ring0Proc
" \% M  W- g) r# R+ q* `        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
% X) C  @3 |$ ?        MOV WORD PTR[EAX+02h], BX
& D5 h4 Q- z8 R! i8 Q% X; z; w
        // 激活Ring0代码
        INT nHookExceptionNo
: H4 v2 ?' r+ E
        // 复原入口
5 I: V: F7 j( t' [* V2 u        MOV ECX,dwOldExceptionHook
% O5 I6 V3 R8 i, W% V. [5 B( o  p        MOV WORD PTR[EAX-04h], CX
# {' V& g. k6 W* T        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
        STI
+ l% d8 d  n3 n, h8 ^% V! ?  B    }
( t8 B) x$ N' R! Y0 ~9 N    if(!bIsFirst)
    {
        bIsIDEExist  = (bool)btIsIDEExist;
) i8 R& X) B4 H: g" @        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
; T. [; @, E* w8 w    }
}
//---------------------------------------------------------------------------
9 W8 q0 ^9 l( b3 \: K0 E2 u) K& p// 调用方法：
% V& t+ e1 s( Avoid __fastcall TForm1::Button1Click(TObject *Sender)
  x! l) ?6 E$ Q4 y; `8 Y/ \3 w{
$ e9 h8 n3 U6 n    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
. e( e. I$ N- f3 b. \; z! s7 @}