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

天云上人

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

1. 
   6 U0 N" X2 S' s3 j: N$ D8 q4 J
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   ( z' A7 C' A; z0 a( Y& q
4. #define _WIN32_DCOM
   
5. #include <iostream>
   # ~- A$ k! X' f
6. using namespace std;
   
7. #include <comdef.h>
   * M5 A8 x7 z- {; L% G  U4 C
8. #include <Wbemidl.h>
   
9. 
   ' q" Y0 x6 l) ?; {' n6 g8 h
10. # pragma comment(lib, "wbemuuid.lib")
    
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    5 R4 C& C1 O! c2 i& ^. `/ U* D, L6 X
13.     GetInfomation();
    , [$ h" Q" |8 y+ A9 O
14. }
    
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    " ]# y: _$ h* E( M9 Y
20. {
    ; p8 t) ~9 [' }0 a
21.     HRESULT hres;
    / Z' r5 R4 B( r2 v6 O
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    6 S% k8 Y5 j6 {. M' C$ p
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    & u8 n& S+ E4 e" b
30.     hres =  CoInitializeSecurity(
    3 G7 E2 k4 f" H" l4 L) A5 q$ k
31.         NULL,
    
32.         -1,                          // COM authentication
    * L1 {+ d0 s6 q! O  b
33.         NULL,                        // Authentication services
    + L. l& t3 {1 r1 R7 R5 E
34.         NULL,                        // Reserved
    ) U* i; B/ \$ B6 p. z! a2 L; g
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    ' M$ u' t# d7 v- V
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    $ N* e* s8 ?$ E
39.         NULL                         // Reserved
    4 m  f( y! h0 D- {
40.         );
    2 l* c: x8 ^, E, h5 @
41.                      
    " |- L0 \$ a( M) K/ n3 P
42.     if (FAILED(hres))
    # \8 ^7 I6 I) R# [6 U5 Y
43.     {
    
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    
46.     }
    
47.    
    / \7 _9 s: g5 Z: h0 \9 R3 Y
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    0 \8 {" g6 D( d9 \5 F& q
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    5 {, T3 @4 v0 l% g9 c/ l1 t6 |1 ^( |
52.         CLSID_WbemLocator,            
    ; q* F9 c4 W6 z
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    8 [5 `  o( J4 [4 ]3 W8 e/ O
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    # D) Q0 x" L! ~4 Z# X  ]  ^
57.     if (FAILED(hres))
    
58.     {
    
59.         CoUninitialize();
    9 s5 K+ i9 P: w9 x; G( R
60.         return 1;//Failed to create IWbemLocator object
    2 H1 l* |5 L; Q' |4 X- m
61.     }
    
62. 
    + e; M$ P1 \2 _6 ?
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
      z0 q! \2 G; Z- E
64.     IWbemServices *pSvc = NULL;
    8 V/ K2 q' i: b( q& s& [3 q
65.     hres = pLoc->ConnectServer(
    4 V3 T5 X/ m0 ]5 `$ V1 }, _4 l
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    ) k1 C0 k# E% Q' O
68.          NULL,                    // User password. NULL = current
    ! B3 w3 S8 @3 L$ H
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    / ?. f' e7 R/ f5 K
71.          0,                       // Authority (e.g. Kerberos)
    5 A. q% V- g. Q5 W3 L
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    " e( W+ }! e7 I$ V1 M1 `) M. M
74.          );
    
75.    
    
76.     if (FAILED(hres))
    
77.     {
    
78.         pLoc->Release();     
    ' y& ?3 Z/ c: k  A5 T& _* p
79.         CoUninitialize();
    $ u& V( _# |) b; o8 ?* g
80.         return 1;                // Program has failed.
    
81.     }
    ! Q7 m! }' F4 U5 F, ~$ ?  k$ K
82.     // 步骤5： Set security levels on the proxy
    ( m/ C% M3 h* i' ~
83.     hres = CoSetProxyBlanket(
    - @9 d4 G, B0 u; m
84.        pSvc,                        // Indicates the proxy to set
    3 _$ U8 [2 z( d8 C- J( ^5 c# z
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    7 G7 Q* K  Q* b, Z0 P5 o
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    6 _2 @. }+ g3 `  Q# u
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
    + M; ?3 m" L0 E! V
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    
93. 
    9 \( g; S7 H3 ?4 b% G
94.     if (FAILED(hres))
    ) k* X. F( P$ p4 y8 T
95.     {
    
96.         pSvc->Release();
    + n) G" B2 S5 L7 ^* I  S9 o
97.         pLoc->Release();     
    4 f7 C' ^4 W0 }
98.         CoUninitialize();
    ' g7 [4 T+ {- l5 n4 V9 O3 r, A, w
99.         return 1;
    0 u4 Y/ d( f0 T# l6 [6 z5 d
100.     }
     + ]1 y$ [+ X/ b2 z
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     4 h2 M7 N$ q: E
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     , o( M8 B; \6 g4 c8 }! g6 @  u8 Q; t4 N
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     # Q0 X' w6 k9 ^1 C) u
109.         NULL,
     8 G, Y2 F5 z: U% W4 i' u
110.         &pEnumerator);
     + I( @% W" m4 o$ U" A% \' E
111.    
     ; C5 H  [1 a: [9 }2 |" V$ Q
112.     if (FAILED(hres))
     
113.     {
     + i9 E/ c* J6 ~
114.         pSvc->Release();
     
115.         pLoc->Release();
     # H, ?7 Z3 q7 ^- e+ i' Y  c) F
116.         CoUninitialize();
     
117.         return 1;
     4 p3 T. V- N8 k8 z: [
118.     }
     . ^% Q7 J- k2 G* a% ~5 Y- r
119.     // 步骤7：Get the data from the query
     1 p% }$ @4 d( v; G% t3 S, ^
120.     IWbemClassObject *pclsObj;
     $ u: V- `4 H: s+ l: t
121.     ULONG uReturn = 0;
     3 S* d, w4 N, i; _# }1 i" j# |7 k
122.     while (pEnumerator)
     % Y' i! O# P8 L( m# _
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     3 P/ S8 `" R1 c/ B
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     ) b  f: P% ^5 s# M+ s. O( _% Z
128.         {
     
129.             break;
     
130.         }
     ) @1 f  W( o9 d
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     1 W  X+ w* Q, K7 P4 p/ I# {- a/ q, |
135.     }
     0 s# A! B4 k! ^
136. 
     0 I* j5 m: E! Y, u- s( P
137.     //计算硬盘系列号
     
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     $ k+ G8 l) n1 {) n4 }. @% Y$ K
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     0 w1 C& q0 d. _- t  R
142.         NULL,
     
143.         &pEnumerator);
     
144. 
     
145.     if (FAILED(hres))
     5 s/ l; d; y0 i) C; [5 }- g
146.     {
     * q9 W4 E. M# E7 H" P$ M
147.         pSvc->Release();
     % L2 ^- I0 o  I
148.         pLoc->Release();
     
149.         CoUninitialize();
     & j" p6 I$ h, H/ K1 C$ V
150.         return 1;
     3 r/ u/ E3 c+ O) r; u
151.     }
     $ q/ A4 E& _7 A2 z3 J
152.     while (pEnumerator)
     : b# @8 f3 j4 N* N% q1 @6 L
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     : X1 A( K  N5 @: e: B1 k# `1 V
155.             &pclsObj, &uReturn);
     7 X& ~  \  k1 j0 ~* o" b' @+ b
156. 
     ' f6 u# N6 J' ?
157.         if(0 == uReturn)
     0 d5 v: E, O2 _& ^4 d3 C: L+ H/ a
158.         {
     
159.             break;
     1 C/ A; E/ h, q0 d) @3 M
160.         }
     # Z9 J3 U/ L1 G& y0 S
161. 
       O3 t7 \& w' U, n( Z, T, T! {6 w
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     / s% }7 S8 }+ x) i- a! G7 T& D+ A
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     ' H% J, `' ~# L. x
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     3 I* f: J7 h( i, V7 @) O
166.     }
     5 G* T& T  l2 Z" k* l  Y: v! @
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     * K( A! R7 a, d/ m& m
171.     pclsObj->Release();
     
172.     CoUninitialize();
     & i% a4 f" l* e6 M
173. 
       ?& A* c: @' V' |1 }1 l2 b( _
174.     return 0;   
     
175. }
     . d8 G% h) y1 K  {1 x0 R9 ~

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
3 _. O4 D" K( N+ x  R: H
#include <WinIOCtl.h>
#include <stdio.h>

#pragma inline
  F1 d* h9 k" E# F' f  o//---------------------------------------------------------------------------
: r" n# F! r! _2 Y; O// IDE NT/2000/XP专用变量
# H8 t$ {, H$ z#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
: Y8 z" I1 E2 J: ~/ S#define DFP_GET_VERSION         SMART_GET_VERSION
#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
5 z. P5 L. |' |( @- z#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

: E' N; `. D; K7 m+ a2 e. Xconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

. U5 z. r# Z, u; kconst int MAX_IDE_DRIVES = 4;
5 d( G5 J5 ~: V. y- n% |2 ?% m
// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
1 g2 E. Y- z3 S2 x- tconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
; Y$ @  h. f# F8 b* N- ^const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
! F8 F( c! _% q  W8 y# `) D
typedef struct _SRB_IO_CONTROL
{
    ULONG HeaderLength;
    UCHAR Signature[8];
4 P3 `' M, O5 m. v; x% [$ A5 c6 i+ \    ULONG Timeout;
    ULONG ControlCode;
    ULONG ReturnCode;
    ULONG Length;
  Y% w8 h% x* ^$ f' P' ?) p}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

// 读取的主函数
* n2 R' `1 L& ?8 Ivoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
* s) f1 R; u. m$ qbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
% S. S4 @; y* U        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
4 }2 x: W8 u& w1 ~3 `' x# Z// Windows 9X函数
# y, L: G$ h4 N8 Svoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
1 b1 q" V# {4 V; D7 O) Gvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
; X! o8 ]$ s( ]9 T/ a, `        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

// SCSI读取函数(for NT/2000/XP)
5 q4 u& g% _1 ]% Q  [, R4 I, HString __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
8 T# M- G7 t6 t* w( G{
6 e; T! }& V4 ^$ ]" s    switch(Win32Platform)
0 o9 _2 k: S+ t9 c    {
        case VER_PLATFORM_WIN32_WINDOWS:
! O5 [& V' @3 x( ~0 n( i/ x0 K            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
        case VER_PLATFORM_WIN32_NT:
- H; ]" m- d5 M8 u6 T, o            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
4 t. M5 s/ k+ Q* C( V0 B        default:
) J) n$ V/ l( ?9 U* F% r2 y            break;
    }
}
//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
  h: u* C* P" ^3 B. a. ^9 i{
