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

天云上人

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

1. 
   % x0 P7 J# T2 J4 B: d" B/ d
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   
5. #include <iostream>
   9 d/ Y6 d+ a$ F3 d9 C% A; m
6. using namespace std;
   & y. E! }( d4 \7 w8 P4 T" S/ b+ k
7. #include <comdef.h>
   2 E0 c6 c; J- ]( F/ Z- [$ L
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    * Q, q1 A" g/ _, N
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    
13.     GetInfomation();
    
14. }
    / ]! Z3 h2 P, v8 T  O5 w
15. 
    2 z0 b" A4 \, K% [  f
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    : {7 {1 ]# p! B% v2 {
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    1 Q* o) U: G1 Y4 J
20. {
    # J  n3 R, \$ s5 l% L1 O
21.     HRESULT hres;
    ' S" U% K! g, W% ^  G- q
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    ( M( W" g6 y) [2 c/ i$ ?8 V
24.     if (FAILED(hres))
    
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    9 w2 {; l/ g& B& h2 f
27.     }
    ' T) [3 K0 @0 t( n6 a
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    . v6 O' q7 E' N) b& z8 D. u
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    3 f: B& D: l0 Z: c: d; _
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    % t0 A( _) F- ~6 z
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
      [2 a' x( _4 K1 k4 N
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    2 w/ O" g- O2 E& `
39.         NULL                         // Reserved
    0 _, Y( `& W% r3 [7 {! _
40.         );
    ( H( b' _' |" G+ n! C9 C
41.                      
    & o9 u$ ~) W# ]
42.     if (FAILED(hres))
    2 R$ r, l2 J8 ~- Q8 S$ \
43.     {
    
44.         CoUninitialize();
    7 g: N1 J3 U0 k$ b1 U8 z0 @6 S7 c
45.         return 1;                    // Program has failed.
    
46.     }
    
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    - P$ C. n! u) L, S
50.     IWbemLocator *pLoc = NULL;
    ( e7 q. S3 `6 V' n
51.     hres = CoCreateInstance(
    ( d! N# h% c" g1 m$ J
52.         CLSID_WbemLocator,            
    5 a7 D4 E6 g6 a6 ]( n
53.         0,
    ) c" _4 Z0 b- D2 C$ f1 w( ~
54.         CLSCTX_INPROC_SERVER,
    ( y* K2 M- V6 F. B1 [1 i
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    , ^# F2 O, a& k1 ~; s$ [. R5 J
57.     if (FAILED(hres))
    
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    0 A4 z8 N! ]$ d0 i, s
62. 
    / |0 n9 w+ T  }
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    8 `! i8 e" O/ K+ _7 K; Z
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    : b8 m! r% w2 Q" Y, ]! g" c) q
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    5 a  N8 |; s) R# H: R4 g3 u
67.          NULL,                    // User name. NULL = current user
    9 F8 ~: X' Q5 Y0 ?0 ~  h4 ~
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    * c% e0 ?/ W1 B8 i$ ~
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    % y& d5 x9 U& N: p* a8 B0 d
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    0 c) f& R$ ], i1 ?) p  w2 y4 \
74.          );
    , v9 G0 R9 V. R/ u- k! O
75.    
    
76.     if (FAILED(hres))
    
77.     {
    
78.         pLoc->Release();     
    
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    & T/ b) p- s/ z8 |7 [# S
81.     }
    8 m/ S4 R# q+ ?: j- F4 t4 z
82.     // 步骤5： Set security levels on the proxy
    # Y# y; j6 ~  T0 O7 h5 r  B$ |
83.     hres = CoSetProxyBlanket(
    " U! q# j0 J3 @* v# ?/ g
84.        pSvc,                        // Indicates the proxy to set
    " C! V# H$ {4 `6 @4 |1 M6 P8 j$ R. r
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    
87.        NULL,                        // Server principal name
    2 C1 r# {+ p7 r; @- U8 @; c
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    % L% E! K+ F- d1 I& |
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    + L# n% L3 W, v" d+ U
93. 
    5 ?) @. x6 x8 |1 O
94.     if (FAILED(hres))
    
95.     {
    
96.         pSvc->Release();
    
97.         pLoc->Release();     
    & r3 R5 R# [) ?% @% r7 ~9 e
98.         CoUninitialize();
    & K( p: b- I" y2 O  Y8 C! O
99.         return 1;
    
100.     }
     
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     9 G7 G7 q, f& J- q9 x- J( H/ c9 g
103.     IEnumWbemClassObject* pEnumerator = NULL;
     / N' g# d! U5 L. _
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     % I1 W, |  G6 t
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     - B1 s" @% ]* D- n: F- R
109.         NULL,
     
110.         &pEnumerator);
     * a' Y2 o% q# T0 Z8 J3 f% R7 U  y; I
111.    
     
112.     if (FAILED(hres))
     
113.     {
     
114.         pSvc->Release();
     . F' M2 Y+ i5 c, R2 G' g
115.         pLoc->Release();
     
116.         CoUninitialize();
     3 a6 A4 v& e0 G( {, \2 X
117.         return 1;
     0 `" C' G; f. M8 c- s6 u' {
118.     }
     
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
       G1 L3 X, r" F
122.     while (pEnumerator)
     7 ]7 m. T8 _9 t% d5 x7 i  i; @
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     0 D2 d1 {$ j) E0 P! k- ^; b# Q
125.             &pclsObj, &uReturn);
     
126. 
     9 D: T. K  G4 H; x: A1 B, c
127.         if(0 == uReturn)
     
128.         {
     
129.             break;
       _7 B- ?+ v! }3 |4 \) b
130.         }
     
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     ) k" l, R) C$ k( ?+ e1 w
136. 
     
137.     //计算硬盘系列号
     ; X2 P, ^, E0 o5 o! E$ u" a1 F
138.     hres = pSvc->ExecQuery(
     5 g7 h0 L) I1 `& B4 R8 s+ E  n
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     * a9 a: \. U+ {7 H" D4 P
142.         NULL,
     % K0 m! P: V5 F1 }+ K7 H; f
143.         &pEnumerator);
     
144. 
     
145.     if (FAILED(hres))
     
146.     {
     * }# m0 H8 ~8 a. }
147.         pSvc->Release();
     
148.         pLoc->Release();
     
149.         CoUninitialize();
     
150.         return 1;
     4 z1 g; g* ~; p. }' ~/ q6 K
151.     }
     6 f; u! a3 f6 x8 a/ o& X
152.     while (pEnumerator)
     3 p# W$ Z$ O/ U% F
153.     {
     & r1 ]# B+ z# Z& e
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     : g7 F; h7 ^* J; K9 `  E3 n
155.             &pclsObj, &uReturn);
     
156. 
     , G: N# _2 Q* E6 ]' K
157.         if(0 == uReturn)
     
158.         {
     
159.             break;
     
160.         }
     
161. 
     
162.         VARIANT vtProp;
     ( b! O' L3 B5 p6 d3 m5 T% U) `
163.         VariantInit(&vtProp);
     3 a7 N% o; u  l- S
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     0 X  }, L) i0 `0 y2 ^
166.     }
     ! t4 `2 p, e: j& T
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     / [4 K1 c# S* X% S
171.     pclsObj->Release();
     4 _6 L9 |  J1 P- @% z
172.     CoUninitialize();
     
173. 
     
174.     return 0;   
     ; L/ E1 y* B& B8 L( n
175. }
     

复制代码

天云上人

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

' p  r- G  A3 ^1 u( Q' ^#include <WinIOCtl.h>
#include <stdio.h>

. C/ N2 q6 h3 o1 k6 B& G8 I#pragma inline
; ^( R7 F0 Y: ]% x( I. V3 p3 T//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
" ]/ t, P4 c3 Q( G" V9 m+ ^+ k0 Y) E#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
3 `' `. G" k# l% G6 c#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
, k. I: u5 k5 N7 w$ w
const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
% J! E1 [6 J2 w, |% qconst WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
0 m0 K7 q. G8 G. v) a2 u# S
6 b2 x6 _( k) Sconst int MAX_IDE_DRIVES = 4;

5 N0 n: O9 ]7 f/ I2 w8 E+ p9 N// SCSI专用变量
- p! n0 I4 P6 d7 }" @% ?const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
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
{
$ j& Z* J8 n' T) e* X+ S+ N    ULONG HeaderLength;
# T6 X- g! ]# i    UCHAR Signature[8];
    ULONG Timeout;
& R) `( `- Q. {1 a1 ]# r8 D: D    ULONG ControlCode;
6 u8 L( D5 {0 _0 S    ULONG ReturnCode;
# O2 l' D& e3 q    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
) |' i/ P/ ~4 s4 p6 W+ p
// 读取的主函数
' T+ G3 ?) L. A; C2 Uvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

( q3 f; `, X3 c8 Z// 辅助函数
% m0 V8 D! j; |& b/ \1 U3 q$ P3 _, |char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
% k! K. ~: Z5 s% l2 N+ c// NT/2000/XP函数
' v# u6 B% h( I  Uvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
( ~% @; C8 A3 }8 W3 d0 x' }3 Zbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
! x; P9 ]7 X8 z- S9 E& Z( A        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
# m3 r5 p8 k( O' V- Hvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
( ]! ]- w$ s/ ^6 r5 L( z, p4 b
// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
( d( F! a$ g; d: o( ]{
/ i7 x: `0 }% M" R# Z3 j1 _$ z    switch(Win32Platform)
    {
" ?; A' e6 [5 |& p% e        case VER_PLATFORM_WIN32_WINDOWS:
; K% {" u0 f  r            ReadPhysicalDriveOnW9X(pSerList, pModeList);
; M1 v! r* S! Y            break;
% _; E! t0 x- |  G8 h3 c        case VER_PLATFORM_WIN32_NT:
+ F" ]& o8 ]7 i# [            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
+ E7 F2 C5 V  f2 {        default:
            break;
    }
}
//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
    static char szResBuf[1024];
$ j' A2 x3 a6 ]1 p; ~    int nIndex = 0;
    int nPosition = 0;
$ Q; H# n! R; @+ T: f5 m! [+ P5 O
. P6 ~4 D3 p$ F4 j/ c7 T, q    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
# X' I5 N6 Y: x  b! o" H    {
        // Get high BYTE for 1st character
- L+ }% H9 `2 l        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;
7 S! Y  H% p; M( R6 l
        // Get low BYTE for 2nd character
! x8 ]1 I9 J, c% p        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
" D; p! ]$ b% w5 w+ v    }

    // End the string
    szResBuf[nPosition] = '\0';
" i, B1 @# I" h. ~
    // Cut off the trailing blanks
. Q8 m& `$ T# [- c+ {    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';

2 f+ d# ]4 J" z* M( t2 h# H3 g    return szResBuf;
}
1 k9 M1 [3 g- d0 ~: W' G4 i/ e8 {& a//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
( V) ?, f& _0 n  R8 k2 O* }void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
    // 输出参数
5 p1 ~5 {7 @8 J/ b    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];

1 i2 [) O0 l+ y        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
: t" J" g( u% R2 C                        GENERIC_READ | GENERIC_WRITE,
" `5 A4 P4 @2 k4 F                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
$ L- H) a4 m% B, g& }7 c  O                        OPEN_EXISTING, 0, NULL);

