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

天云上人

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

1. 
   % w9 B' c7 r, L' Y; @: u+ w6 b
2. #include "StdAfx.h"
   $ p  x( g4 E( l6 ?
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   
5. #include <iostream>
   
6. using namespace std;
   7 W6 d; O0 Y2 O; j
7. #include <comdef.h>
   ' y! _* k3 T6 r( M: d
8. #include <Wbemidl.h>
   0 p% I* P3 |$ q) r! ~8 E3 R& K
9. 
   " v' o2 t" L+ N7 H. k. S+ Y
10. # pragma comment(lib, "wbemuuid.lib")
    ) o+ G* A' w6 k  T% \8 a; L$ o9 m$ b
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    
13.     GetInfomation();
    
14. }
    
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    8 A3 J: J) v) p6 b
17. {
    1 U6 V" n: z- i- K, V; |5 {
18. }
    9 M8 r  m& U; c
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    + }' J, ~' W2 f: [1 X2 ?% [& \8 n
21.     HRESULT hres;
    1 u( w$ p2 g0 x$ G, g
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    3 h8 I. t( M( r; C" n
24.     if (FAILED(hres))
    
25.     {
    4 v4 h! H3 z; _
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    7 \' ]0 Y4 i' U) J  ]6 Y
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    , l, G4 [# s: z7 u* F
30.     hres =  CoInitializeSecurity(
    . u0 Z' H- e. N9 u! m+ q# w
31.         NULL,
    
32.         -1,                          // COM authentication
    7 p  |: D  @! T5 N! i3 O4 w. |
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    $ T3 |' [& }2 M& K
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    7 r/ Y) m; Y' w: Z
38.         EOAC_NONE,                   // Additional capabilities
    : i1 k/ n* J+ G2 E! L
39.         NULL                         // Reserved
    
40.         );
    4 B+ {, I( @$ p  r4 @* [
41.                      
    
42.     if (FAILED(hres))
    
43.     {
    2 M- J* X3 A" O: r6 \- m* P
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    * ]( g; B$ x( L
46.     }
    * C- `- g* [; N5 k
47.    
    + Y& d2 U- W) v
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    - e& e5 }) @: K& w
49.     //步骤3： Obtain the initial locator to WMI
    . ~; v' H, N9 w6 |, G
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    $ Y( _7 ]6 }3 |
52.         CLSID_WbemLocator,            
    
53.         0,
    , _* a; n; i- U9 }* ^$ D$ T
54.         CLSCTX_INPROC_SERVER,
    
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    & y) k* b% h$ ]6 |3 i
57.     if (FAILED(hres))
    
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    5 c$ C- M; R2 G2 A% w7 A
62. 
    - G9 `5 j+ d- Y5 T( A1 U
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    1 u2 _. K* |5 T  d
64.     IWbemServices *pSvc = NULL;
    3 q* L+ L5 @; i$ c/ _- G4 Z* T
65.     hres = pLoc->ConnectServer(
    7 Y( g5 t$ h5 z/ M6 N
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    8 r0 r( b4 _" A5 A3 Z1 ]) G+ f
67.          NULL,                    // User name. NULL = current user
    ! E/ w+ \! |. c$ `
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    1 F: I/ C$ K6 S6 d
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    ) c. }4 j. u: u8 E: v, D8 \; X
73.          &pSvc                    // pointer to IWbemServices proxy
    ) M, T2 u" n6 f4 x8 v# y- B( }
74.          );
    2 ?9 c$ G0 L/ U
75.    
    " C4 Z5 s1 j- x- F+ s' {
76.     if (FAILED(hres))
    
77.     {
    
78.         pLoc->Release();     
    
79.         CoUninitialize();
    * J) a+ F7 ]5 }! `' k
80.         return 1;                // Program has failed.
    
81.     }
    1 I( K2 F) `9 C1 F0 s# ]$ V
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    ; U! I0 s, j( G' f* C( u; ?) f% i! P
84.        pSvc,                        // Indicates the proxy to set
    * D- U3 M& q, I' f* W
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    , q' y( C1 m/ [) z0 F* j# u  |3 l
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    7 w$ _% ^  E* i3 X  {1 K" f2 M2 N
87.        NULL,                        // Server principal name
    # a' l6 |& W: v5 T# J3 f
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    ! D; `8 v- Z# W: }6 @$ J/ Q
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    
90.        NULL,                        // client identity
    5 ], J) p3 q3 _3 s
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    
93. 
    
94.     if (FAILED(hres))
    8 ^; {: e, B6 v$ L/ l$ @7 x
95.     {
    / x, H) w; H- ?/ ~6 k1 Q
96.         pSvc->Release();
    + j" A" ?5 o+ Y( T3 U. r
97.         pLoc->Release();     
    ' s/ a! ]/ f8 I
98.         CoUninitialize();
    
99.         return 1;
    
100.     }
     / V8 u! f& x9 g- S
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     ; K1 S! ~1 q+ W- l/ K* a7 q
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     6 Q0 M" N) v6 R
106.         bstr_t("WQL"),
     * ~. @/ B; f: c/ M6 K
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     
110.         &pEnumerator);
     
111.    
     
112.     if (FAILED(hres))
     
113.     {
     
114.         pSvc->Release();
     
115.         pLoc->Release();
     
116.         CoUninitialize();
     & H. L( W1 f/ f. R' q0 y% k* d
117.         return 1;
     ! Q$ ]7 g1 j' C# \
118.     }
     " i" e0 |; O) `4 j/ v; r
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     3 |: W7 Y5 ]+ v( _$ q9 s& ]
121.     ULONG uReturn = 0;
     ) j* g+ `9 F# z8 O) l/ i
122.     while (pEnumerator)
     ( ^1 J# h) V/ M/ r
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     6 m; H/ G$ I! F6 A/ ^
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     
128.         {
     
129.             break;
     8 n- ^% ^* i8 n! C6 X# y1 A9 B2 _
130.         }
     
131.         VARIANT vtProp;
     * _5 I* C$ r9 X( Q" Z/ Q+ K2 P! s
132.         VariantInit(&vtProp);
     : v/ L7 W. d. A, Y
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     5 N- I* A$ W0 r# p/ A- t  Q6 s, k, G
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     8 @/ `% ^5 |7 O7 n4 c$ |% ]0 c
136. 
     ; i) T) t: P8 Y; a  O& c
137.     //计算硬盘系列号
     
138.     hres = pSvc->ExecQuery(
     # o3 H# r8 c- ~1 R. l! J3 H. s
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     
143.         &pEnumerator);
     
144. 
     ! M* @6 k: j" _- y$ P$ H
145.     if (FAILED(hres))
     
146.     {
     , x' N# l0 d) ~, S! c4 _
147.         pSvc->Release();
     
148.         pLoc->Release();
     / ^3 ^: q% D! t
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     
152.     while (pEnumerator)
     
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     
156. 
     
157.         if(0 == uReturn)
     
158.         {
     
159.             break;
     
160.         }
     
161. 
     0 v( S8 p4 `3 B+ h# e
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     ' e1 _# @6 C! n
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     . @4 i; ^" M, D( Y
167. 
     + v. D8 r; z' Y2 r# s  j
168.     pSvc->Release();
     
169.     pLoc->Release();
     0 }/ ]& H. y+ W* K$ L; F
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     ; C) ~  I" e/ g% F+ }
172.     CoUninitialize();
     
173. 
     
174.     return 0;   
     
175. }
     

复制代码

天云上人

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

+ I0 \, \, P8 K#include <WinIOCtl.h>
#include <stdio.h>
8 C( E* I! S4 G
#pragma inline
6 T4 N0 u: P' N% ~. D9 n2 }4 N//---------------------------------------------------------------------------
- `. e4 C3 x9 p' i// IDE NT/2000/XP专用变量
: q0 ?: |3 P" P# l0 t( m#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
' b0 u5 o% _! h, ?# N/ w#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

const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

- Q: u; C! L" }- ]* D& L/ hconst int MAX_IDE_DRIVES = 4;

! p7 c6 @/ }  _' S( x// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
8 m' I$ {$ R; F3 Z& e, ]+ l  pconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
4 [% v: `0 S" _! t! `const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
$ \" J" v5 t0 ]: w9 y. Bconst DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

typedef struct _SRB_IO_CONTROL
8 s1 F2 `# Y, k: h' o{
    ULONG HeaderLength;
( A& E/ J* T1 y# j    UCHAR Signature[8];
' C# \2 B! X; x: ]/ s    ULONG Timeout;
    ULONG ControlCode;
& x8 y: A6 O6 @- j" k- a- i    ULONG ReturnCode;
    ULONG Length;
0 `. H8 P2 }- g: P+ O}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
' c% O! N5 l+ q. S
// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

) t7 K( k4 n! E. y7 e// 辅助函数
' Z  ^0 k: e0 A- b. a' b& ]char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
# U  P1 t0 A5 h% E- |// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
) X3 \  E3 V% R        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
. |* E$ \( ]2 V( B9 Y- @. Z; {void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
5 H3 }6 ]# U' h+ ^. z        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

// SCSI读取函数(for NT/2000/XP)
7 S' D6 g3 c4 y  X4 K8 R! @; wString __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
* z4 \( A) G! X! z! `# a// ReadPhysicalDrive
/ [2 a% O& R$ \" @9 x& o0 c% S1 j8 Uvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
* u' W- v/ U5 y/ Y+ R. V{
    switch(Win32Platform)
5 `" ?2 s( A9 F6 s    {
1 X( s2 j% z- k/ d8 G! }        case VER_PLATFORM_WIN32_WINDOWS:
5 |0 T5 F! W1 p            ReadPhysicalDriveOnW9X(pSerList, pModeList);
; l( S# Y+ g) |  |- w5 g$ ^0 [            break;
- s( L5 m$ K, H( B& S, K/ s        case VER_PLATFORM_WIN32_NT:
  l& X& a( z" O% f: A3 X. g            ReadPhysicalDriveOnNT(pSerList, pModeList);
, E; J7 O1 i4 ^. A% g# n            break;
2 I6 S) ?7 c& y# P; W        default:
            break;
9 C1 v& C" E: S4 b    }
}
6 }, I9 x) {1 l//---------------------------------------------------------------------------
; b, b7 ~# f3 }/ W! O// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
  m' q! N9 v& K8 V{
2 C) A, H2 g: `3 N% g& C    static char szResBuf[1024];
4 m1 i# ~0 Y, ^) t    int nIndex = 0;
4 b" G% {! K9 L) ^) q8 c$ t    int nPosition = 0;

    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
& s5 U: I5 ]6 _# u3 Y    {
        // Get high BYTE for 1st character
9 N: e' S9 c; C: Z$ c( E0 J4 e        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
7 l8 T- X& U8 c        nPosition++;

        // Get low BYTE for 2nd character
( ?3 G% [6 |: f. Y        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
/ P4 t2 T  |9 }  w; J& h, N: z        nPosition++;
    }

$ v1 Z# @2 q" o, C    // End the string
    szResBuf[nPosition] = '\0';
) b- ]4 O. d$ L' J
    // Cut off the trailing blanks
    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';
& k2 Y, a* u2 w3 U' B2 F: m9 K
    return szResBuf;
! i( G. Z& X' {}
' j+ l3 t9 a1 V. l8 Z* o//---------------------------------------------------------------------------
8 c+ ]* B6 I3 _// Winndows NT4/2000/XP 代码
' c& N6 N9 r/ s' w: a. u//---------------------------------------------------------------------------
; u3 L. f* J- U3 {3 X6 U// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
( a1 [! O! J. n: L+ A1 `: I* a{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
: x. }1 ~; k5 N$ D( f! K! d
    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
( B. R2 F& [! _$ h. H3 w5 ]    {
  g$ \/ {9 I* g1 I        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];
- F5 l( E; n6 Y- i
% h, _) y7 B; R" G; q        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
5 C/ m+ x2 V, z1 y1 C1 w; H        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
7 ~5 ^( z2 \! N) q: n( F                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);

        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
9 x" }# H! I: n" j' ?( ~' B/ C" N, a! i        {
: a# Z6 {& L# }  Q            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;
' l( e  ~5 W; D" i( y
            // Get the version, etc of PhysicalDrive IOCTL
2 U! r/ _  N* w) j% l9 ]  N# I) e. Q            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

; [# f" m) t$ u& t, v+ E6 T            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
            {
                continue;
' g3 g) V, @0 o  y6 t/ l8 C5 J  Z            }
, j+ ]6 k$ t# }: M/ G
            if(gvopVersionParams.bIDEDeviceMap > 0)
' {/ h. q( H. q& U9 c. I. P9 h            {
; ?9 {& S3 Q2 S/ q4 P                // IDE or ATAPI IDENTIFY cmd
                BYTE btIDCmd = 0;
$ F4 o8 A3 h2 |4 ]' H8 f: a$ H                SENDCMDINPARAMS InParams;
                // Now, get the ID sector for all IDE devices in the system.
: M, j* @- n6 n                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
                // otherwise use the IDE_ATA_IDENTIFY command
5 ^5 C/ l& c8 V                // 具体所得结果请参考头文件中的说明
  T- }7 v. d$ m0 A7 Y7 C. t2 q                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
1 ]: J/ c" a! M" l1 V
: v$ H% z! Z" ^% |" {0 a                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
. l. X, {% [" V5 O2 O  f                    char szSerialNumber[21];
8 I. w$ G; T/ C# T0 S  B2 ]" @  _                    char szModelNumber[41];

$ z8 A4 E8 ?  m4 N! W                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
$ x$ }& u- Z# X' `9 q                    for(int i=0; i < 256; i++)
6 |" G  s+ B" ?$ S* t! w                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
# d7 f) G3 _7 I                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
2 N7 }) ^3 C8 `# z0 c7 D% L& v                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
6 E6 i: L$ V& U
; R8 y8 p% M8 u% k5 z2 Y  h                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
# Z, T+ W# p7 u8 ~                }
: ~( b% U: o- n+ z5 q2 {            }
            CloseHandle (hPhysicalDriveIOCTL);
' N+ ^9 [7 W3 j5 r0 p        }
( a4 p+ C8 H$ i0 w$ y    }
; }9 X  j( O4 y9 f}
0 Y' v- _0 y$ b' M& H7 T8 B: L//---------------------------------------------------------------------------
& F% b$ h. C2 o. o. D& \// DoIdentify
0 b5 [0 e) W9 U% T  E8 i3 fbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
2 u7 L3 `9 J7 c( T              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
$ ?: E6 b/ y; [3 R: q              PDWORD pdwBytesReturned)
1 f0 x8 c: R; |6 p8 M{
    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
4 m2 }, u8 D' i4 H+ l    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;
, H2 t% o. t9 F: ]# w( i, l* u
0 _( x& ?3 Z9 c- K0 `9 {2 d7 j. h    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
# M8 d1 O- n$ r# L
    // The command can either be IDE identify or ATAPI identify.
2 T7 V# M' {# y1 `; p9 K+ ~    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

$ [2 d! F1 `* q- g7 b7 I/ T: d    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
& q0 t7 @' F3 v           sizeof(SENDCMDINPARAMS) - 1,
) b9 l) q+ n6 V& ^! B; w/ P1 M1 T           (LPVOID)pSCOP,
; |! H& Y9 A0 n$ Y           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
. }. {6 {8 J& g9 |( ~6 W0 s+ C           pdwBytesReturned, NULL);
}
* l: a2 c0 o0 l1 o8 c//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
! s. N& x4 ~' v1 w( O& k// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
! q9 h' n: p9 x0 }{
    WORD wOutData[256];
& s2 F  H5 t4 A# o9 o    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
4 F: w( H8 p% n0 b  `% [    {
8 @* r, o8 F' X9 ~3 h- ~        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
% D2 U$ L0 e+ s, \! C        bool bIsIDEExist;
6 Q9 \+ k0 ~( m: O: `2 h$ m4 g7 Z        bool IsDiskExist;
# k+ E! ^. a2 W& ^/ R4 O5 R
        switch(nDrive / 2)
        {
1 x! m, {' j) _; R5 _: S            case 0: dwBaseAddress = 0x01F0; break;
+ h1 v/ S" E& R+ f            case 1: dwBaseAddress = 0x0170; break;
- i& a5 ]0 b: i4 Y; y            case 2: dwBaseAddress = 0x01E8; break;
: I5 b0 ?# g- ]$ l2 F; }, w            case 3: dwBaseAddress = 0x0168; break;
' r& Y) y5 T( a* X7 R        }
2 k* }9 y! I2 T9 @2 m4 I' e; E
( Q! T7 Z1 j- s; L3 j        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

- _4 Y3 _4 {8 g        // 进入Ring0
3 W* c+ P+ x! _        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
    }
- t4 }/ w. y& Q, w
5 P, Z( M' `0 s# z+ i    // 开始读取
8 B. a) q, I% e! X    for(int nDrive = 0; nDrive < 8; nDrive++)
' u* C5 F, G, M, h; B. z    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
3 X. h5 q- Q  j. Q6 T        bool bIsIDEExist;
        bool bIsDiskExist;
        switch(nDrive / 2)
% S( m# H9 h- m# R& ]- e        {
% i1 H; T7 h6 m9 Q% p            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }

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

        // 进入Ring0
8 g/ ~' i& L( u7 E        bIsIDEExist  = false;
        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));

        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
) e% o  J/ ~# u6 ]2 g: }# S3 t                bIsIDEExist, bIsDiskExist, wOutData);

0 u  u* R8 E4 V* l) x) S8 }        if(bIsIDEExist && bIsDiskExist)
! z: P, o& T* }        {
  S/ N4 S0 S* F0 K5 G& U3 Z. w            DWORD dwDiskData[256];
            char  szSerialNumber[21];
/ D2 s' L% T* G            char  szModelNumber[41];

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

0 ~* @( A1 u& j' C% \            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
8 r2 k4 d$ n7 f! B! i1 P/ A
            // 取模型号
* s$ h# @5 e& ]4 ^            ZeroMemory(szModelNumber, sizeof(szModelNumber));
3 C' |7 y+ h+ k  k- M2 X# h            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
+ {' i% x7 N" n$ ^9 R
            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
7 Q: [5 V3 [7 s7 I" m        }
$ O' d! w- y% P) P3 t6 L    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
+ L4 I3 [, S& @9 D. i$ ~+ g$ k}
! }; O1 R3 G8 y/ N//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
" `" s4 T! R& _" N  N5 M// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
2 M0 d# _$ B! K; o2 d//---------------------------------------------------------------------------
# [) g1 z6 B% T( E* R2 v: x% m// ReadPhysicalDriveOnW9X_Ring0()
//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
. v( @/ h) \2 ?/ U8 z# p// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
6 {8 K) N. ]# Y4 I4 w        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
9 `; o- u) D+ G3 B! h{
    BYTE  btIDTR1[6];
- S( I! [1 c0 b9 R) f5 `1 C    DWORD dwOldExceptionHook;
3 a" Y, ?! ~1 w; f$ z: M    const int nHookExceptionNo = 5;

    BYTE  btIsIDEExist = 0;
8 `# N1 f  r$ ]* P2 Z0 [( K* i    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];
& W  x& M5 N: H+ @& E  W0 Q- Q9 q
    BYTE  btIsFirst = (BYTE)bIsFirst;

% C* H2 F  _0 ?7 F) X# f$ ~, O    const BYTE btBit00 = 0x01;
+ f8 \' k0 O. f# ]; Y, Y  I    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
" G5 B2 E/ a) t: D    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
7 {0 s' A. B# O6 n5 Q3 {    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;
6 |. T0 {- `4 {/ ~" ]1 l5 n: o
    __asm
    {
( v% G0 a, y2 x7 n% Y0 G5 X2 q        // 必须先执行这条语句
        JMP EnterRing0

7 s+ v( S( Q! ?+ o9 ~        // 定义过程
  [# A; N, }0 y! h- U( q+ }3 S- N        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc
) a1 x/ l" r6 `+ ?: u
8 W6 g& K  b" m: z( E5 G7 b0 X        MOV  EBX, 100000
) T$ M) R9 c) W& `3 G' r* j        MOV  DX, dwBaseAddress
" Y* B9 r9 b$ q# m) H        ADD  DX, 7

- y- K; B! w- P5 T  n$ {        LoopWhileBusy:

8 R8 \/ F5 ?9 m* U  P* l        DEC  EBX
9 Y9 p7 o' P& m+ e        CMP  EBX, 0
        JZ   Timeout
0 T( R: C$ U8 \2 R( C0 ?$ f        in   AL, DX
        TEST AL, btBusy
        JNZ  LoopWhileBusy
        JMP  DriveReady

        // 超时，直接退出
, w2 A, p, r  k) C& @        Timeout:
        JMP  LeaveRing0
( R0 j6 F  `* t. h: K) x2 k        DriveReady:
' B: q  o8 {& m( d3 q        RET
/ V6 [" t# W: R9 Z& j, h        ENDP   // End of WaitWhileBusy Procedure

$ ~+ m1 D# _; a( ]- g: L/ `        // 设置主盘和从盘标志
        SelectDevice proc

        MOV  DX, dwBaseAddress
5 z4 `8 G1 K) z& D' p) H        ADD  DX, 6
+ P  {3 H7 v3 W  ^+ r7 y        MOV  AL, btMasterSlave

, G+ |9 b& ?0 ^: P1 b; x        out  DX, AL
9 g& U- x* k$ k2 u- d7 r) F        RET
+ F1 a( P! S/ P$ c( z
        ENDP  // End of SelectDevice Procedure

6 p2 }) u8 b' c        // 向IDE设备发送存取指令
        SendCmd proc

8 D, J5 X+ Z& A; l+ a        MOV DX, dwBaseAddress
; E% d) r- u3 ^. R  V5 }8 U        ADD DX, 7
0 I4 O0 h. B2 u* p* N        MOV AL, BL // BL是主从盘标识，在过程外设置
+ u, ~- z& H9 y* e: L        out DX, AL
        RET
6 X( H5 l" F- `9 V( l! G) {* Z        ENDP  // End of SendCmd Procedure
. u9 ?: Q) W/ Z" P8 T4 t- t
2 T- J( D; b* u" O) N# U. P- p0 h$ x        // Ring0代码
        Ring0Proc:
        PUSHAD
        // 查询IDE设备是否存在
  N) q8 N& t- R" q) |0 \  ^        MOV DX, dwBaseAddress
        ADD DX, 7
        in  AL,DX

. C1 B+ y8 \; ?3 r        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
- F' o8 j, d' ~0 `' ]. ^+ x' u4 |        JZ  LeaveRing0
        CMP AL, 0x7F
        JZ  LeaveRing0
4 O5 Y. o/ U3 v) F- {9 k# M
        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1
, M, F! b( q* r4 _
        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
! K' \8 d7 {3 k: g, H0 [' _        CALL WaitWhileBusy
        CALL SelectDevice

        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
, j; S( ^" w; ]* T) g+ T7 U/ R        JZ   LeaveRing0

        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy
9 S8 }0 B8 O) S- x
. c$ {" n5 r( Y        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
6 _' ?+ |1 V( G1 _) H& E        JZ   LeaveRing0
3 W; q9 r- L( ]: Q! d& X. L, n4 [% U  k
        // 设置驱动器存在标志
" z) D' n2 B3 u6 h        MOV  btIsDiskExist, 1
( R3 x: c2 T, L, w: V
" p" Q2 c" L" H; @+ F2 |* E/ j        // 发送存取端口命令
+ _$ F5 e* ~6 J! d% }0 r        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
8 z4 I* G; d) p4 k+ [, x0 r        CALL WaitWhileBusy
  o1 K0 C# z9 B: g/ W# v: W& I        CALL SelectDevice    // 设置主从盘标识
8 }- t' z! v! d6 `        MOV  BL, btAtaCmd      // 发送读取命令
1 N' T2 O6 m, [+ b1 |! P        CALL SendCmd
& _: @) o: P! p1 u9 S0 h5 H        CALL WaitWhileBusy
- h& b' a5 G, X3 @4 }
6 n* O; o. }" [; i& c  f        // 检查是否出错
        MOV  DX, dwBaseAddress
) M3 G; @. a5 I        ADD  DX, 7

) D- @1 m2 S' K& o( m# H: B" S        in   AL, DX

* F: I; r. W2 h0 T        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
1 ]0 h9 \1 m5 T5 q- n
        // 如果出错，则进一步尝试使用ATAPI设备命令