+ b0 o8 G! P' W2 W+ w. t    static char szResBuf[1024];
+ n* K+ X, W& T    int nIndex = 0;
    int nPosition = 0;

    // Each integer has two characters stored in it backwards
% R& r( o+ v4 m2 t    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
/ s5 G9 Q! G2 a/ k) [( Y    {
        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
( \' q& s) {! R8 Q! W: p4 ^        nPosition++;

        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
, p1 @: L7 P: Z; R    }

, I! h" T( H9 U% F    // End the string
7 j- V* c8 n, s    szResBuf[nPosition] = '\0';

/ d9 h, `; J+ f0 Q( h. _    // Cut off the trailing blanks
: l2 y2 j" X0 m, x0 o4 Z$ Q" r    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';
. n1 F: X* _, E/ m+ j
) m% T4 `* r; r7 u# c! [; Y, T; A    return szResBuf;
}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
4 V" t5 c' {/ o4 K& v; _- z//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
/ Q1 y0 J, q, L% Wvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
! y  X$ g* ^# C. V& ]    // 输出参数
, J6 B/ x# |- u+ ?8 c( w    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

4 \! `8 U' f& z! C    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
2 a/ A# X; h# F1 N) D: k        char szDriveName[32];

. t: ~- y+ n( }! H, c2 ~        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
7 Q, R! R5 ~/ G1 W                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);
- D" k3 I* ~% w' M  n
9 x$ g6 x0 N. W6 Y        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
, w7 f/ J) [9 G; M/ Z% l            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;

            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

6 B& R4 _4 f  W1 |# J1 d            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
" [; X, K$ l; z" K                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
, a: c8 q! j% [6 n                    &dwBytesReturned, NULL))
            {
4 v' z1 ]0 b$ W) j" C                continue;
            }
7 G' E0 [9 w1 y0 m2 `9 K
            if(gvopVersionParams.bIDEDeviceMap > 0)
4 ]' q/ x( E* e) i3 U            {
                // 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+ `9 k3 g  e* {; i3 m, Y! a: H                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
- X8 X! ~- H& }3 e                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
5 `; g4 s$ e5 P  T
5 M. g* ~+ z0 e0 R7 i9 j                if(DoIdentify(hPhysicalDriveIOCTL,
0 t; A5 N2 c1 S                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
& F  G3 @0 f: y) E                {
                    DWORD dwDiskData[256];
9 C3 P' x! e: y- c6 T, w$ N3 _                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
9 p0 w. [; _: t! Q, [                    char szSerialNumber[21];
                    char szModelNumber[41];
) c2 }, c2 a, D/ |8 U( a- ]
                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
- a3 @, G# I. s! q                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
' t+ d' U! p5 z9 v7 M) X8 i                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
( C' O6 s: M0 x* {                }
            }
# m8 T4 Q  [+ b+ M- g) O            CloseHandle (hPhysicalDriveIOCTL);
        }
    }
, x& X' }  W8 v}
//---------------------------------------------------------------------------
// DoIdentify
8 Q* w6 V+ k1 Z% x& ^$ w7 gbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
{
& B8 a6 d/ T' }: d9 O$ @" d; p8 g    // Set up data structures for IDENTIFY command.
( o- `# G5 |4 ?+ p    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
% |$ F5 E$ {7 ~* \! n  a/ O    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
  ]# n. P$ u8 l8 W% V9 y: P
    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
