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

天云上人

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

1. 
   - f3 n% _; f- E) S9 _8 R$ n
2. #include "StdAfx.h"
   - v4 E$ O8 ]5 x7 R) g
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   4 J3 `) B# k# g
5. #include <iostream>
   
6. using namespace std;
   
7. #include <comdef.h>
   ( `$ {+ [) k* n( Y( o8 h! h1 n2 `
8. #include <Wbemidl.h>
     T; R5 b8 W7 N1 O9 v5 ?/ g5 Y
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    8 J. H0 Z6 p1 k9 e7 Q& }
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    
13.     GetInfomation();
    
14. }
    
15. 
    2 v$ y3 t% B3 b$ l- ]& i
16. CpuIDDisk::~CpuIDDisk(void)
    3 D" {  c: p+ _. p6 g% V
17. {
    4 B- {* {* h% \7 e$ \( g
18. }
    ' |4 d4 @4 q, v' ?
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    & V+ }# `" G$ k* w- {
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    8 w& W  ?9 ]3 ^  {5 J1 T0 G
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    ) a% Z5 J: W- }& b2 R
24.     if (FAILED(hres))
    ! H3 f& y) J$ w7 u# Q
25.     {
    : a* N6 L$ y) B2 V
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    6 Z: E0 o" U! y" V
28.     //步骤2：不是必须的，COM只须也只能设置一次
    ( C$ `* F: x# z  c+ L
29.     //Set general COM security levels
    1 c( [! n1 Z0 k0 x& h9 x$ R; X0 h" y
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    
32.         -1,                          // COM authentication
    8 H- h9 [5 P4 Q" }4 Q
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    6 q% R( \4 q' k+ p2 a
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    
40.         );
    - T$ p! T7 P# C$ D% A  d
41.                      
      ]( v" {/ J9 V+ z8 i( U* o
42.     if (FAILED(hres))
    * a; b5 h+ t" @0 F
43.     {
    
44.         CoUninitialize();
    ; B& ]% {. Y# w1 b
45.         return 1;                    // Program has failed.
    
46.     }
    
47.    
    3 W3 l( Q3 K0 ~1 F3 w1 ?
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    6 M4 D5 Y+ v3 @; _
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    
52.         CLSID_WbemLocator,            
    + s: z: L4 I  s  T& B/ K( J; l
53.         0,
    7 s5 R8 m, a4 l7 w
54.         CLSCTX_INPROC_SERVER,
    " t7 A0 x0 |9 M. x
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    ' U2 a- r$ E, |- C% W/ ]9 K
57.     if (FAILED(hres))
    & F5 E& [' u/ s/ [" {$ b
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    ) p1 \% a# B& {0 Q) ?' `- t
61.     }
    5 ]3 ^! b9 ?! s* h4 o
