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

天云上人

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

1. 
   
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   ( w% W6 M2 L0 C1 {& K
4. #define _WIN32_DCOM
   $ l+ ]6 H; _4 I
5. #include <iostream>
   
6. using namespace std;
   
7. #include <comdef.h>
   ( H: {7 c5 s; a: H1 w6 b* A
8. #include <Wbemidl.h>
   7 r7 a. f- O; \) N; N! v7 C
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    / N# o8 g/ m+ E( K
11. CpuIDDisk::CpuIDDisk(void)
      s/ c; I  ^1 }4 `/ F
12. {
    7 [$ t: ~8 {$ Y0 w
13.     GetInfomation();
    
14. }
    
15. 
    " k- R$ k0 y6 ?8 m: J2 p; t
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    5 W0 ^* `4 N. M: Z, M
18. }
    8 N; g8 {, x2 `$ E
19. int CpuIDDisk::GetInfomation(void)
    1 n# k9 z5 }4 D9 N9 \0 n
20. {
    , _9 {5 v9 r4 D: i
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    1 C$ J# L! ]9 w& m
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    9 s, S5 @5 }  A0 i' F; W; K7 A8 }
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    1 A$ X( l, H$ A& E' `; Q
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
      F6 j: U, Q: ?/ d; Q
30.     hres =  CoInitializeSecurity(
    ! Y3 n' Q- R  ]
31.         NULL,
    
32.         -1,                          // COM authentication
    , T  J8 a- e* T  _) N
33.         NULL,                        // Authentication services
    # }) E( {4 C" e: a/ x9 Z& s% i0 M: N; j
34.         NULL,                        // Reserved
    
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
    , q9 e% U3 M5 A+ z* f
40.         );
    
41.                      
    ; S$ |: @" R4 T2 E- S" Y" J
42.     if (FAILED(hres))
    ! N6 e' U* P) C" p, P" r" T4 ]* y
43.     {
    - r" T4 M7 l  H7 M4 `2 S
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    
46.     }
    
47.    
    + q- S9 N/ C) S4 Q4 \4 `
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    1 o* c. f* m  N
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    
52.         CLSID_WbemLocator,            
    % m) ?7 `2 Q# L0 q! g4 B' e
53.         0,
    ; E6 A$ j9 D% q. `! c
54.         CLSCTX_INPROC_SERVER,
    
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
      u5 b! g, O" \
57.     if (FAILED(hres))
    " s( E3 a5 x4 S# P1 G# @
58.     {
    : v" k% P0 g* o- m' t7 J3 E
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    ' a% y7 ]0 D+ W
61.     }
    0 r: ~7 B* A7 H7 ^! {
62. 
    8 H7 h/ C7 a& @. d# k8 |& ~( }* T
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    9 @: s( y1 e. P# S/ d
69.          0,                       // Locale. NULL indicates current
    % e! \- S! O  E9 r; h
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    4 }& z7 v* A3 Q1 c9 `7 |0 Q) j  G
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    . ~+ I1 m* c3 O3 c: T  w* d
75.    
    % i$ `4 e- u* @- h
76.     if (FAILED(hres))
    
77.     {
    
78.         pLoc->Release();     
    
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    " v8 w# k; p8 K: x- V
81.     }
    1 i6 x3 y! G% Q2 g! {
82.     // 步骤5： Set security levels on the proxy
    / h+ d! ^. ?6 I4 T7 H7 `) M
83.     hres = CoSetProxyBlanket(
    4 l; o% {1 G, r( @0 N
84.        pSvc,                        // Indicates the proxy to set
    # L4 ^/ O# N- ?7 X4 A  {
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    % v/ c* C2 `/ r% m; {
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    
87.        NULL,                        // Server principal name
    9 w* Z0 N, c4 v$ |5 i+ M
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    " Z' s7 E2 O# D" s0 r& o4 t( ]
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    3 g) d& V+ V. ?) ~5 n" m3 z
93. 
    + y5 D- s; r$ w
94.     if (FAILED(hres))
    , u# a- e0 L1 K0 k
95.     {
    + X# s  p1 k- y4 l4 t
96.         pSvc->Release();
    2 c) `8 K% M. R$ F
97.         pLoc->Release();     
    
98.         CoUninitialize();
    1 Z, T1 Y/ l9 H2 k0 u% d6 j
99.         return 1;
    
100.     }
     
101. 
     7 R- @4 q2 n) P
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
     ! M( ?4 R& u" i& f! \2 t: m$ S4 R
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     " p9 V4 F' ?9 r
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     
110.         &pEnumerator);
     0 t$ T2 y1 U0 k8 C: e
111.    
     4 I: q, D- a0 x# z+ w" s
112.     if (FAILED(hres))
     
113.     {
     * n) h$ a$ N; Y' [0 C
114.         pSvc->Release();
     
115.         pLoc->Release();
     
116.         CoUninitialize();
     
117.         return 1;
     
118.     }
     3 I. u) ]1 P5 @8 e