; g3 a  J; \  A0 c/ @! Z2 h        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;
0 C$ x+ R, \5 {
+ Z$ b' K7 H( b/ c            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
+ o7 r4 a0 s2 ~4 y; T, G0 \; E
            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
4 q$ H4 J9 n! Z                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
/ l1 X  N$ z9 u5 V1 b                    &dwBytesReturned, NULL))
            {
2 i4 r. s2 E% ]: v& Q$ [9 L* B                continue;
            }
- f0 E/ |& K! m6 n; ]2 a, I0 g7 q
- D2 k% C, h$ X! r( y, R            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
                // IDE or ATAPI IDENTIFY cmd
% d6 a8 T. J2 R4 C/ n8 W) X                BYTE btIDCmd = 0;
, G) z$ K* G: [5 q$ X2 {                SENDCMDINPARAMS InParams;
                // Now, get the ID sector for all IDE devices in the system.
$ X) I5 I0 M6 P, P                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
- p' @- s# o2 E( Q; @( j. ]2 n0 Z                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
+ o# F9 N. E8 z" K/ b3 W& R3 ]7 v                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
* o, F9 {6 ~- y, _" R2 e4 z2 M                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
( h- f  z4 U, Y$ F4 h( R* c+ T
6 i' N4 S6 ]# W. Q; G( ]9 e7 ?                if(DoIdentify(hPhysicalDriveIOCTL,
/ U+ i" f9 r5 K4 c' l                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
# s; x7 t9 D" j- I6 a: O, C2 f% V                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
                    DWORD dwDiskData[256];
  b1 E7 B; x* p                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
$ S% n. W- `/ t; B* |9 u; Q% t( e                    char szSerialNumber[21];
& v9 q8 I2 e* d+ P                    char szModelNumber[41];

9 V9 }  ]  r3 I2 t                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
' H7 Z+ o% I, m* P/ R                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

# J6 k1 F- O4 U7 @                    // 取模型号
) N, e4 b8 J5 u* J+ o& p                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
5 ]( b- U2 f1 W! L
                    pSerList->Add(szSerialNumber);
, ]4 C9 O. z& C* c$ `; r" f                    pModeList->Add(szModelNumber);
' M2 r$ W3 @4 n, m3 ]                }
/ Q4 h* O5 r3 Q9 Y            }
            CloseHandle (hPhysicalDriveIOCTL);
; C( u: r/ y3 ]- e0 Z8 b) |        }
0 f  y. c6 A+ D) M6 ^% D    }
  E8 b$ u6 ^! U- Q! F}