62. 
    * A5 u2 V  Y- [# h
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    ( ^  ?$ U' D: Y6 j
64.     IWbemServices *pSvc = NULL;
    7 I5 \. ^' X" P: r, J! U
65.     hres = pLoc->ConnectServer(
    : b& M- |) f% `" Y
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    + U% `3 N8 h! N2 e7 l- x
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    ( _9 K+ M5 S$ `$ h9 A8 z! W
71.          0,                       // Authority (e.g. Kerberos)
    5 v4 P% C, F7 w' l1 `
72.          0,                       // Context object
    1 X  I% y7 {% o
73.          &pSvc                    // pointer to IWbemServices proxy
    : j+ {1 H8 v1 l9 `1 x
74.          );
    9 U, Y& b( @$ T; ^
75.    
    # }$ Q; p* x- m1 K8 a! J4 O3 u; x
76.     if (FAILED(hres))
    / ]. b9 k. B: e- I. z
77.     {
    ' A/ ]: ~  S4 j+ A; e7 ~
78.         pLoc->Release();     
    6 q* f3 i8 Q' x1 C9 ~8 g) z
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    * G6 _: J, ]2 n! e
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
    * U9 Y0 @9 H4 N$ Q; N+ c
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    ) r- B1 Z4 v4 i7 K4 r  l+ t( D7 r
92.     );
    2 @; m, H+ _4 k5 ~3 U
93. 
    0 {. L, N! c* I7 R! s, X
94.     if (FAILED(hres))
    
95.     {
    
96.         pSvc->Release();
    
97.         pLoc->Release();     
    
98.         CoUninitialize();
    
99.         return 1;
    
100.     }
     3 |* a- j7 M4 U' B' v- U/ m. }% V
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
     . {7 b% ~$ d' {2 ~. o( T  X
105.     hres = pSvc->ExecQuery(
     & w: @$ W2 {- V4 Z& I
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     ; a: C6 v% s" M& H0 S/ Y
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     ! x" ^6 J8 _7 W* q5 H/ z1 j
109.         NULL,
     , c4 }  b  {4 u+ a. r
110.         &pEnumerator);
     
111.    
     ' u! T5 u6 i3 |1 O7 x# q8 ?" u$ K! T# ?
112.     if (FAILED(hres))
     
113.     {
     
114.         pSvc->Release();
     & L; x/ w$ f/ t4 [9 Z/ t& M
115.         pLoc->Release();
     
116.         CoUninitialize();
     # Z6 S8 `& V" Z
117.         return 1;
     
118.     }
     ' H  Y# X- C' E8 y! f  h* F# i/ ^
119.     // 步骤7：Get the data from the query
     & ?  P( F, A* B; a3 u- O
120.     IWbemClassObject *pclsObj;
     ! ^: {, q" O& c+ D, B0 a! J$ z* l
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     & Y6 D0 X; @8 ?1 ]  ]
123.     {
     ' r# i: f  w, g# R$ D" y' x
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     ! I( y8 U0 a6 j& @; U
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     
128.         {
     ! l# h6 |2 g! X  T
129.             break;
     $ e  F/ {$ \! x* K9 _" }
130.         }
     ! b1 \0 u* y+ H& n
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     , u( x2 |$ y% U& l! b/ g
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     , s0 }; M( w7 `
135.     }
     ! G7 v. e! u3 k, Q% {5 u
136. 
     9 r$ U& `0 y5 \' n2 P
137.     //计算硬盘系列号
     - w- O; W  b( a! A1 a# b
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     4 G3 v4 P! r. e& H
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     8 b+ k) }2 T# F( |% f& l
143.         &pEnumerator);
     . f3 k, E( p9 F
144. 
     % q# |; Z. b+ _6 l2 H6 U6 ^9 W
145.     if (FAILED(hres))
     
146.     {
     6 d% ?/ l4 L4 L# \/ _( H8 f
147.         pSvc->Release();
     ! E9 Q4 G; Y0 X, l$ I, L" ~7 f
148.         pLoc->Release();
     - {6 k5 u; E; ]
149.         CoUninitialize();
     " [, p- k0 y! ^' ]/ m, U& r1 m
150.         return 1;
     3 ]' e- s( I4 g9 Z( |# T4 o2 e
151.     }
     & k- W. Y2 e  p# ]
152.     while (pEnumerator)
     
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     ! J0 o. z4 y2 T. ?' [7 m) Y
156. 
     2 |& i# @) u3 X- ~
157.         if(0 == uReturn)
     # R0 h9 i2 Z* g, }6 c5 Z8 R+ D8 l
158.         {
     
159.             break;
     9 `  x7 t4 R/ l) j* J  A6 l9 Z
160.         }
     
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     . {3 O3 ~: o6 a6 l" D5 a% @2 H' {, N  y
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     % c- p$ e1 s! L1 v& E
166.     }
     + j6 }. E  g+ E+ e+ R7 d+ [
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     
172.     CoUninitialize();
     
173. 
     
174.     return 0;   
     
175. }
     

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
$ o3 _6 |/ H) }' X
! `1 ~* U' {) C1 k#include <WinIOCtl.h>
#include <stdio.h>
5 h( K# F1 d6 ?& R; W4 O
#pragma inline
//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
6 f* I5 Y' E2 `7 v3 _6 h  p5 P1 v#define DFP_GET_VERSION         SMART_GET_VERSION
3 t* u3 n+ j# ^9 J#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
- ~* v' R0 A9 f; n0 J6 i, z  n$ ?% d#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
4 C$ |! u4 e+ O: b8 lconst WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
% s( ]$ f0 f( `( s
const int MAX_IDE_DRIVES = 4;

// SCSI专用变量
8 N" s& d$ |. u, H8 uconst DWORD FILE_DEVICE_SCSI             = 0x0000001B;
const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
1 C7 n& {/ A4 c0 _8 t* Fconst DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
, ~2 }; s0 L( V# a9 O
( G8 |  w% Z9 {. F! r  f' \typedef struct _SRB_IO_CONTROL
{
    ULONG HeaderLength;
    UCHAR Signature[8];
    ULONG Timeout;
! L7 k3 v' ^0 {$ I    ULONG ControlCode;
" B: ^8 M& G) b1 o7 Q# o4 y( z! `; |    ULONG ReturnCode;
    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
. I& d. g2 ?/ a7 x9 P) V8 P* C
// 读取的主函数
: r* ?: r* {- P' `1 y2 i4 n8 wvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
/ h9 j2 ]2 c: E8 S% h
// 辅助函数
* W" m# \( c( T  Z* |0 f" r$ Hchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
4 ^0 \: _3 {5 G8 j: ~/ B// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
* w  F/ w' k5 A/ P- d: l: f( {bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

) T$ T) t6 q5 F6 m// SCSI读取函数(for NT/2000/XP)
4 F/ f& _* W- p8 Q, R0 XString __fastcall ReadIDEDriveAsScsiDriveOnNT();
9 @2 e, o+ C( C0 ^0 I: o//---------------------------------------------------------------------------
// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
! [# m7 N2 t! Q6 `* D{
- G7 U) s* Y5 `( `5 x* J    switch(Win32Platform)
5 l: ?  u# ]& o4 K, C    {
        case VER_PLATFORM_WIN32_WINDOWS:
7 \8 u$ S- B# c- J- I) p* C! S' P0 L            ReadPhysicalDriveOnW9X(pSerList, pModeList);
, V& G/ j- b  w* w" P$ D            break;
        case VER_PLATFORM_WIN32_NT:
- s& d% N+ t% Z$ N: `/ ~" H) q0 m$ d1 y            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
) A$ v0 G* h& Q1 w" F) A/ k3 M        default:
: O2 _, @6 ^3 J; }/ X            break;
    }
$ [7 }; M) N2 x* {( Y7 D}
/ E# ~( A+ O1 B5 e5 d//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
- T) }1 V' F) E, r; C5 T2 f{
    static char szResBuf[1024];
    int nIndex = 0;
    int nPosition = 0;
) F1 ^: X( |6 z2 t$ y
    // Each integer has two characters stored in it backwards
. c1 h  M6 U* ]4 [7 l    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;
. O- {$ S* n/ H/ M' J. Z
        // Get low BYTE for 2nd character
0 [9 y" l3 b, C( x/ r; z% Q8 A! U' F5 z        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
' I- {$ d" T0 ]+ Q# y$ t- g& e        nPosition++;
    }
% v) I% t) ]; o
    // End the string
    szResBuf[nPosition] = '\0';

( u9 k, l1 A) L8 {) o6 `    // Cut off the trailing blanks
4 x$ d6 l3 A0 f5 X- K5 Z    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';

% s- R% F, T$ Y! i/ b    return szResBuf;
}
5 o3 X- ?" `# f! o7 q$ m//---------------------------------------------------------------------------
2 I2 O3 G( l, Z3 l% u// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
9 v) r9 _1 H' b  |" \// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
- M6 L7 z* R/ ]8 J: Y{
7 C& W/ r6 x3 |2 e6 n7 v' C2 N: {    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
; J' Y, V- \+ O- W" J    {
; Q% _! H4 E5 Q9 I7 C6 f' R0 w        HANDLE hPhysicalDriveIOCTL;
2 F) Z- R$ R7 A' v2 _  k/ \        char szDriveName[32];
2 y( L6 d2 j# `% u- m# J
0 e2 E, M; [) }7 u  C        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
% z5 ~! J' M% |- Q' `* k% Y* ~' `# l                        GENERIC_READ | GENERIC_WRITE,
; I) u% R2 c- E) u, q                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);

        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;

            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
1 _7 G+ ^  b" `$ c
# R) n  `9 }: ?4 [3 M" I# }            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
  V* T0 [' H8 k+ |                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
/ Z9 }$ I  C) i8 r$ S                    &dwBytesReturned, NULL))
            {
                continue;
; ^& d+ X9 m! E( I8 i0 g            }

7 L1 Y% d1 w* q2 F8 U3 l            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
& F( ~! |1 n% }. M4 p8 M! x                // IDE or ATAPI IDENTIFY cmd
% j0 H6 V( A) ~! K4 x3 d9 q                BYTE btIDCmd = 0;
1 R+ T! _: T* U. Z                SENDCMDINPARAMS InParams;
0 O, K% x, T# t: l; p8 {                // Now, get the ID sector for all IDE devices in the system.
) y5 ~* t% s* u, e$ R7 w                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
& T3 t( E4 n5 O0 n$ B( D                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
, }1 M- L; J' N                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
! E  j3 D! @- z$ {                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
8 X# }: i1 e4 L$ |
3 @2 V0 F; s& Z$ [) q5 ~0 D# `8 n: g                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
: D. z9 A' ]" Y8 Q                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
! }! x* g, c2 ^                    DWORD dwDiskData[256];
9 T9 m0 l# g. j: C( H% @                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
' J  N8 ]: p3 z4 B8 f& o' O                    char szSerialNumber[21];
                    char szModelNumber[41];
& {# G- o6 f' A9 }, t( o- L1 H
                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
( j7 [$ ^5 {$ E) w. l                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
) m- b, B1 V2 m, k/ X' f: ~
                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
+ s) T% }. Q$ \+ O, Q; T2 f0 Y                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
7 r. \. ^' h8 v
+ @7 Q$ D5 x1 d/ y" S$ R, N                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
                }
            }