: P! m" Q: s$ ~; R$ }    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
8 [' X/ `. O) K5 a" r
& E) M/ Y# k5 t( e) l% S    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
1 ~4 c. J- V: p7 V2 T- x4 L# |0 t           pdwBytesReturned, NULL);
% X- u* U$ d: i}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
/ d: X' R1 D+ [8 s4 g$ A* [//---------------------------------------------------------------------------
0 w" C# m+ t8 o0 M// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
5 w% t  U% |" F  }: j    WORD wOutData[256];
) T. k- H( O7 D( f    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
) F! Z! K  b9 I! B$ e% u    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
4 ~! X3 o; g1 D5 R* e1 i    for(int nDrive = 0; nDrive < 8; nDrive++)
+ Q& R% j- K% X) A# {7 i4 ?    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
2 c( k  `: z0 w. t2 r) U; y# ?# [        bool bIsIDEExist;
        bool IsDiskExist;
  b5 W5 O5 ~9 s3 q
7 {4 t$ S% e$ Z, y  {        switch(nDrive / 2)
        {
/ U: @1 A8 N1 j/ m+ n2 K            case 0: dwBaseAddress = 0x01F0; break;
3 G9 o3 y8 Q9 M$ e            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
; f, G$ J( t# ^* \' f# {            case 3: dwBaseAddress = 0x0168; break;
        }
/ J5 c" K% x  d& [, H7 U5 Q& m
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
2 |! j3 g6 ^( X4 N
        // 进入Ring0
% ^7 i$ {, {0 y. o. }9 A) q' n        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
8 f6 f: i, ~3 q) F7 ^                bIsIDEExist, IsDiskExist, wOutData);
    }

+ Z# V* G* l% u/ S8 \9 h    // 开始读取
- f/ G$ R9 R! i! _) D* q    for(int nDrive = 0; nDrive < 8; nDrive++)
" _2 A# K5 G0 z/ Y. w9 m    {
        WORD dwBaseAddress;
3 ?  c) Q" P* R& A4 o' @0 F9 ~        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
, w$ N8 j; v! T# a        bool bIsDiskExist;
4 H& o0 T6 g9 ~* D+ o: x7 `        switch(nDrive / 2)
! }/ K! ?7 \" ]$ P% p4 D        {
" B2 _" Y' g. t            case 0: dwBaseAddress = 0x01F0; break;
) C* g4 y5 w5 d9 a) `9 d+ n            case 1: dwBaseAddress = 0x0170; break;
$ s+ k  Z+ W. H$ D. {8 H2 }' K            case 2: dwBaseAddress = 0x01E8; break;
3 _, @. f3 U( P            case 3: dwBaseAddress = 0x0168; break;
3 L; F+ H+ j) b. W( d' Z# j6 L        }
) Y- M5 L, `7 [% {
9 i% g4 I$ s0 S; E        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

1 q7 f4 I  n* J+ _0 h- l% {        // 进入Ring0
        bIsIDEExist  = false;
7 a9 j: F! \" @8 H- z        bIsDiskExist = false;
$ S" d( j7 G4 ]5 K! G5 d# |: s1 n        ZeroMemory(wOutData, sizeof(wOutData));

- S3 v# r6 i/ T: M) z; l3 r% A0 ]        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

  ]- K4 Q0 k8 o; x        if(bIsIDEExist && bIsDiskExist)
3 g# \' h2 v. y( k  h- J$ u        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
! Z* T6 C+ {8 l: t5 N7 j- Y6 j6 B            char  szModelNumber[41];
* K0 l( F( R  P4 V1 M- l6 d
            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];

            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
( ^5 a, d$ R$ S5 C  v( k7 j% Z            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
; C: l/ I/ ?5 P# Y; w/ K
: a  b) _! M% O            // 取模型号
- v0 z0 C8 F/ u! R0 }5 D1 O            ZeroMemory(szModelNumber, sizeof(szModelNumber));
5 m' A- I( d. C2 T. J/ W            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
/ F  X' _1 j/ o' S
            pSerList->Add(szSerialNumber);
2 n  S2 }7 A" ~2 `3 I0 f9 Y            pModeList->Add(szModelNumber);
        }
    }
4 X1 ]. B, j2 H9 A    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
  E! g" I! ^# _6 i  L  D. X}