2 D: C( d3 {$ u# V* ?//---------------------------------------------------------------------------
// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
7 z( j5 z, ~# _4 o8 g: h% `7 m              PDWORD pdwBytesReturned)
* n3 L' x8 N; t$ h! ]{
    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
+ f: _2 F' t' X3 w8 N  e    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
1 Q# S/ B5 c+ N! r6 ~    pSCIP->irDriveRegs.bCylLowReg  = 0;
/ X- Q6 z) M/ W2 r6 Q    pSCIP->irDriveRegs.bCylHighReg = 0;
7 n, ]% W7 |- Y5 m2 T$ S
, a' y9 a* C! z  h  L3 _% M- Q) c    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
: Y3 ?$ K9 M. \! Z8 ]2 s* V    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

    // The command can either be IDE identify or ATAPI identify.
( H6 w8 }2 q, Q7 X    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
" h" g( A9 Z! r    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
3 s3 }) i' L& o; \; _  b) n* f
4 R! Q9 Z" Y) Z3 D6 l8 O2 i    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
4 y9 N& c. A, I9 b9 ^           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
6 a( `: J, R6 r0 I# ?" K; r, u7 V) s           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
) g" ]- y9 [: H0 w9 F: b2 G- p! q//---------------------------------------------------------------------------
3 v% @7 U2 A( ]/ ~$ J  D. t! }// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
2 d, \9 K& U4 L* J% h# M{
! J) p4 k7 N! A' X* D    WORD wOutData[256];
    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
/ J, K0 A/ F; R. P. e2 o! o
    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
( u2 L+ L7 r- }! r( V$ W1 P6 [  O    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
) z" [! {3 [# ~0 Y" u5 y$ @% Y' g# @    // 避免蓝屏的出现。（期待高人能指出原因）
. K. E: t% |- Z. V+ a: Q1 F    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
+ A$ X4 D) b6 e) `+ ?        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
        bool IsDiskExist;
# t: S( }9 m6 I2 Q/ ]
        switch(nDrive / 2)
2 O1 {3 ]" p) d        {
! R4 S1 z* }7 t  ]" r            case 0: dwBaseAddress = 0x01F0; break;
0 D+ \/ X! S8 J* E# L7 u* k            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
7 E1 X9 n# W. b            case 3: dwBaseAddress = 0x0168; break;
        }

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

        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
    }