119.     // 步骤7：Get the data from the query
     1 P1 ]! e8 ^# e- @
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     
123.     {
     : S8 z( V$ U) M+ c1 p
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     # t# _( Y( Y! k: j) S1 E
126. 
     
127.         if(0 == uReturn)
     
128.         {
     1 x& W/ o1 F! G5 l8 i) Y4 F
129.             break;
     
130.         }
     + H% B4 x8 j2 P
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     5 X. Y( I9 `' F
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     5 r  U9 K. X' \: l* S0 p) I
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     
136. 
     
137.     //计算硬盘系列号
     # Z5 _3 t) o" ~0 Y# E
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     * a* S/ J% a# q2 a2 B8 u( B! q5 R. L
142.         NULL,
     2 F/ V( O+ W# k: e
143.         &pEnumerator);
     8 e" L+ v) `: w: K( z4 B
144. 
     - b& o5 l- x# z" t% \" e4 F
145.     if (FAILED(hres))
     
146.     {
     3 B  {" l8 q3 _2 }
147.         pSvc->Release();
     
148.         pLoc->Release();
     
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     ) r- M; n7 L/ C1 d% x
152.     while (pEnumerator)
     
153.     {
     ; X" R; a! w# R& T% v0 C- ^
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     8 N, E# r' w/ ^
156. 
     
157.         if(0 == uReturn)
     
158.         {
     
159.             break;
     
160.         }
       _. Y1 e2 }$ n1 o' B
161. 
     7 j8 _: g: d. ^- x
162.         VARIANT vtProp;
     & J9 W; b4 T0 g9 @1 B, a
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     $ W  L& Z: T' `6 `* L2 w) g8 q
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     9 m+ O! v1 ]7 u6 J: ]  {+ r
166.     }
     
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     7 c0 E' Q% c0 C/ Y* I( y- b4 y% |
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     & \3 [6 ]7 T) t, d: l# U: e
172.     CoUninitialize();
     
173. 
     
174.     return 0;   
     6 z; j* z" l) ?# k8 |- t) m