//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
4 _: U: w" M1 h! O" R: |: ?) ^// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
: n2 h( O% y& V, @& b//---------------------------------------------------------------------------
2 ]/ i3 T$ f7 Y// ReadPhysicalDriveOnW9X_Ring0()
//
* E) W5 P2 [" o: ^: g4 d// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
( _( `6 |1 \' B  Q7 m% u// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
# G% Y, i0 _$ g2 x0 v        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
1 p" k: S3 }! a! u0 u, c    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
. p! O+ [7 U+ `+ E/ _% {  ]    const int nHookExceptionNo = 5;

0 q, X4 A- t! U1 n9 w% X    BYTE  btIsIDEExist = 0;
& z, D9 B/ R/ _: ]8 y: \; \+ e5 y    BYTE  btIsDiskExist = 0;
& C. R6 o/ ]; w+ g3 v3 k5 y0 M# G: N    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;
, e2 Z+ @9 U3 O
    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
" ^( [: D0 a# F$ a3 c9 |' X    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
7 K1 `  b# ^1 `  U7 b$ ]7 f* Z; }    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;

. P6 j& [0 G6 q( t4 }9 d6 \. K    __asm
    {
        // 必须先执行这条语句
        JMP EnterRing0
- E5 K) X* t  T( g: X" p# g
        // 定义过程
4 o' F) d0 i! |+ y        // 等待IDE设备直到其不为忙为止
+ r7 z8 M% L0 H, E9 ~        WaitWhileBusy proc

- v6 n/ l! D7 {  t4 Z" Z- `% t, M& M        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
        ADD  DX, 7

        LoopWhileBusy:
' l3 f8 _* y3 K  n* ^# K9 m0 Q2 V
' F  Z5 S: A( _( \        DEC  EBX
        CMP  EBX, 0
        JZ   Timeout
( H9 J0 g# Z" [& g" c        in   AL, DX
        TEST AL, btBusy
& I4 q, B3 \4 t# ~        JNZ  LoopWhileBusy
        JMP  DriveReady
+ j% K4 p3 F& D; V$ W
        // 超时，直接退出
        Timeout:
        JMP  LeaveRing0
6 D5 \9 U* m; U& v' p% i        DriveReady:
        RET
! u# y. A7 O# P. {1 ~2 Y        ENDP   // End of WaitWhileBusy Procedure

9 d9 Z7 N7 T) h3 a) x! N  u7 I2 c0 c        // 设置主盘和从盘标志
        SelectDevice proc
9 D9 Q5 i7 O  A  k! z) w' L( \6 z
4 l1 R* P# p+ V        MOV  DX, dwBaseAddress
% I6 Y$ M( W* c7 s/ ]        ADD  DX, 6
        MOV  AL, btMasterSlave
9 d( X- M, N' c) O" r8 R! ^
( S1 i5 G1 }, t6 N% x9 U% q        out  DX, AL
6 F6 ^% K( D) A  C3 m! g2 D        RET

        ENDP  // End of SelectDevice Procedure

        // 向IDE设备发送存取指令
  L+ g# \  W/ @; E% ?# A        SendCmd proc

7 |, u) ]& I7 }$ i+ [) P        MOV DX, dwBaseAddress
, i8 M% }2 V6 X1 u" E        ADD DX, 7
7 R# A( _) n, w7 R, k        MOV AL, BL // BL是主从盘标识，在过程外设置
- W& ~: J2 R5 s9 [) w* l7 g4 ^$ X        out DX, AL
        RET
        ENDP  // End of SendCmd Procedure