' H5 K3 \3 R$ O
. A6 L* n6 c, U# h9 r2 H7 ?& a* v    // 开始读取
. A2 Y- t% n8 [0 z' {  p    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
3 y8 b/ @" V. y0 C; f% p        BYTE btMasterSlave;         // Master Or Slave
4 Y& g2 ^  J5 k4 @8 L4 N- S        bool bIsIDEExist;
        bool bIsDiskExist;
        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
" A3 [4 a6 e$ z9 U! Z2 t        }

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

" T" A" ]6 P2 e$ n        // 进入Ring0
        bIsIDEExist  = false;
. {# R# h5 ]4 z, g4 [1 J. l        bIsDiskExist = false;
5 n  B7 J$ t$ q9 [0 N- b! w" `        ZeroMemory(wOutData, sizeof(wOutData));

/ f# r+ O3 P* R9 q        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
, N9 w* O7 G, Y& }4 B                bIsIDEExist, bIsDiskExist, wOutData);

. W: ^) W# V# d. }7 A* J; V& H        if(bIsIDEExist && bIsDiskExist)
) n1 }/ B6 p5 S( o" }        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
            char  szModelNumber[41];
9 W" h8 |) |# s9 U( c; ^, R& I
            for(int k=0; k < 256; k++)
- `/ r7 H* [4 C) e, ?9 W# L6 B! `' [                dwDiskData[k] = wOutData[k];
; T# V. H4 L8 e
            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
, M9 M- }6 O% k2 u            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

            // 取模型号