' y9 u% N  h5 G7 P            CloseHandle (hPhysicalDriveIOCTL);
1 B' \" l6 b/ {4 g- A  ~7 t4 @        }
    }
}
//---------------------------------------------------------------------------
3 i6 T6 ~" u2 k  r2 c: |// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
" F9 p0 q0 k  l" }/ B# F+ a. J              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
0 c( n1 s. q2 G# j) a- s' C$ N+ ^              PDWORD pdwBytesReturned)
) B9 i4 J0 ?& ~- N{
) U2 ?6 i4 K/ l: E+ ~7 i    // Set up data structures for IDENTIFY command.
8 R0 G4 k. F$ Q+ s& Q7 p9 R0 m+ K: K$ \    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
, O( X4 q: X$ ]1 E    pSCIP->irDriveRegs.bFeaturesReg = 0;
% @- {5 t6 j7 \0 v$ J# @0 {$ H    pSCIP->irDriveRegs.bSectorCountReg  = 1;
( `  N6 ?/ ]- B& F4 }6 K' ?    pSCIP->irDriveRegs.bSectorNumberReg = 1;
0 L; G' ?! o5 C    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

# G1 Y9 Q! v8 V' X* E6 _+ ^+ o& B    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

    // The command can either be IDE identify or ATAPI identify.
( D3 U, g8 A: i. N    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
" k6 u: e7 W6 o1 V' f) f    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

5 Q" e- |# v: x7 _; [    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
  E6 [: V, y  e4 e% ~2 C& f           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
, N# O$ F  t  y/ C( t           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
  B/ s5 I/ v/ A) N' ~4 P}
. B1 u0 q4 T% f' m//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
$ J! ]- y: w. x4 ^//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
( b5 D; P: I5 gvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
9 A. W+ G& Q% p1 b3 ~; d. W    WORD wOutData[256];
4 N& f0 \* ]% r( b* O0 {    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
, E$ Y$ F; v: M1 J& F$ o" \8 r    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
1 w/ n. a1 ]* O+ E0 d# M    // 避免蓝屏的出现。（期待高人能指出原因）
. d1 D6 J* R6 D) ?9 E" A( I    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
2 z4 D: k; m7 i$ D/ g: n9 K7 a5 Y        bool bIsIDEExist;
  f" n4 l# ~( a7 U  }! X  A) K8 F        bool IsDiskExist;

* y" @6 i& S! I/ d& U! x        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
; Q: S8 D1 C! w, L            case 1: dwBaseAddress = 0x0170; break;
/ R! J+ o' S: c. V* D& k            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
# W9 ~& ]$ M% T        }
; v* J. I$ @) }% B; ~7 Y8 I) J8 a
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
  v+ q4 p" j+ e8 L& M1 O. f
0 |+ q' r7 D- H" c        // 进入Ring0
! T- A! i+ D5 l& A+ c        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
# i) {% ~: k* m# v1 @    }

" B8 q& v' p; _+ k    // 开始读取
    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
5 j" X: B  l' l0 `8 X# `        WORD dwBaseAddress;
5 c1 C# x$ \& d4 h) a/ \        BYTE btMasterSlave;         // Master Or Slave
5 j0 b6 ?" M, T        bool bIsIDEExist;
* S8 O, `* S) T9 p% r        bool bIsDiskExist;
4 [  @. c4 b% ~  n: M  v        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
0 D6 x, t. R+ |            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }
0 Z% k$ z& O: w$ }
# n5 l) I# i' D& w) y; M0 _. ^        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

        // 进入Ring0
/ d% |% g) e! @! M        bIsIDEExist  = false;
        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));
/ {2 Y2 Y2 e. x) ^( z
8 G1 I$ R8 ^* P* F- t        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
7 p* f. Q' s* J2 d4 T4 b                bIsIDEExist, bIsDiskExist, wOutData);
$ q1 _- B! \7 d8 A7 K3 x
% Z6 P$ b: e1 }2 {! W$ W        if(bIsIDEExist && bIsDiskExist)
' x% r6 e) |0 G: f: m        {
& I$ k; u) F: F' {) j; P- Y  l3 `% W            DWORD dwDiskData[256];
! {$ W: ^- ~, s            char  szSerialNumber[21];
# H" ~: ]8 [/ b            char  szModelNumber[41];

            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];

$ W4 k- V* S: b3 R! k# L( X9 |            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
$ G$ m$ r9 |6 [2 J( b
1 E2 s& z# X: x6 M) N* E+ N3 ~            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
2 x  w  K2 m" K/ m' u% y2 ~        }
    }
4 Y2 R' |: b5 R8 c- B  G$ u1 z    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
) O5 J  H4 v- @7 s) L// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
  S% F3 I% U) w* Q// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