% [4 P: L7 b' n2 v4 |& b+ i        // Ring0代码
' R" f! q3 }( x: h8 l& j        Ring0Proc:
        PUSHAD
        // 查询IDE设备是否存在
7 y; P" v4 I: A: R/ o        MOV DX, dwBaseAddress
        ADD DX, 7
        in  AL,DX
& S7 t% @' J; k& S' ^( @# @5 N
        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
! U* [; O! }2 E        CMP AL,0xFF
& C8 T* {7 O/ x        JZ  LeaveRing0
, y1 S/ B- j+ M3 R        CMP AL, 0x7F
& C1 D+ d' n4 ?        JZ  LeaveRing0
! H' \# n6 ^+ |0 p. k# g; E
+ [( ]. ]. _% f7 v  L, o: v: T" D        // 设置IDE设备存在标志
5 q" @4 J! A* f& V  u        MOV btIsIDEExist, 1
9 q( ^: j) f* Q
        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
        CALL SelectDevice
7 k0 ]6 m! I& a
  y& z, X' \: e; {1 K1 c* V  @. P8 r6 v        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
        JZ   LeaveRing0
+ y7 ~) |. n6 v+ g) U5 u+ m
, z; s" ~* B: p7 `; M! V- R        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
$ i$ \+ D2 Y+ s! W  g% m% v$ \        CALL WaitWhileBusy
# m8 g' m/ x( S8 T6 {
        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
        JZ   LeaveRing0