3 i% g3 b/ O( z3 g; I. A. O( D            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

9 f% p, s: P+ R& A# G3 M            pSerList->Add(szSerialNumber);
# T1 j" `( n3 ?/ _; p            pModeList->Add(szModelNumber);
        }
    }
3 i1 R6 k7 O4 u  U! r    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
) ]) X* \6 v% u& [, U//---------------------------------------------------------------------------
* l3 H' S0 v; o; U  ]/ U) L) \// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
/ e# H- W8 n0 j. b//---------------------------------------------------------------------------
! L2 P6 H$ ^2 c8 ?- G  q7 }. K// ReadPhysicalDriveOnW9X_Ring0()
4 w5 V, s: M7 g5 ^: }//
. `. ]9 h6 t  L# H/ H. i// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
/ Z9 E1 t+ r7 r9 K( B// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
- h) }2 l3 S/ y$ h' ]{
    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
6 L2 f/ J1 w7 O1 }7 V    const int nHookExceptionNo = 5;

- U6 O8 |- d; F9 e# j" A( r. _. k    BYTE  btIsIDEExist = 0;
6 C, I4 @& _* H" t% V1 T9 ]    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];
# S4 J1 ~, h/ ?8 N- f
# M6 W, O) X. Z8 C% f* H    BYTE  btIsFirst = (BYTE)bIsFirst;

    const BYTE btBit00 = 0x01;
! g% K3 H7 E3 f% F+ t) p- W' I    // const BYTE btBit02 = 0x04;
& U) H6 J& a, S. V: p1 j0 U    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
    const BYTE btBusy = btBit07;
* |$ }$ [& n5 H" {/ e* N    const BYTE btAtaCmd   = 0xEC;
; x/ R. V  Q1 `9 ^# N3 F    const BYTE btAtapiCmd = 0xA1;
$ |' U# [3 T( Q- o; [8 \0 Z+ H( j! k
    __asm
: Q$ K) x- b! e' [    {
        // 必须先执行这条语句
, m, A; n% r. Q. F        JMP EnterRing0