175. }
     / l& ^$ R. c7 M! O( k' \1 K

复制代码

天云上人

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

#include <WinIOCtl.h>
#include <stdio.h>

#pragma inline
" [. B- F3 o9 y( V2 N//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
$ K, q$ g; S3 i8 R" K5 `# M! g#define DFP_GET_VERSION         SMART_GET_VERSION
#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
. f- e" e- t- M9 ?8 I7 w
const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

+ Y4 M" ~: p& Fconst int MAX_IDE_DRIVES = 4;

- B) Z! p! i9 S) @// SCSI专用变量
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
{
+ h3 ]7 G/ _3 {  b2 e    ULONG HeaderLength;
    UCHAR Signature[8];
1 x6 |$ I$ M. n4 r; S: m    ULONG Timeout;
! u5 W* b2 ^7 m: f% B3 ^7 Q. l5 c- J    ULONG ControlCode;
6 y4 m' h9 i$ }- K/ F9 |9 Y! K    ULONG ReturnCode;
# a1 t6 I' E. F; O( H. n    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

# o9 Z. r1 A9 N4 H" O2 O& _// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

% T, w  ?, k0 ]) [  ~  A4 P// 辅助函数
3 x" ]+ j4 y, D6 {: x2 l- p2 Zchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
# l& A; E* ?; v0 |/ w* L, q// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
8 F  b1 h$ o7 z/ j9 q$ [bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
) h  W$ m+ _; S7 @, s. k        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
8 F5 e0 O6 x- Y! K8 C4 X// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
+ M" d( S, f* a+ D8 i: l        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
- Z! I7 c& n) r  g7 y7 L
9 b7 R6 W- n0 R9 U// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
) X" @/ m" l5 e: [//---------------------------------------------------------------------------
( ?* Q' C: @3 ~' M// ReadPhysicalDrive
& k7 S; u) M4 b3 _, [1 {3 qvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
    switch(Win32Platform)
* W- c+ l" Y7 o% I  b- S    {
        case VER_PLATFORM_WIN32_WINDOWS:
# \( V2 B: a8 f) V" [: K( Q; ^            ReadPhysicalDriveOnW9X(pSerList, pModeList);
0 y- `  L2 a/ b# a& I+ L  n            break;
& y9 U- N/ v' F" A7 ?9 v) `" Q, p        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
3 i  g/ c, j: o& v. b$ L        default:
            break;
5 q5 d$ Q" @1 V. H6 `/ u    }
- r" T) ~6 s5 ~9 b}
//---------------------------------------------------------------------------
! m6 U0 V; F- a" }1 A4 c// ConvertToString
9 F# S/ P, S1 _* n2 |char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
9 \+ }, H6 ?* E9 [{
    static char szResBuf[1024];
- g+ ]: W$ i& I4 D0 K    int nIndex = 0;
/ [5 H- U" p: Q2 S    int nPosition = 0;
7 C  A9 M. O% l
    // Each integer has two characters stored in it backwards
- b9 F; a8 c( ^/ d    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
+ A) Z1 g: W- F! Y    {
- y5 q7 L: ^" c9 w# @( m        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;
) X! B* C2 Y0 g: a  X
        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
, S3 N( s% p& D5 U8 D% I" @2 g        nPosition++;
* B, Q6 Y% y, Z. o; L    }
% Q5 |) Z! C) v1 Q6 {% e) O3 U
0 p" Q" [2 \( f5 q2 J    // End the string
5 G5 i/ w- `: {1 a9 D2 q    szResBuf[nPosition] = '\0';
" g, G; H" p" P9 U. M4 @% A8 H
. ?/ Q1 P+ {" \# w( i/ @4 h    // Cut off the trailing blanks
. K' `  L. \) g, K( X8 R    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
; ?% }4 ^* D2 r9 {2 d2 d. M; e        szResBuf[nIndex] = '\0';

    return szResBuf;
7 I3 m0 j' f' ^5 ]: B}
2 E7 V! b8 B, }  a- e0 y//---------------------------------------------------------------------------
" b# J: P% a  c  z" ~" y$ \// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
4 G) x: N/ v7 {// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
    // 输出参数
  t, `. O5 {4 g+ B8 j/ T    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

0 I: k; m1 b7 p' Z; Y' ?' n    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
( |& ~7 Z& X0 |# [* I# Z    {
        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];

7 P* h( N4 E, t* P2 W9 A        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
- C$ E" O& ?8 c, F- u        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
% ~8 D3 M$ ]6 z  S9 f                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
! ^. G0 }" s5 b                        OPEN_EXISTING, 0, NULL);

  t5 o4 z7 i1 r1 w/ g  e        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
3 V+ n3 M6 B; Y        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;
, n9 z1 d5 D' @! g
            // Get the version, etc of PhysicalDrive IOCTL
' I! c( P3 x* {            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

! g6 J- A/ n$ ]# v& x8 k) a9 u            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
; P  z! n1 K( ?) A" O7 H7 H                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
9 }1 F$ w$ R) B! K) x) y8 d                    &dwBytesReturned, NULL))
$ |: O; ]: s8 \; I6 w  P% ^            {
" j8 m) Y0 _$ F% C                continue;
            }
3 ^4 d1 P' r: m; q" x& ^" D" h
            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
                // IDE or ATAPI IDENTIFY cmd
2 [: c" \5 f6 k8 `  W                BYTE btIDCmd = 0;
                SENDCMDINPARAMS InParams;
                // Now, get the ID sector for all IDE devices in the system.
/ q( r  w' i2 f) {* E( s                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
% b7 p* E: M6 W3 k                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
) I! n& N6 i2 [, Z1 z                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

, [! ~+ F# ]9 J/ g                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
' C  h$ h! I, z  z4 |; d                {
                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                    char szSerialNumber[21];
                    char szModelNumber[41];
; N' y% b! I* B- ?
                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
* D' V0 M) W# }5 A. j. _% d                    for(int i=0; i < 256; i++)
, K5 p, h; d7 p. Y$ G                        dwDiskData[i] = pIDSector[i];
5 g  Z" u3 P% W& R" s% p7 W) _                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
+ u" J7 J5 z- Z
6 v6 l+ f9 Y% |1 f% e/ ~' {0 T                    // 取模型号
( |% g3 n% L) H' h: y& E                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
4 n8 P+ ?" e* D( e$ f                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
                }
) w3 B# @0 I& ]% C- p4 }* h            }
! q% c2 m& L0 y7 g% q' U            CloseHandle (hPhysicalDriveIOCTL);
: _9 \9 b* @' I$ L. v        }
/ I/ ]5 F' I: h2 d: Y: }    }
3 O& B* @3 n9 k" c" l: D1 \}
: R0 y5 A( R4 I9 ^# R3 F' e//---------------------------------------------------------------------------
/ A6 q- a' N0 r// DoIdentify
. K  Z! p& u- m8 i% S$ B9 Y1 hbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
{
    // Set up data structures for IDENTIFY command.
, M. t' m% h% @# x# t/ o    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
: @' Y% ?1 [' `6 \" H. K1 c- Q! ?    pSCIP->irDriveRegs.bFeaturesReg = 0;
! f0 ?. Z- Y. J    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
7 L9 p. F% `2 `. w& k7 d3 x$ K: U    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
& D& }1 C4 f/ [. O    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

1 {/ h8 H$ A* N0 `& ^# t    // The command can either be IDE identify or ATAPI identify.
0 {9 ~- A3 i( [& Q    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
/ j8 H& U5 }/ |+ m( \( n% Q! l    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
1 ?' \% }+ E* J; E2 T9 \4 N5 @. R
, F9 B$ P! C% k: _% A( H    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
) u( P0 s' q# s! ^$ |           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
& P% D  |1 l# T0 E//---------------------------------------------------------------------------
- X* S+ d0 o! p8 M// Windows 95/98/ME 代码
1 T& d4 s: c# z0 z: E9 y//---------------------------------------------------------------------------
4 J2 `+ Q! d5 X) }! X& U! l// ReadPhysicalDriveOnW9X
' p' M7 E9 K! d* L0 F2 p3 p: hvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
! p( `7 K! F2 a# J! ^8 B    WORD wOutData[256];
- p9 z9 a3 \: a! I" E    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
) c. W/ m- f. n. f0 N    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
6 _. x' X  t6 K        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
        bool IsDiskExist;

        switch(nDrive / 2)
" o& q; @! G3 c. M        {
% _  l# ?5 e+ ]. `7 H3 m" u            case 0: dwBaseAddress = 0x01F0; break;
4 n) d5 f  Y# ~- P' U5 |3 s) U            case 1: dwBaseAddress = 0x0170; break;
* ?9 Z7 h! {4 y4 H1 U9 Y" n7 M# l+ i5 q7 h            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
! h+ j; x6 C: S2 q0 h# l4 Y        }

) ?' R) B( {8 x/ C0 o; J        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
# V1 X4 F+ `7 p! Y& i( j
. S3 j4 Z+ P" u) T! t% w        // 进入Ring0
3 Q" Z9 ^- n" r' t: f        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
7 v1 A& W6 w! k7 z                bIsIDEExist, IsDiskExist, wOutData);
    }

    // 开始读取
; f' A* R, e% |7 F5 `    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
% k, C% H* x+ j, S4 c        WORD dwBaseAddress;
1 R7 E/ w& p; U" K7 M        BYTE btMasterSlave;         // Master Or Slave
! G4 H1 n. i' k1 t4 h9 w, y        bool bIsIDEExist;
( ?+ u' D, G) a) \        bool bIsDiskExist;
        switch(nDrive / 2)
  Q; N2 Q7 F6 T; p- \+ {3 [7 D        {
) s* n6 Z( h. q            case 0: dwBaseAddress = 0x01F0; break;
9 f( _7 q* s. n4 o- \3 b# I8 t            case 1: dwBaseAddress = 0x0170; break;
$ G) P1 F; U' M            case 2: dwBaseAddress = 0x01E8; break;
. F5 k7 L% E! W# s" ?. l, Z6 |. ~            case 3: dwBaseAddress = 0x0168; break;
        }

6 L  W/ I+ s) t* d5 }        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
" R' x. k* E  s2 Q0 \% W
        // 进入Ring0
5 u8 K3 w" ]6 p) F8 h0 J        bIsIDEExist  = false;
        bIsDiskExist = false;
# m* I; k1 S) E; X( c        ZeroMemory(wOutData, sizeof(wOutData));
5 _: N/ b" o* P8 j* ?
        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

        if(bIsIDEExist && bIsDiskExist)
        {
$ `# Y6 Y' v; o8 L2 @            DWORD dwDiskData[256];
) O4 G* M  B7 {% g/ l1 A" u2 g- e            char  szSerialNumber[21];
* M/ l8 \6 `( k# T% v            char  szModelNumber[41];

, u5 V8 j2 B9 X( X7 C7 ]; T            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];
! ~& N5 O6 N! [
  ~# j& I: R3 @# N# |            // 取系列号
! S5 U$ V' b3 K+ o            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
3 ^) |5 G" R# X( m8 b
# M) Q4 q: W& k0 _            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
' F+ X) X  ]- @: k5 H+ p4 N( C# Z            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

' R4 @2 \7 i5 \7 |            pSerList->Add(szSerialNumber);
/ x7 d% V( Q5 v  ^, C/ i            pModeList->Add(szModelNumber);
6 w& K: S/ [1 }9 }7 k        }
' s: W5 p9 C3 h6 s( N0 o    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
& ~  G, q& q3 T8 z  [; v//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
) r3 Q) {  g$ e2 x# k6 j; {; C//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
" K" V; o2 l/ L- [1 s2 a/ {//---------------------------------------------------------------------------
+ U4 @0 S8 Q) t, K( R* Lvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
& X7 l' ^5 K8 @. `    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
. N- P9 y8 l9 t# N4 L    const int nHookExceptionNo = 5;

) R8 H6 [( b" N. F# K    BYTE  btIsIDEExist = 0;
! r  @2 u& s( {2 j! T' p1 P7 Q+ i    BYTE  btIsDiskExist = 0;
6 [  u5 |6 D: D; }6 g    WORD  wOutDataBuf[256];
) l1 F' w1 a2 E: y* L
0 {# u) g2 e3 @' m/ U: b  ^: `( G2 X    BYTE  btIsFirst = (BYTE)bIsFirst;

% m2 v1 i$ `3 i4 \- _6 ?    const BYTE btBit00 = 0x01;
" U. n9 p5 L; \! E$ Y) O    // const BYTE btBit02 = 0x04;
7 K/ C6 S, U, W5 D4 m9 `    const BYTE btBit06 = 0x40;
& a0 i- e9 k! h" n    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
7 b7 B: H0 f) P5 W    const BYTE btBusy = btBit07;
5 g8 }: [, F4 B    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;

    __asm
7 P; S9 Y" j9 p& {$ q    {
        // 必须先执行这条语句
        JMP EnterRing0
' ~* Q% Z; i# `
        // 定义过程
        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc
% v7 @  ]: `, P9 A' n% M
! \+ ]& ^3 A; I        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
        ADD  DX, 7
/ l  g1 S0 H5 Q" |- @' l- t7 A
        LoopWhileBusy:

( h7 r7 Z" C% H! B6 }- d+ p        DEC  EBX
! W9 S/ ~+ c& a$ I. w        CMP  EBX, 0
        JZ   Timeout
( O- H; |' p! k) I, E3 {; L, M2 M5 ^        in   AL, DX
* _* w7 L$ _5 m" t4 j( C1 Z6 q        TEST AL, btBusy
        JNZ  LoopWhileBusy
# J* M8 w8 Z5 {' D2 I4 R        JMP  DriveReady

- ^! N# i, t8 a8 _        // 超时，直接退出
5 j& {3 G* A, ^9 {) D* t        Timeout:
        JMP  LeaveRing0
. T- ?4 h. G) o- N6 S        DriveReady:
        RET
        ENDP   // End of WaitWhileBusy Procedure

        // 设置主盘和从盘标志
( C: f' S2 E* {- _        SelectDevice proc

        MOV  DX, dwBaseAddress
        ADD  DX, 6
2 N6 q$ g7 Z7 k+ n& G. T        MOV  AL, btMasterSlave

        out  DX, AL
        RET

        ENDP  // End of SelectDevice Procedure
: I+ ~; _" b0 r/ b* A. K! w
        // 向IDE设备发送存取指令
        SendCmd proc

        MOV DX, dwBaseAddress
        ADD DX, 7
5 g5 N" O$ R5 F9 E        MOV AL, BL // BL是主从盘标识，在过程外设置
6 x! c4 X3 t3 n. z! x        out DX, AL
        RET
        ENDP  // End of SendCmd Procedure
$ j0 }( P4 C: {$ @. ^
        // Ring0代码
        Ring0Proc:
/ O# m# M0 }8 N4 f3 g6 s1 E        PUSHAD
3 N$ ]- [; n& ~& T& V- x2 j' T        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
0 G! R& [& g# l7 N! I6 U, u        ADD DX, 7
+ ~! h: k" W+ p. `/ S( |        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
- P$ U8 F7 ~* ?" O$ P        CMP AL,0xFF
6 h& g) a2 R4 b' D% H7 f        JZ  LeaveRing0
        CMP AL, 0x7F
# {7 o# q$ }& h        JZ  LeaveRing0
1 z4 Q! H. {0 q
        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1
3 N( ~1 u8 ]- m6 q4 M8 x
        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
        CALL SelectDevice
+ A. @( V5 K; V5 [3 y1 V+ H& d
; }( K* A/ v  B5 m6 m        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
7 ?) J, |1 t  d7 a6 T        JZ   LeaveRing0

        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy
6 g$ X# U& I2 {) D" |; l* s
  `2 f% h/ C$ s3 @        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
        JZ   LeaveRing0

        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1

        // 发送存取端口命令
1 w$ R) Q7 N! s$ @        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
* N' ]8 y+ N6 i& k        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
        CALL WaitWhileBusy
5 h# N( X7 t8 c$ |. n
        // 检查是否出错
+ e/ Y9 O6 l1 L        MOV  DX, dwBaseAddress
, [) O1 X) Y8 d6 D4 B  ]  d$ p        ADD  DX, 7

        in   AL, DX

: N* r; D* M+ ?7 {; B/ Z; S        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
6 u9 ]; Q! q6 K+ R$ B        CALL SelectDevice
        MOV  BL, btAtapiCmd
; I" p$ R6 P7 p0 [4 V9 _        CALL SendCmd
        CALL WaitWhileBusy
. W8 s  q; Q. }5 i+ C
        // 检查是否还出错
. i4 F$ ]9 V& }        MOV  DX, dwBaseAddress
+ l; O+ m5 G" P1 b        ADD  DX, 7
        in   AL, DX
; K: Q! ^( V" |  U: @        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回
2 C. w0 N* }6 E- K
6 y9 k; J. _+ Z        // 读取数据
        RetrieveInfo:
! a/ m8 I5 c5 U( H& `( A
        LEA  EDI, wOutDataBuf
6 Y& H( X- F4 l- h        MOV  ECX, 256
3 B2 N* G7 U5 r/ v3 n; f3 g1 c5 y        MOV  DX, dwBaseAddress
        CLD

        REP  INSW
4 E3 d6 W) H, k
. N1 G0 d0 Z* D" J        // 退出Ring0代码
4 E2 |0 |& ^8 b* p% s& }, e2 B        LeaveRing0:
$ q9 ~+ C( v" y, H( r7 A
+ m+ B$ B. }7 M4 |: C. c6 l        POPAD
        IRETD
1 {! W+ K- P4 g0 S# c' ^
. V! c) {2 S% x  P        // 激活Ring0代码
        EnterRing0:

        // 修改中断门
        SIDT FWORD PTR btIDTR1
' }7 `! J" |. n! i        MOV EAX, DWORD PTR btIDTR1 + 02h
( X7 p% b4 ^9 |* h7 |# o        ADD EAX, nHookExceptionNo * 08h + 04h
! a7 w% `* V+ n* d% C; F2 F2 p. H        CLI

9 M5 |4 K" E) b        // 保存原异常处理例程入口
/ M' i; U! c8 s4 p5 ~5 a        MOV ECX, DWORD PTR [EAX]
% p. D! a3 i2 R2 t; {8 C        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX

2 h) y& J% t/ _( A! ]        // 指定新入口
* R. j; V  l: }+ m6 q7 m% Y, V( p        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
- R3 Z0 l' Y, |9 A& W        MOV WORD PTR[EAX+02h], BX

7 h  ]  S- Q2 ~! B! c, H6 N        // 激活Ring0代码
        INT nHookExceptionNo
4 j* |4 H4 W) k+ F0 s6 A/ M7 M5 R; |) w
- |8 v" L2 z7 X; \! z: x. Y0 O        // 复原入口
        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
& }2 {" @. l; U- _; R        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
        STI
6 ?7 F# W1 u( r" \% f    }
* Y4 u" ]" v, _( o    if(!bIsFirst)
7 S7 J& y- D$ ?) n7 n    {
        bIsIDEExist  = (bool)btIsIDEExist;
/ M. E. x4 `) ^  u        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
}
" d6 W. k# w$ H9 `9 r/ g//---------------------------------------------------------------------------
0 Y; W0 g& ?2 Y' \7 Z4 C- g2 }// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
* d+ j9 w& s4 L- i! x' C}