0 J7 k0 s. k% S+ W! ]: l! ^//
1 L4 H$ K4 p" L; s// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
! |9 ?- a! J2 X4 z: u// btMasterSlave = Master(0xA0) Or Slave(0xB0)
% K. C/ x, {: o//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
: r% B% J' \: [9 f+ ^1 s0 C{
" r/ ]. b. b8 Y. X    BYTE  btIDTR1[6];
/ a1 r; D1 P9 d4 x, W0 S. S) K    DWORD dwOldExceptionHook;
; `) o" Y8 A9 N& e7 t2 y2 c    const int nHookExceptionNo = 5;
- b8 u9 Q  d/ S# c2 E' s2 @
4 [0 |! m) A' p, h+ w    BYTE  btIsIDEExist = 0;
( Z1 y+ u" m2 k1 J    BYTE  btIsDiskExist = 0;
# Q" @2 i* L& G, e4 [    WORD  wOutDataBuf[256];
- D% t( G1 _9 ~+ q4 X5 s
    BYTE  btIsFirst = (BYTE)bIsFirst;
& U8 Z7 z$ M" d; s  C9 V
- K/ {; j8 E- w, Q* ?  {) m    const BYTE btBit00 = 0x01;
8 l" [9 U2 w* X$ J9 n9 \. R5 D    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
& A* O8 o) |0 I: V0 v: T1 H    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
    const BYTE btBusy = btBit07;
8 c6 S' ^# n2 Q0 L, G$ s; `) I5 G    const BYTE btAtaCmd   = 0xEC;
( c- b4 B4 B( x$ ~8 r) l    const BYTE btAtapiCmd = 0xA1;
. z9 M" @7 M0 o; \9 c# H; q
    __asm
% D+ i' X  Z9 _5 N# d3 ^; k" C    {
4 k/ |  M4 }+ i( U- d' e        // 必须先执行这条语句
        JMP EnterRing0

        // 定义过程
- }. l5 W4 W* {) r' f        // 等待IDE设备直到其不为忙为止
( ^! ]6 L/ t3 f, m3 c3 }  C        WaitWhileBusy proc