. J. C# k: i  A3 R/ C        // 设置驱动器存在标志
+ o1 V+ {% y! i3 e3 p) E* H5 o        MOV  btIsDiskExist, 1

, c- \; ]; k; @: Y# w        // 发送存取端口命令
, g# z0 E: O- [" g4 z, Q2 y        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
, P9 h3 A% D, y$ A4 m        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
" u1 l% M' l$ I2 B) U        CALL SendCmd
        CALL WaitWhileBusy
& `0 b% \# X0 @* @  s
        // 检查是否出错
        MOV  DX, dwBaseAddress
& L% O1 [( W( Z7 j% x- ?: `; ]0 x        ADD  DX, 7

0 X+ j$ t2 G5 V/ K. `: |$ n0 x6 |6 n        in   AL, DX
% I) h- I3 a: Z  R+ h  L0 b
, J8 C0 c0 t7 i2 ]- p. [* [6 v, W1 \        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
3 q7 a, E  Q& N( O) F        CALL WaitWhileBusy
        CALL SelectDevice
: H6 _, d: u& P        MOV  BL, btAtapiCmd
. i# S# y0 h* n& ]/ I, D        CALL SendCmd
        CALL WaitWhileBusy

        // 检查是否还出错
+ g( }3 G& c0 k/ i) f, i' Z        MOV  DX, dwBaseAddress
        ADD  DX, 7
$ ^5 Z; P+ g1 M) @+ T% r        in   AL, DX
0 e: F. d* |( e2 ?        TEST AL, btBit00
+ w: T- @! p7 z# j9 C* i+ g. w5 o2 d        JZ   RetrieveInfo   // 没有错误时则读数据
, E; v7 E4 u0 i" A0 J) }  O        JMP  LeaveRing0     // 如果还是出错，直接返回

5 Q- [% P' ]  o( M2 L' ~3 F/ H4 u        // 读取数据
* D- m- e' m9 _7 A% }) O        RetrieveInfo:
% T& \4 \- ]: U0 H- n, g
        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
        MOV  DX, dwBaseAddress
        CLD

        REP  INSW
$ H" @1 O/ `4 O4 ^- S
% X5 h& @3 ^/ i; K        // 退出Ring0代码
5 x/ [5 A' o4 A! k+ P4 @5 k6 A        LeaveRing0:

$ _' ?2 q, }3 ~; Y. S' x2 X5 J' p6 ]# W        POPAD
        IRETD
0 J& @5 C. ]; Q& Z9 X
        // 激活Ring0代码
        EnterRing0:
6 d& F/ f  l4 k" Q& E' U+ q
        // 修改中断门
% ~* c+ X* W: |* Z3 z        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI
9 g5 ?8 y% S+ I# N
        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
5 x! _6 e. ?& Z/ t! @        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX
# K9 B8 Y& p. V# Y
        // 指定新入口
        LEA EBX, Ring0Proc
' [" I2 |6 |4 ^9 X        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
- W+ z1 b) N9 A- d        MOV WORD PTR[EAX+02h], BX

0 [: v3 Y& @# Y& x, n        // 激活Ring0代码
% y! Q: {( h* }        INT nHookExceptionNo

% Z1 t5 f/ c7 l$ \3 L        // 复原入口
        MOV ECX,dwOldExceptionHook
/ q8 m, t) o" s( O        MOV WORD PTR[EAX-04h], CX
% O$ F# t1 F+ Q' p/ L9 r        SHR ECX,10h
2 J2 ?, [& _$ r- J1 S7 m+ \8 a        MOV WORD PTR[EAX+02h], CX
+ H9 q: t$ o0 R" E) v* @% N        STI
    }
& i, S- @, [1 e. D7 y    if(!bIsFirst)
    {
9 c/ C* \$ t5 M& m& F        bIsIDEExist  = (bool)btIsIDEExist;
1 @" W# V4 v( \0 r        bIsDiskExist = (bool)btIsDiskExist;
7 e! r! |2 l+ D( M& W6 C& q- g        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
0 y# Q; F0 Q! [( r( a/ P- W}
//---------------------------------------------------------------------------
// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
{
  |. E. e- ]& t2 H    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
5 \0 _$ ]+ R8 Y2 E% P( _$ q}
6 ^) C3 F1 N; ]" b7 }5 L' w; K