/ f. i$ K9 h) y+ H, A, Z        // 定义过程
! [- M! l! r- t8 N% g        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc

        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
        ADD  DX, 7

, M+ O3 C. y- k        LoopWhileBusy:
' ^. i2 }# g5 n2 v
6 h' v% ]2 _% q4 X5 R8 i; K        DEC  EBX
+ R; j& A9 n! L3 T5 b# x2 i        CMP  EBX, 0
/ m. m% B8 j6 O. @1 |2 ?7 s' d( ^        JZ   Timeout
        in   AL, DX
        TEST AL, btBusy
, C+ c; G( O" U1 V        JNZ  LoopWhileBusy
        JMP  DriveReady
* V1 K5 k0 o7 }9 \% J4 Y
7 a/ k  ?' z$ ]- x! j; u* y# Y        // 超时，直接退出
" I/ Q2 F8 N9 ^- H1 {7 H; A        Timeout:
( E6 Z. v: O2 S' b" e/ U, |  W% F        JMP  LeaveRing0
        DriveReady:
6 I# g6 s* p, t2 g/ _& G        RET
        ENDP   // End of WaitWhileBusy Procedure

/ c, u# y/ V# c  `. E; K        // 设置主盘和从盘标志
8 M  l9 X- E1 M& I! p        SelectDevice proc
) z; T$ P5 ^- P8 j& E
  `5 D; B; [- p- U" Q) ^) @        MOV  DX, dwBaseAddress
* L4 K4 S1 q# R        ADD  DX, 6
# v- m) [2 q& y4 J  n        MOV  AL, btMasterSlave

$ O1 c! S: M& n( V1 @) g- y5 K6 v        out  DX, AL
        RET
" P  r* U7 I8 r3 G
        ENDP  // End of SelectDevice Procedure

$ f- Y$ g9 C0 O- f; s$ H6 y# c        // 向IDE设备发送存取指令
        SendCmd proc
+ a: R  ?( |! k
        MOV DX, dwBaseAddress
        ADD DX, 7
2 b0 K# e; ~) k) b' S, e        MOV AL, BL // BL是主从盘标识，在过程外设置
. V' O+ `. E5 ^9 ~8 o2 t% x8 t        out DX, AL
/ `6 V  J. N3 h1 f1 A; B        RET
' E. z+ G. i+ ~' Z- U1 H        ENDP  // End of SendCmd Procedure

        // Ring0代码
5 Y) O5 j9 p- B  Z; n7 S* s; x        Ring0Proc:
        PUSHAD
( W* _8 e) {1 R5 S  o% A( l        // 查询IDE设备是否存在
$ [1 k3 X+ C# Q; q- Q9 |        MOV DX, dwBaseAddress
7 k& F. j( }/ I# Q1 D: M% J        ADD DX, 7
9 M* Y0 Z' R/ V2 |. M6 H        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
        JZ  LeaveRing0
        CMP AL, 0x7F
% j; e( l7 P; Z2 r  n5 X+ s        JZ  LeaveRing0
# @/ {. U: a( ]* P+ \7 q; t
        // 设置IDE设备存在标志
5 Y) T6 M- j7 g/ J& `7 g5 c        MOV btIsIDEExist, 1

        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
* x- p* f( o" |! e. m9 L        CALL SelectDevice

        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
        JZ   LeaveRing0
1 d+ F$ M- L- f, t! ], w
2 V  A% [: l/ T/ w  v2 l, l        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
) Z" g0 N1 t) P( }1 ~9 V9 l% `        CALL WaitWhileBusy

( c  o; a. C: M+ m1 ^/ Y        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
        JZ   LeaveRing0
- w, ]  U2 M5 L# _1 ~, a/ [
7 Q, k8 ]+ a- ?) I/ k: K& c& S9 l        // 设置驱动器存在标志
7 [9 v. O: e: N# G        MOV  btIsDiskExist, 1
) N5 i; b  H/ h, y, a7 E
5 D$ E+ j* ~  K* d0 l' z* z        // 发送存取端口命令
/ T* N  V4 a6 L        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
4 Q; a! |& Q9 ?7 j6 m        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
* w7 U- ?2 g/ L+ f9 T        CALL SendCmd
& C; ]' R: V2 m+ v& Z* b: X        CALL WaitWhileBusy

        // 检查是否出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