/ H: D# Y7 e$ @% q        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
6 s9 _) T6 a, t        ADD  DX, 7
8 M, U' F" x7 Q+ R3 N
        LoopWhileBusy:

) I8 n# j* q3 F9 F& H        DEC  EBX
        CMP  EBX, 0
% M8 M2 E# a$ ^7 U3 j        JZ   Timeout
        in   AL, DX
        TEST AL, btBusy
        JNZ  LoopWhileBusy
9 n5 @1 k' l. U- d% x4 d8 G        JMP  DriveReady

        // 超时，直接退出
        Timeout:
        JMP  LeaveRing0
        DriveReady:
* l0 M3 V6 N, v! R, x: h        RET
. o& n7 d+ e- a. Q4 H& I        ENDP   // End of WaitWhileBusy Procedure

7 p! L; v- a: z- w7 e6 }        // 设置主盘和从盘标志
        SelectDevice proc
/ @; h0 c5 r* @! t+ x8 V
6 @9 D1 l. r$ {6 O        MOV  DX, dwBaseAddress
        ADD  DX, 6
2 w) A) Q0 E% r4 L4 g        MOV  AL, btMasterSlave
" |7 L1 f- w3 x) O0 D
- ~# \' V$ Y( V/ G3 Z" C        out  DX, AL
        RET