% q( S8 j0 C8 E7 c# u$ [# x/ M+ I& _# K( ]        CALL WaitWhileBusy
        CALL SelectDevice
/ i& z2 o6 Z" ]        MOV  BL, btAtapiCmd
        CALL SendCmd
8 h& ^6 Y6 D( g8 [, i        CALL WaitWhileBusy
  T6 K8 V3 {/ L. ^4 K$ f; }
& D1 ?; T7 Y, p0 Y. z        // 检查是否还出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
        in   AL, DX
( x& e. `% {  C        TEST AL, btBit00
1 D8 a* `$ f3 J7 Z* K        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回

        // 读取数据
; j& h& h# e: Y1 s        RetrieveInfo:

9 I' }: F  o" [# N  x: W        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
1 M; @, y0 s8 o, v: M0 |5 O3 K8 y7 c7 h; z        MOV  DX, dwBaseAddress
        CLD
+ {2 n% H9 o4 N# v% P  w( N- }
        REP  INSW

0 g! z9 l$ ^. s        // 退出Ring0代码
& H7 o7 A; Q# G, g8 v        LeaveRing0:
4 j% [' D! b& a& {2 [! W
8 Y1 I  [$ d) |. O6 K2 k        POPAD
        IRETD

        // 激活Ring0代码
+ w- f, Z' V! P        EnterRing0:

; @/ F1 _- |& w3 b0 c2 S1 i8 j4 S        // 修改中断门
        SIDT FWORD PTR btIDTR1
7 r2 Q. z2 p( x' E1 S        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
, _1 Q8 }! ?# @# c! j- S0 F) Q        CLI

        // 保存原异常处理例程入口
1 x' S; Y# M; ~: d) ]- d7 L* ]5 N        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX

        // 指定新入口
( R+ i- N/ s1 K) K+ L2 Q        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
' Y/ g/ P# x9 A- M, Q        SHR EBX, 10h
& b9 m. ~" w4 K; j        MOV WORD PTR[EAX+02h], BX

4 I% Z! Y% r( A7 o! q1 x2 e; C        // 激活Ring0代码
# r& ^# Q8 N0 R2 \% i' i2 C- K$ c6 F% I0 O        INT nHookExceptionNo
* H$ R$ a: E' j9 g
        // 复原入口
; c3 w% H4 d4 \- B/ ~0 ?2 w        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
/ p/ m) P8 S5 O1 Y        MOV WORD PTR[EAX+02h], CX
        STI
8 i5 P' a$ }- e8 T7 z    }
    if(!bIsFirst)
    {
        bIsIDEExist  = (bool)btIsIDEExist;
1 }& j8 @5 i9 ~  ]: v" P* a; ]        bIsDiskExist = (bool)btIsDiskExist;
' {* d' N/ y: e- y1 Y! k8 l        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
6 t7 b1 ]& r! g3 C    }
. A) b8 q( O& N1 v}
% a' w& s8 {7 y3 v//---------------------------------------------------------------------------
* T) Y! c% a" R! f7 r9 _// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}
6 F/ `& e1 i) d; L: Q, k