; W2 w* A% F  J% z' Q
7 a( @0 u5 k% R/ j( s* g        in   AL, DX

        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
* L/ h- P" K! j6 C3 O' ]: J
4 C6 f# H. z. h% |( J        // 如果出错，则进一步尝试使用ATAPI设备命令
, ]0 E5 T- J6 q; Z  O0 V; p1 q        CALL WaitWhileBusy
        CALL SelectDevice
        MOV  BL, btAtapiCmd
# v8 q' e! w) j+ e, L        CALL SendCmd
        CALL WaitWhileBusy
. |8 Z- k7 r4 j% y- `% t8 G" X2 Q% m
1 l, w5 G' F+ v3 c; U  H2 q7 y" Q9 O        // 检查是否还出错
( ?6 x1 O% u6 ]" @6 ?9 O. ?        MOV  DX, dwBaseAddress
        ADD  DX, 7
: `8 {6 T8 [& F8 Q. y8 y        in   AL, DX
        TEST AL, btBit00
2 G; `' }7 u- i0 d6 y$ f! a        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回

6 u$ ^3 r& Y  Y0 f        // 读取数据
        RetrieveInfo:
1 U5 e3 i  K# A6 t8 i
        LEA  EDI, wOutDataBuf
$ x2 S5 N" ^( U9 A& I* O        MOV  ECX, 256
, c2 Z* K9 [- s        MOV  DX, dwBaseAddress
        CLD
" H; X; D1 ~- r- R: S  Y, ~: a; O
1 {# l$ o1 J! J        REP  INSW
$ _1 `; H! f, N
        // 退出Ring0代码
$ G+ Y' a( c* Q6 Z0 f% z0 H" g; e        LeaveRing0:

        POPAD
        IRETD
) r7 n+ v/ Y  \( e
        // 激活Ring0代码
% e1 C7 o2 h4 _9 X6 i/ N: Z! R        EnterRing0:

/ I4 j8 h% [8 _3 H; K        // 修改中断门
; \0 M8 g( f# ^7 K# w* d) @        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI

        // 保存原异常处理例程入口
* A3 g: d0 [- z& y! O% ?9 X        MOV ECX, DWORD PTR [EAX]
5 t4 q! D8 D" P5 b- Y        MOV CX, WORD PTR [EAX-04h]
2 Q$ B/ v0 s# U. g; q! i! P        MOV dwOldExceptionHook, ECX
* A  ^' p% d& E5 c/ }
        // 指定新入口
' ^( p+ @; `+ q. [! `( T" u' I        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX

9 t5 ]6 k" L6 Y- V: I        // 激活Ring0代码
& Y* q% W! @6 u1 i; g  E: }        INT nHookExceptionNo
$ L6 \4 A+ K) E8 `' k2 A( c
        // 复原入口
        MOV ECX,dwOldExceptionHook
$ f# A# ?, C1 n, g: w" A6 M0 [$ k        MOV WORD PTR[EAX-04h], CX
4 y% u. ^* K5 N, W) R! m. Q7 D        SHR ECX,10h
' g  q. T* e  _3 s        MOV WORD PTR[EAX+02h], CX
( G. s* {4 i' O7 D& h7 @8 C* g        STI
    }
    if(!bIsFirst)
    {
        bIsIDEExist  = (bool)btIsIDEExist;
3 ^: l: e% i" j# @+ q        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
}
* I% ^5 i& G, o9 u6 `//---------------------------------------------------------------------------
// 调用方法：
1 S" ]- f* Z& P: r7 O" O" `5 F0 Kvoid __fastcall TForm1::Button1Click(TObject *Sender)
, H$ Q" v6 D2 r! t" ^{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
( s, I+ B1 q0 w2 V! B}