% `. f) [& T# Y. c8 I8 p        ENDP  // End of SelectDevice Procedure
2 t8 S2 F$ u7 B( C; ?' z/ |
        // 向IDE设备发送存取指令
: W; f0 \3 t! X: W5 a        SendCmd proc

        MOV DX, dwBaseAddress
) ^& ~* V6 k9 R$ h5 K( ]        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
$ h# z$ Z/ K6 l: s- j2 o2 F        out DX, AL
        RET
        ENDP  // End of SendCmd Procedure

) t4 n, z% Q8 W8 Z- \" a        // Ring0代码
        Ring0Proc:
' N! Z! r* S; k9 e        PUSHAD
        // 查询IDE设备是否存在
8 b! o( L' o, R0 a        MOV DX, dwBaseAddress
        ADD DX, 7
' o; n1 U& U+ ^) C4 j  c        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
        JZ  LeaveRing0
% V8 {) _$ B6 Y: x6 q8 G: Q        CMP AL, 0x7F
8 g! ]. b. [3 @2 g3 a        JZ  LeaveRing0
0 b* r0 e2 \2 W) h9 U5 a/ c! H. t8 f
% E5 \4 i/ Z1 F) x" f2 Y        // 设置IDE设备存在标志
" o# L7 [) ]) B4 ?        MOV btIsIDEExist, 1

        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
        CALL SelectDevice
! j- I0 [+ _! c  V. r5 k- p% |
: [5 B/ @" U  n/ \        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
; A6 Q- |$ Z+ M7 V& F        JZ   LeaveRing0
; d9 a5 M3 t5 q8 G% S
& H) d  z1 n7 }7 _        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy

        // AL的值等于cBit06时，不存在驱动器，直接返回
' ^) B3 \( K) x$ b5 w        TEST AL, btBit06
        JZ   LeaveRing0

, M9 c# t* j. o9 j: m: Y        // 设置驱动器存在标志
2 r9 T# j0 b! b! S        MOV  btIsDiskExist, 1
  |8 |& A9 f6 _5 u$ i" p# F! Z
        // 发送存取端口命令
  K1 ?8 E9 m( D$ H( `        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
