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

天云上人

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

1. 
   
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   # }; Q5 L; k! [5 V7 n: k$ ^
4. #define _WIN32_DCOM
   4 M  O0 u5 ?3 n1 ]7 P% x
5. #include <iostream>
   . B- C# |) y4 h) e
6. using namespace std;
   3 z' ]/ {& ~! [) O: X, z2 |7 R
7. #include <comdef.h>
   
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    5 l; p' _2 V- \" D9 ^4 m6 \3 w2 x
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    
13.     GetInfomation();
    - e0 @- A7 e: _; \# k
14. }
    , \& C8 S4 G: N5 b, y
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
      k" [- m9 V5 Z% P$ q# V0 ~- [- S! J
17. {
    3 [$ u0 |/ n8 w; t% f
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    ( h, Q0 |+ v' ~# N
20. {
    
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    1 t7 f) D0 @: q. P4 k" V
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    % v" H  E/ v" ?, z" |5 F) @: O2 T
24.     if (FAILED(hres))
    5 D9 E: j/ @' s7 ^
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    $ G0 f2 d  A* E: f0 _  l
30.     hres =  CoInitializeSecurity(
    2 e7 [, K# n- w& \% }
31.         NULL,
    ( l8 W6 p. v9 y8 v9 `7 t) E4 l1 |- x
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    2 s$ ?6 ?; L& g' K& M5 d' X
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    % L) R& J# `8 j
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    8 \( u8 T: q+ s1 o7 S; V
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    # P5 |+ ]5 E6 b; r9 v0 B
40.         );
    0 u# T# T+ g7 m; T
41.                      
    
42.     if (FAILED(hres))
    . t- t2 C9 |! f; i! q
43.     {
    
44.         CoUninitialize();
    & v5 ^3 Z6 y3 j2 m- J/ v: |( |
45.         return 1;                    // Program has failed.
    ; J$ V! N" h0 U; Q* w6 f/ V7 y
46.     }
    
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    " z0 A8 p' Q" c2 m: O- n( h$ P
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    3 \* X* G& {" _- ^2 X. C
51.     hres = CoCreateInstance(
    * L) ^$ h/ `7 v& v+ L3 O, o: U
52.         CLSID_WbemLocator,            
    * _8 X4 ?* b8 U
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    
57.     if (FAILED(hres))
    
58.     {
    : Y1 s4 B. p% P& |. F+ @, L
59.         CoUninitialize();
    1 [9 y3 c$ k; }6 V7 h; L& `
60.         return 1;//Failed to create IWbemLocator object
      H; w' ]; F& k5 V. I" w
61.     }
    
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    ) `, S0 D+ |8 b; c: A
65.     hres = pLoc->ConnectServer(
    / ^/ D1 ]% z0 D3 g6 }
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    $ N( ^8 a( o6 N. a
68.          NULL,                    // User password. NULL = current
    ) c9 @% S( d8 ^% ^
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
      F" W+ y  I( I, P
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    6 Z( s- t* e. K' A2 A
75.    
    
76.     if (FAILED(hres))
    
77.     {
    7 a  ?5 Q) u& @
78.         pLoc->Release();     
    
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    ' P2 o  Z. L% S/ \* m6 o1 P
81.     }
    3 U- J# \9 g( d8 H& q
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    1 `0 [2 |+ f! k- X3 O+ A
84.        pSvc,                        // Indicates the proxy to set
    + r- [0 p. N  |
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
      Y; q9 E) W6 m$ J0 f1 h* p
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 O/ U$ [! F7 V
90.        NULL,                        // client identity
    ( j, d' v4 A( ]# u; a
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    
93. 
    1 O0 J* m2 j% U* y0 `  U- o
94.     if (FAILED(hres))
    
95.     {
    3 J7 v0 R. `. g$ M- G8 z+ l
96.         pSvc->Release();
    
97.         pLoc->Release();     
    * j. P) V# {& w# ^
98.         CoUninitialize();
    * _( P6 d5 Q$ v3 R  h
99.         return 1;
    
100.     }
     
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
       ^! f* H. N; B; |% @
105.     hres = pSvc->ExecQuery(
     & w. M* O6 b5 P( m3 v* m9 m
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     / M0 s; C: q$ |& ?0 n# P2 e
109.         NULL,
     5 u0 Z4 \7 u8 f+ W# c
110.         &pEnumerator);
     
111.    
     9 R- C' B+ U: q( o+ o
112.     if (FAILED(hres))
     5 Y% [' f1 r, h+ m
113.     {
     4 J5 G# z: @. D; }+ K
114.         pSvc->Release();
     # u9 p5 [& X% c8 ]7 G# H
115.         pLoc->Release();
     
116.         CoUninitialize();
       l( `- X2 M9 |+ \; K1 b$ `$ d& U' d
117.         return 1;
     
118.     }
     ! S& b% m3 w4 T3 u7 j
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     
123.     {
     4 E, G" R  X: s% w, T
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     3 |+ G% }9 C5 G& p3 h
126. 
     
127.         if(0 == uReturn)
     
128.         {
     # {- _( C: W; h6 q: ?  Y" |* R- r
129.             break;
     
130.         }
     
131.         VARIANT vtProp;
     + @1 a4 T$ P/ l
132.         VariantInit(&vtProp);
     ; x) C0 p3 A( y$ {. l
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     
136. 
     
137.     //计算硬盘系列号
     
138.     hres = pSvc->ExecQuery(
     , N3 I9 t7 W- p: ^, D
139.         bstr_t("WQL"),
     * p6 @# {) G, h1 T) |
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     ) t9 h$ O! e9 N$ U! H
142.         NULL,
     ! e4 t" q$ ~- W5 _- g
143.         &pEnumerator);
     5 w5 r' m3 M! ]; a% h
144. 
     5 \+ y1 E0 b7 w6 W) d% j1 G
145.     if (FAILED(hres))
     1 h0 S0 e) @: J7 o/ j
146.     {
     
147.         pSvc->Release();
     
148.         pLoc->Release();
     5 O- x, Z' c$ _6 m+ v
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     0 j8 B1 _8 |( g$ K
152.     while (pEnumerator)
     ( a. |3 N% h, q) g/ R- _
153.     {
     2 F& O( t) r6 F$ Q3 b+ p
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     1 v: i8 x3 H2 [  E
156. 
     $ }$ `2 V. `6 B: @
157.         if(0 == uReturn)
     
158.         {
     
159.             break;
     * m! D- J; P  ]& i
160.         }
       J% g% Y. o' @& v/ n3 o' i8 Y
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     6 N$ N' v2 \9 t$ a7 I7 ~4 x  O
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     . ]- I9 x! F# j- B4 b) I! ^7 h
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     - }! t" q: c; O2 x1 p' @* W
171.     pclsObj->Release();
       u1 Y6 F1 Z3 I; W
172.     CoUninitialize();
     1 Q# K# @( d/ ^% k
173. 
     ! h8 G" s4 W+ G2 X- @0 Z3 d
174.     return 0;   
     & u7 M! g1 C1 ]" N. R6 V, A, }
175. }
     7 x* B7 q5 q1 B- e, |, c: I

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
0 P0 l% r5 O4 g8 b% {& P2 d0 |
$ L: E6 f1 K1 Q$ v/ c& K( M" \#include <WinIOCtl.h>
#include <stdio.h>

$ S" ]4 u3 b% }( |/ W' M2 ^#pragma inline
+ w( }" F+ c. ~+ N//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
' ^8 g2 u; N8 z/ X0 z+ d#define DFP_GET_VERSION         SMART_GET_VERSION
0 Q2 j7 w9 G& B+ J6 B& \6 z0 _#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

7 B6 ~' C8 w  u5 [. ?% aconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
' {4 P5 I2 o; b5 S4 u0 W" jconst WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

const int MAX_IDE_DRIVES = 4;

// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
: ~# F0 }* l7 n  E$ w7 L9 d6 {const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

typedef struct _SRB_IO_CONTROL
' i. M6 z, U" ?; I2 [/ H! G$ R{
$ w3 ]/ Q0 v8 ~    ULONG HeaderLength;
    UCHAR Signature[8];
# |1 [1 N: j2 i' ]; t: N; p1 J5 d    ULONG Timeout;
# Z: q$ p- H$ E( \4 `    ULONG ControlCode;
1 M8 ^+ s& Q/ W0 |( j    ULONG ReturnCode;
    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

0 {7 j- ~2 y2 R  A1 l: ~5 x// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
0 @( k( u: s+ m0 w- }
3 }5 S; R/ y4 K) I2 t// 辅助函数
7 k# `  \4 s+ i; o' achar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
% g  d4 l: q) r, Kvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
8 a0 P& E) @+ B4 J8 a        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
6 E" I' e  p1 ?: V/ r: `4 Y        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
+ {1 t4 Y' K' D9 Y/ |// Windows 9X函数
, b8 ~/ z( i! K( G( U$ z+ m& j5 dvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
  t/ q  ?* D5 [1 o3 [/ jvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
0 L- `3 x. z/ j' z8 P& T        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
! ~: b8 K& E7 L- I4 ]- U//---------------------------------------------------------------------------
// ReadPhysicalDrive
' z( f" G5 _( c7 e9 Lvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
+ ^; J5 a1 u9 t  P: ~9 F  N- v1 s{
. R( v- n$ H+ _5 G6 H    switch(Win32Platform)
    {
0 Z; D1 T) m  U' J5 {2 x# F        case VER_PLATFORM_WIN32_WINDOWS:
* c, h3 S/ k9 l* t4 H* l            ReadPhysicalDriveOnW9X(pSerList, pModeList);
' [; R9 ^. U' }6 m            break;
  E2 @$ P& ^( Z! v% l& U! g. i9 `) \        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
4 [; U+ l$ ^, @/ m            break;
' O5 ^( v5 D$ V* ?- c        default:
. [" X0 ]4 |  ^" s            break;
7 H5 v, X9 k$ N: |    }
}
- s4 s  J0 }' u/ u* j//---------------------------------------------------------------------------
// ConvertToString
  s! f( X) }1 Z- x5 Rchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
    static char szResBuf[1024];
& _' T5 x( F; n2 @, ]    int nIndex = 0;
    int nPosition = 0;

    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
8 m6 H7 g9 j8 o1 ]. D' n    {
2 A; k( i- i7 K% {        // Get high BYTE for 1st character
8 P* U5 s# O* C: @5 j        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;

: G- |! J0 |- h# R5 ~        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
6 w. G8 T% H" ~/ N        nPosition++;
# p5 Q9 ?# B- P! y    }
; k+ a  ^5 h1 W2 @# }6 G; _  K
4 i/ \1 i! p: n6 ?9 e5 m$ g) W    // End the string
9 z& J, z3 S+ `- ]* C, D    szResBuf[nPosition] = '\0';
& L5 s; ^0 I7 u; g- C( e
2 `. X2 M$ P! w& f1 F; M  Q    // Cut off the trailing blanks
    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
. m8 _( _" J. T2 i2 o9 ]        szResBuf[nIndex] = '\0';

1 ]( @, u( x9 N, R    return szResBuf;
! q& ]; z( G  [; c" ?}
( a- ~2 ~; j. @: I: a9 {% o0 K3 {0 h# o//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
! e! Q% D6 H5 [6 @# E2 V//---------------------------------------------------------------------------
$ b5 F2 T+ u% w3 T; V# s$ h// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
9 j! R# k$ O% A8 q6 f{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
/ F) D$ O6 T& F* Z    {
        HANDLE hPhysicalDriveIOCTL;
% U2 z0 ^7 K  Z) i        char szDriveName[32];

        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
% ^# w- G# a# @- S) @( U1 z1 J0 n        hPhysicalDriveIOCTL = CreateFile(szDriveName,
: }- v' u9 b( _8 o) B& @                        GENERIC_READ | GENERIC_WRITE,
3 O& P1 t+ [. E. U/ X" \; i! ^                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
) K5 }9 P5 r4 ^% l) ]/ t                        OPEN_EXISTING, 0, NULL);
3 L2 Z- W% \; M
2 ?$ T3 T' l' y# A- c4 U9 A" _        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;

            // Get the version, etc of PhysicalDrive IOCTL
( Y9 Y/ U0 B0 e- q; ~( N            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
1 W: ?1 O7 q$ O; ?
1 e( B0 g7 [; k0 y; @- h  c, F  P            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
+ Y# p4 l. m; }3 `7 m" w5 }1 y; U                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
2 ^6 P5 Y! Q5 |0 Y2 J            {
- V. h3 c& u/ f: ?$ a                continue;
0 T  U/ o1 ~% A/ V  y            }

            if(gvopVersionParams.bIDEDeviceMap > 0)
& p  a/ j5 D$ u: }- D            {
. T( X0 R! `1 T5 {                // 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,
                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
! y3 @9 t( g, A# {  E) G                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

                if(DoIdentify(hPhysicalDriveIOCTL,
7 ~' \0 m) J. z8 J# ?                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
  n; @) B1 c7 X1 @/ \. P. C                {
/ S1 p' R4 E+ I; l                    DWORD dwDiskData[256];
. v) k6 D" F5 \- E! ^                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
' L. M6 n0 H% ~                    char szSerialNumber[21];
4 ]( @- f( `1 p. |                    char szModelNumber[41];

  A$ V7 c8 Q; r, U; t                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
7 d' `0 H; L; w2 g9 j: C) s                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
' n8 R0 [. i8 L& Q1 D- h2 R" t6 d
9 ^7 V. ?4 V) c8 t                    pSerList->Add(szSerialNumber);
1 d9 e; d# I# j                    pModeList->Add(szModelNumber);
                }
            }
( T% t4 ]! q8 {& ~            CloseHandle (hPhysicalDriveIOCTL);
# p5 r8 P* Y$ U5 i  I" \        }
    }
3 W* s  R8 K* P+ U}
& L6 @8 D! i1 x$ x  F//---------------------------------------------------------------------------
+ U! m1 S8 Y. h* ^- }. B// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
{
    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
' w0 k6 h8 O; N. E! K% T# b* a    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
, V( c, z  b3 Q" {    pSCIP->irDriveRegs.bCylLowReg  = 0;
: O7 w3 j# c3 z    pSCIP->irDriveRegs.bCylHighReg = 0;
& }: J" q6 p5 c& F- C
    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
) R/ b" W3 S% ]7 z8 h+ f    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
1 k) b% G" Q: v$ S2 t! R    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
# M! f8 C& W, o- U- ~9 [. L           sizeof(SENDCMDINPARAMS) - 1,
' E) |2 g& j3 b# S           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
8 ?* L* T3 c% `# G5 e//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
1 a% j; H+ f, Y& s  T8 X) _// ReadPhysicalDriveOnW9X
5 Q2 R/ y$ P5 j7 Dvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
% f9 k- l, v! ?) C    WORD wOutData[256];
5 t4 ]. Q( e; G  m/ O* p3 d5 c    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
0 j3 j: _1 d1 r! K, A
    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
# ~# \* ?/ V* e$ m4 ?& m    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
$ a8 t. i; [: B8 B. P5 ~    {
, L( u" a2 |% z- q' h* R5 X        WORD dwBaseAddress;
9 K1 _3 O/ E2 ]2 }( v7 V; K        BYTE btMasterSlave;         // Master Or Slave
; L7 {5 T/ k% i" a* c, \        bool bIsIDEExist;
        bool IsDiskExist;
8 C2 ?+ ]' y* q. H- `! s8 j
% ~: x. O$ A5 C8 c) f/ G1 n% o        switch(nDrive / 2)
        {
# j3 v/ }% [! x3 V$ Y1 W9 {, I  V; y3 v            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
* G/ q% a; O) I            case 2: dwBaseAddress = 0x01E8; break;
+ J: ]4 q" J6 i- n/ I' r4 {( v$ P, {            case 3: dwBaseAddress = 0x0168; break;
        }
9 @3 y5 o$ N# H; ?
# o- p& ]  `  @# T# r+ I% `9 H        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

  g- ?3 T) ?5 {: J+ X        // 进入Ring0
: r1 ?3 e( |- b9 @        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
2 c, L, m. V: Y3 F" q. j                bIsIDEExist, IsDiskExist, wOutData);
    }
7 c. m4 t! I. K; W. l1 j: H
$ I6 t& ~* @8 q8 E; ~+ O    // 开始读取
0 J' p* ]# ^" J+ B. o    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
2 |  R  v$ L0 c: u. Q' d        bool bIsIDEExist;
6 c. a! t2 `0 D* P+ H% W5 ]2 c        bool bIsDiskExist;
: N* a( D1 Y* ], i5 Z: e( W8 Z        switch(nDrive / 2)
        {
& B# [5 q  H$ z+ S: C6 M            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
8 t0 S' v! A/ T  {            case 2: dwBaseAddress = 0x01E8; break;
+ {4 n  n+ O0 T7 V7 p            case 3: dwBaseAddress = 0x0168; break;
        }
; y9 `) ~; q: F) }* ~6 D! Q2 P
' R8 `$ x. Z' V: Y: F        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

7 @& v, G3 L; m2 G        // 进入Ring0
2 C' e1 ~' }) u7 E% H        bIsIDEExist  = false;
! F( n7 z$ w/ W! T5 p        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));
: {" W; @. i% K* i5 B# o
, F( V, p/ L* A0 F' T        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

        if(bIsIDEExist && bIsDiskExist)
        {
            DWORD dwDiskData[256];
* J6 d4 `6 @1 I! \7 @            char  szSerialNumber[21];
8 R  F) m) |% y; P- p$ \            char  szModelNumber[41];

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

            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
2 D- H9 G; F# X9 k1 n
            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
) s; r- G' p( z$ \
3 O  ^6 N) P( s            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
        }
' O! `5 D. o& Z7 @5 T& G    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
; T. \" m4 s- L' |* `$ V}
//---------------------------------------------------------------------------
: ^6 H6 C' }5 j" T" Q// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
+ J3 T+ T2 E% R4 ^// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
8 j  U, c+ M7 J3 o1 M//
7 x4 `4 x7 ]( W5 W. N3 v: Y( B! c// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
$ D# K& |0 I5 E//---------------------------------------------------------------------------
; Y8 t5 k' \6 G' `. v# vvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
( }8 p! X4 U4 B# C    BYTE  btIDTR1[6];
3 v5 R* l0 a5 q- p2 A    DWORD dwOldExceptionHook;
- x! `) b! X5 x  P; m    const int nHookExceptionNo = 5;

4 F: z& }  w. P) Z# j* z& Y& A    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];

! ^: x% E. a) S. @+ F- q    BYTE  btIsFirst = (BYTE)bIsFirst;

    const BYTE btBit00 = 0x01;
* ^7 B1 O+ L7 E9 g    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
& [( v: [/ H3 y1 C    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
    const BYTE btBusy = btBit07;
2 o: t$ L7 T( \. T    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;

    __asm
    {
        // 必须先执行这条语句
, t$ M+ O: @- U! m1 V% x' _* d6 l( f+ y        JMP EnterRing0

3 }+ a+ J) f$ T! j7 c# J        // 定义过程
6 k+ g- \: Y% |2 u        // 等待IDE设备直到其不为忙为止
- n% r4 K) ~; z# M0 f        WaitWhileBusy proc
' f2 R  ^1 d: Y) C: j
        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
        ADD  DX, 7
+ ?. i0 E0 O/ I  b# z: C% y# y
4 W1 }2 F0 r: p6 I1 G        LoopWhileBusy:

        DEC  EBX
3 Q- D" u8 p, J. K& f9 J' ?        CMP  EBX, 0
        JZ   Timeout
- M7 Z$ T4 g% S& T+ d7 J        in   AL, DX
% x8 |$ n6 Q" c  X/ V; y$ _* E        TEST AL, btBusy
        JNZ  LoopWhileBusy
0 O4 r7 w" }* l8 V7 _        JMP  DriveReady

1 z# _* ~4 P$ k) _        // 超时，直接退出
        Timeout:
  ]; M$ N, u- Q; N6 ]5 l8 P        JMP  LeaveRing0
. j( k2 j& l7 j+ z" P        DriveReady:
        RET
        ENDP   // End of WaitWhileBusy Procedure

        // 设置主盘和从盘标志
        SelectDevice proc
9 _/ F  t, W/ }0 ^2 |: h& u
) v, o8 o+ e: u+ k5 e4 \/ K. W        MOV  DX, dwBaseAddress
3 s# k( ]+ t$ X: ~2 s- B- [        ADD  DX, 6
2 w' J; w# E5 n# }( ]1 n        MOV  AL, btMasterSlave

6 n1 ?( w" l! ^1 Q! ~        out  DX, AL
        RET
' s9 f5 j* c  k( z  X7 m
* y0 d2 E4 p9 l5 ]2 q$ m4 S0 z        ENDP  // End of SelectDevice Procedure

        // 向IDE设备发送存取指令
        SendCmd proc

        MOV DX, dwBaseAddress
, d" Q4 U5 d6 K; j8 ^- i        ADD DX, 7
: M% `% B7 k9 U! F$ Y4 k        MOV AL, BL // BL是主从盘标识，在过程外设置
% B  [8 x) `1 j% }        out DX, AL
& ?, _" L9 z3 n% `; I        RET
4 x$ s. j; N8 a5 k5 r+ a        ENDP  // End of SendCmd Procedure

        // Ring0代码
        Ring0Proc:
        PUSHAD
        // 查询IDE设备是否存在
- L; @0 Y0 a% m9 |0 w        MOV DX, dwBaseAddress
        ADD DX, 7
        in  AL,DX
' q- a  M8 D- [. ], Y6 K% ^
        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
- t, k$ \+ [( W* R$ h        CMP AL,0xFF
1 Q5 n# t) j5 X        JZ  LeaveRing0
        CMP AL, 0x7F
( d, a( V" l7 f8 R) k  e0 c2 }" m        JZ  LeaveRing0

        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1
' {+ ^" g1 O$ Q
        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
        CALL SelectDevice

# G: D1 w: X* _        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
, n% v1 @, H- p  ]; W, D        CMP  btIsFirst, 1
        JZ   LeaveRing0
3 B5 W. ~2 K: ?) q) ~; \4 g( _
        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy
4 l9 S3 ~, k% j8 ^- I% f
5 ^4 ?( k3 E* K/ ~; Z1 N1 L        // AL的值等于cBit06时，不存在驱动器，直接返回
) X. `( m0 P$ y# D        TEST AL, btBit06
4 W& n+ @2 n, r9 e        JZ   LeaveRing0

4 T* N+ e* @4 N        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1

        // 发送存取端口命令
0 n& c& V* w0 V$ N" d! j3 m        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
8 }8 ]2 @5 d/ F& W" `* _5 T& y& I        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
6 ~( _* E; w+ u0 _7 u- d5 @        CALL SendCmd
6 Z9 A2 S" z% m9 M3 g# f0 z        CALL WaitWhileBusy

        // 检查是否出错
/ O+ z. P/ y0 x5 g6 O: p6 }        MOV  DX, dwBaseAddress
5 p4 _* S3 k! ~% J3 k        ADD  DX, 7

        in   AL, DX
9 L0 G$ L6 _6 o6 y0 U
        TEST AL, btBit00
4 g6 m" p# ^% Y7 }7 y" W  ^        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
; M! o' s8 T" O! \! u        CALL WaitWhileBusy
. [  j! ~! x7 W  }( {: \+ E7 ?        CALL SelectDevice
        MOV  BL, btAtapiCmd
; ^( @7 D4 z. `) C4 `        CALL SendCmd
  D. p' d, |4 H        CALL WaitWhileBusy
  d; B, S: a* f! ?. `
        // 检查是否还出错
1 `7 K5 q, g! q, N, i        MOV  DX, dwBaseAddress
        ADD  DX, 7
        in   AL, DX
8 L  b% }' f% b: o0 P3 Q        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回

" N0 D7 Q/ k. T# W" p. ^) S        // 读取数据
1 r4 b/ a4 b  S% O        RetrieveInfo:

% G; c6 X$ N6 g8 E        LEA  EDI, wOutDataBuf
8 q5 e- B1 Q! k. ?2 ?' @        MOV  ECX, 256
! B3 t1 `# Y( p6 K: T        MOV  DX, dwBaseAddress
        CLD

. l/ ^; W0 J( U' I  u* n        REP  INSW

        // 退出Ring0代码
) G& x/ ]8 s' c. \) E        LeaveRing0:

, F8 _1 g3 L3 ?! U# i6 m        POPAD
        IRETD

6 Z" I$ g% B& Y# E9 T        // 激活Ring0代码
" ]8 d; g( t. ^8 [  K" _        EnterRing0:

        // 修改中断门
& z$ D' J; R9 c7 S4 i        SIDT FWORD PTR btIDTR1
; H' K9 [+ `- n$ o# ^        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI
( r+ f* b4 `/ W( {* c% C8 u
        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX
: g+ w% C  X5 m* B* R
        // 指定新入口
$ ^7 p  y# w: U% S+ S9 n        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
4 w( b0 r2 p  \        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX
4 ~. L, U  ]5 A1 C" N1 ^2 q! q
        // 激活Ring0代码
        INT nHookExceptionNo

" q9 d( J5 ~" Q# w- D4 l2 g        // 复原入口
$ h3 i  ]; N: E4 e5 y' E        MOV ECX,dwOldExceptionHook
9 j% d) y7 c' y7 w$ f. U% }( e        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
4 Y( S9 E5 X8 J7 P: }        STI
- h$ {. u  A3 J5 \' n- H    }
2 y5 b9 ?4 ?* J) D' k! y    if(!bIsFirst)
    {
$ Q# s- `1 Z* Q, B. @        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
, |: H* J8 U7 Y3 l' I! m    }
}
//---------------------------------------------------------------------------
( e! O+ q. B- q4 y# J3 ~% u// 调用方法：
* X- I) {2 t7 G, [/ j# B' r( ^. S) Xvoid __fastcall TForm1::Button1Click(TObject *Sender)
{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
& g) j" D  ~8 j% n7 m$ n/ F( G7 I) [}