0 I2 B# _( p5 R% N/ Y0 h5 C2 I        CALL WaitWhileBusy
% n% B+ ^. [; a# Q- ^        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
, q0 [$ P* y4 o        CALL SendCmd
        CALL WaitWhileBusy
/ ~  k2 [. ~' s: B- G4 X
        // 检查是否出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
2 w0 ^# ~" `1 X6 F3 m- s" ~. Z4 |
  U; a8 o) T) a: u& ?; a        in   AL, DX
1 w: `) Z5 n6 A( V/ F) `) s* p/ ]
* z# e& t) M9 \  J* @5 k+ S+ F; N: a        TEST AL, btBit00
( J0 o0 g4 f# m; m+ |3 X; Z/ L        JZ   RetrieveInfo   // 没有错误时则读数据
$ t+ E, |1 a, p, y" |( y9 f- T& D0 Q
        // 如果出错，则进一步尝试使用ATAPI设备命令
: `: f* c5 P  Q        CALL WaitWhileBusy
1 w1 U" m. T* u  ]1 {7 L' p# e7 n        CALL SelectDevice
        MOV  BL, btAtapiCmd
2 S. S7 R% G9 q3 G        CALL SendCmd
        CALL WaitWhileBusy

7 k, n* ^$ Z& o- f        // 检查是否还出错
" F# @  R! g' y        MOV  DX, dwBaseAddress
        ADD  DX, 7
3 [/ t4 V8 {: A+ {. j        in   AL, DX
        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
9 y7 M: L$ V( C# W) u        JMP  LeaveRing0     // 如果还是出错，直接返回
7 l% q# m5 X7 ^, y: }
- i( x1 |: w; y        // 读取数据
        RetrieveInfo:
4 f) Z- {: Y- {; [4 d9 H; v6 n
# z! v/ {$ T- N& n0 W0 p$ P        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
        MOV  DX, dwBaseAddress
; _7 {" D+ G/ P        CLD

( G8 V, I4 Y5 n, [# v3 c        REP  INSW
# W& Y& m  h- u5 J: f$ D7 Q4 }
        // 退出Ring0代码
        LeaveRing0:

* l% b1 G. E! R        POPAD
! R2 B9 }* @2 [# l        IRETD
! N5 c  \9 t2 h9 {
3 _6 [- d$ e0 C        // 激活Ring0代码
4 \" d" I* k( \. ]0 p        EnterRing0:
! X1 m% _1 _1 e
        // 修改中断门
# g8 q2 b9 b2 _        SIDT FWORD PTR btIDTR1
: [2 G4 N6 l$ p/ r% U        MOV EAX, DWORD PTR btIDTR1 + 02h
9 ?8 B3 M0 M$ C3 f        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI

% F6 c# v5 n9 x% |- b        // 保存原异常处理例程入口
& o* _! P4 p  {        MOV ECX, DWORD PTR [EAX]
2 |: }8 f0 E8 f        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX

        // 指定新入口
8 X9 F: h7 P  s- d! H! v. \9 p        LEA EBX, Ring0Proc
2 A6 t5 S0 w8 J, M        MOV WORD PTR [EAX-04h],BX
* A" z* i* Z' M  B4 U1 d        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX
5 H, [' \/ Y+ a$ f/ n
        // 激活Ring0代码
        INT nHookExceptionNo

        // 复原入口
! L& L; W5 `. H/ Z* R) D" r        MOV ECX,dwOldExceptionHook
- U  N, |7 F) I8 x: {' }5 `        MOV WORD PTR[EAX-04h], CX
4 h/ W) a$ ?; l% G1 _        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
( `9 |3 q. L( h# o. f+ E- {        STI
    }
( E0 g/ M, K/ D" y    if(!bIsFirst)
    {
6 R/ B9 p- w( i( z        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
) X+ E9 P4 a' ~- O3 a, l        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
+ |: \$ ~% x3 H}
//---------------------------------------------------------------------------
0 C- t+ s! K5 u) I+ \! N// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
1 D$ Q& q. q4 d4 [" Y1 d{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
5 y* p) Y+ c  a6 @7 L8 v+ |}
  A+ b$ ~0 q+ U6 Y. u- f