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

天云上人

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

1. 
   
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   . m8 h; n: v% d
5. #include <iostream>
   2 q0 j  V5 a. e- }
6. using namespace std;
   $ Q6 }6 C) ?4 F4 H7 b
7. #include <comdef.h>
   
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    
13.     GetInfomation();
    " r0 B0 [+ }* P6 x+ q6 _  x2 a) F
14. }
    ) x9 s  C4 Z, N: z
15. 
    " y# ~9 U1 e; R
16. CpuIDDisk::~CpuIDDisk(void)
    & V6 n. D8 `! m8 Q) E0 p% h% K
17. {
    
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    " J. J) k! ]3 G! x
20. {
    ; l% s7 B6 t& v" n" j
21.     HRESULT hres;
    . I5 N- N, x8 s; c$ @! X; r9 j6 w1 b
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    / t! d1 q: L" W
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    * ^( }( v, ]* I1 ]: P
24.     if (FAILED(hres))
    5 i+ Q; V# ^  X. x8 K7 s  J" l, ?* ?
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    9 B1 B7 ^1 x9 S6 n' p: k2 k6 ?
29.     //Set general COM security levels
    / _. M& Q: w8 I$ P2 H; I
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    ! k; \# _4 H. p- A# F1 c
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    5 `! \8 y; a' A
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    ; t% E6 I* D$ E9 ]2 Y
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    - K  n* _. A% \4 A
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
      b9 J2 N; l3 y* W
40.         );
    
41.                      
    % V' C4 h( d* D; g2 Y" ?
42.     if (FAILED(hres))
      T# g- @+ W$ X. f( l! ]) X+ Z2 Q
43.     {
    0 r/ I2 h; S7 G+ _7 h# q+ w6 z4 T
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    : Q+ Q; ^/ Z* L% k
46.     }
    2 H- f- d! _5 k) t- Y; R5 I
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    # c) p* C9 s) ~3 ]  t7 p
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    
52.         CLSID_WbemLocator,            
    
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    / B( J; O6 j( E+ p: v2 Q
56. 
    
57.     if (FAILED(hres))
    3 c8 Y+ E* Q. g. B# p. k& L
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    $ a0 a/ \6 r. g8 S; O/ j
61.     }
    
62. 
    ( z9 v  T2 F$ W  ^1 x/ e
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    ) O% t# h! D9 i, w
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    : Y4 I0 b, L: S: [$ V# j+ B9 @/ a
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    : {2 V" `4 y/ h5 I0 `: u
74.          );
    9 X. e) ~$ i* X# G+ c
75.    
    
76.     if (FAILED(hres))
    ' Z/ J2 \" a, l! N+ O4 q
77.     {
    . z& _/ H) @; e( V
78.         pLoc->Release();     
    
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    
81.     }
    6 N4 u4 M! ~$ g2 ?: C
82.     // 步骤5： Set security levels on the proxy
    ( a5 U% S5 O( B. p+ b3 W6 R
83.     hres = CoSetProxyBlanket(
    
84.        pSvc,                        // Indicates the proxy to set
    
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    3 H1 `% F$ |  k1 t$ e
87.        NULL,                        // Server principal name
    ' I# [% i. {, U  j" S% N$ b
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    6 C( e  Z: j& v' x* U; s
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    $ S5 m2 S# |9 Q; s9 ^0 W
92.     );
    . R5 o' C( ?% d& ^3 B
93. 
    ; _8 l0 V4 X, z8 x
94.     if (FAILED(hres))
    
95.     {
    
96.         pSvc->Release();
    / _) Z9 q) `' c0 K! ?/ N6 u
97.         pLoc->Release();     
    
98.         CoUninitialize();
    
99.         return 1;
    
100.     }
     ; X( P% f: d! a% k- t
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     " Y- U* D+ W" T
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
     + ?& N( |# q4 A: m: k& |7 s& m8 Z
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     , G/ F2 c$ C$ f
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     
110.         &pEnumerator);
     8 N% p; b8 F& }8 ?2 i
111.    
     3 g) @) P( O0 N2 B& v
112.     if (FAILED(hres))
     $ B/ S) K- x# Y! m4 k" `# T1 }
113.     {
     ( U& t+ F( n1 W  D8 E$ V3 e
114.         pSvc->Release();
     # M: W% k$ T+ S( {7 |4 E* A
115.         pLoc->Release();
     
116.         CoUninitialize();
     
117.         return 1;
     
118.     }
     
119.     // 步骤7：Get the data from the query
     ' r9 i5 ?/ i* Z' E: S) `5 G8 f( I8 z% n
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     , m5 v+ f0 {1 Q
123.     {
     & O" A, K* Z+ l" @" @
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     0 f- x2 G6 r5 I( j* d" A
128.         {
     ) i/ ~1 K' @% z- s& z
129.             break;
     , B) ?% g, ]9 S. j& r: _
130.         }
     4 S( Z8 D+ a% z2 ^
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     : f- H7 ~/ b" T
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
       c0 Z+ u# S) i/ {4 L
135.     }
     
136. 
     
137.     //计算硬盘系列号
     ; w7 g- {; `/ @, t
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     & l9 |) s; ?5 g" m
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     
143.         &pEnumerator);
     
144. 
     
145.     if (FAILED(hres))
     $ |8 ^* R4 R4 G2 K
146.     {
     
147.         pSvc->Release();
     
148.         pLoc->Release();
     
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     - V4 r" v' E4 d* A
152.     while (pEnumerator)
     
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     
156. 
     $ |4 [4 C% t  k  e1 ]0 ]* l) m
157.         if(0 == uReturn)
     ( M0 p2 q' S# Y/ b$ E
158.         {
     * K! ~( f* T0 z+ a3 z* b# \
159.             break;
     
160.         }
     , @; w" H1 O) n# |/ ^' C
161. 
     
162.         VARIANT vtProp;
     2 v' z/ T( E" Y
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     ; q1 Y0 x+ w& n: [" l. D2 H$ P+ ]1 J
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     5 R0 W4 n, z) ^; B. h' f
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
       t" Q  p9 @* h  J# A
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     " h* B6 H$ n. W7 e, ], f
172.     CoUninitialize();
     
173. 
     + d  k7 N6 N( N& {7 ]
174.     return 0;   
     
175. }
     : D! l& h3 t' i. E% X& J5 ^

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
3 `2 S+ s3 m3 v
+ F, j3 c9 U/ O" g+ v: q( R#include <WinIOCtl.h>
#include <stdio.h>
, ?" w3 O  f) E! T2 h/ a
5 s' a# t" S1 d! O9 e8 I+ J9 R& `#pragma inline
//---------------------------------------------------------------------------
5 M% O; C8 |; G; G( I5 f' d// IDE NT/2000/XP专用变量
! u  j2 ?* i- w* K8 c# o#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
9 g; s3 d6 Y# d# T+ P#define DFP_GET_VERSION         SMART_GET_VERSION
" v2 U3 ^2 m2 r; V0 p#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

  X* t9 v) w$ W- y+ tconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

* t2 {8 M) b9 a, q; _const int MAX_IDE_DRIVES = 4;
" b3 n3 }- @1 N; T# R
// SCSI专用变量
7 J6 c* H9 L9 `% H8 m  ^% o. @0 Jconst DWORD FILE_DEVICE_SCSI             = 0x0000001B;
9 b, G/ E' t, l9 m- S# rconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
2 P. @/ D" E  Q9 }const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

6 N& n5 t7 N5 s8 Q4 `* itypedef struct _SRB_IO_CONTROL
{
2 }# L% W3 }! I% z2 z% r    ULONG HeaderLength;
6 E3 h% a. D9 Z9 U6 q2 `    UCHAR Signature[8];
- T* k$ P7 w% `( `; k    ULONG Timeout;
6 Z/ D* \! p5 T$ C( g8 \9 `    ULONG ControlCode;
    ULONG ReturnCode;
    ULONG Length;
+ a1 ~7 O1 o+ ~5 e4 l}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
; H/ F  ]  r$ S& Y
// 读取的主函数
0 L" V# D, @# }2 D: b% h. g  Bvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
# i8 @/ |6 b7 m  X4 g
, ?- d/ o5 l1 i4 \& F! t3 a+ D) D// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
8 X, k5 D$ r% }# [- Yvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
- s/ I/ W6 T6 ebool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
9 I3 y4 t$ i1 X) j        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
; s9 |6 W+ s$ D# B" Q// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
: Y: H0 T9 h: Q& O1 G4 ovoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
$ m& R4 f$ R; {: W$ o8 M        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
- q# h& b8 I7 A
/ k+ \7 e' G9 E$ |// SCSI读取函数(for NT/2000/XP)
$ r6 t& n. R) GString __fastcall ReadIDEDriveAsScsiDriveOnNT();
6 ]+ y( h4 k4 @( @4 N7 l3 U; ]' j1 I: s//---------------------------------------------------------------------------
! X' U) N2 V6 }& g( R8 ?// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
" b/ z4 e3 {2 u5 p: [& }; L4 R{
    switch(Win32Platform)
5 r# s& \/ I% b5 O7 b% N    {
9 Z1 V! b( d4 I8 J* h) T5 b        case VER_PLATFORM_WIN32_WINDOWS:
1 r5 c: i' Y/ `  R            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
+ \9 @% M+ n, P; e! }- C$ ^            break;
        default:
1 J2 E( ?$ ]( u7 x( q7 i& u, R' T/ H            break;
    }
}
- Z1 h1 i' [- k0 P/ ?7 Z. C& T$ E8 a//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
$ \+ Y  [: S2 y& Y3 Y1 g# w9 [{
    static char szResBuf[1024];
3 R! x8 o5 E+ ^: S- ~9 p3 {4 V# Z    int nIndex = 0;
    int nPosition = 0;
' B  S7 i- E0 T! h
* \& o; n+ j6 B# T    // Each integer has two characters stored in it backwards
+ I9 P! y: g$ l& ^' I/ b    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;

        // Get low BYTE for 2nd character
- R* P( A* v9 M        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
' J5 \2 J' u# R' W        nPosition++;
    }
2 U/ P$ c& Q$ q1 L$ Q( B$ I2 R0 v# c2 W
  Y! E9 g. u9 Y) K& g    // End the string
    szResBuf[nPosition] = '\0';

& Y7 q1 C# ]. P3 J2 n    // Cut off the trailing blanks
    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
# U+ ]8 g0 i, S% J6 x        szResBuf[nIndex] = '\0';
6 ?4 N) T! s9 D5 [2 O. Y
. ]! E! n. a# S- S    return szResBuf;
}
//---------------------------------------------------------------------------
) U, B, s  X4 T+ U6 P7 N4 C// Winndows NT4/2000/XP 代码
; A; G# H; S' E* ^& W2 e//---------------------------------------------------------------------------
: ]/ V4 y& w* ]0 v1 }1 N" A: C# h// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
8 u  S. ~9 k2 x0 }- h# S{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
2 @8 n! B9 X' N5 H' q: H9 ?* l/ t        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];

& A% ?( ?; ]* c8 \        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
8 r. h# e# ^6 s) `                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);

        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
  T  J+ ~( o! s            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;

            // Get the version, etc of PhysicalDrive IOCTL
; g8 K! A5 b2 k            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

/ g$ K: D6 ~! m7 }) V            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
: f) O3 `0 j8 M* g% @                    &dwBytesReturned, NULL))
            {
. Z! ]$ `7 A) [4 J                continue;
            }
  }. X+ p% ]. a+ c: t. h  W
- {( P- T3 A1 n3 E/ B6 [' o" v4 X. c+ V            if(gvopVersionParams.bIDEDeviceMap > 0)
0 ~# ?+ |: r: B5 [9 b            {
                // IDE or ATAPI IDENTIFY cmd
* d. C( N, M% F6 w) P                BYTE btIDCmd = 0;
% T2 a* }. C4 [                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
4 k+ F7 [* l6 N. k( E, _/ s9 ^                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
, T' ^. Q1 ?$ S                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
' A( Q' t2 e0 T0 T( M$ Z                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
# ^+ b: }' J" g. Y; N6 `. c                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

# G! c2 k# p4 L. y- ?6 `                if(DoIdentify(hPhysicalDriveIOCTL,
2 K: H6 s1 M0 [                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
                    DWORD dwDiskData[256];
. c2 H  V" y5 H& R5 O                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                    char szSerialNumber[21];
0 k! P) J  x4 g                    char szModelNumber[41];
+ ~) u5 C6 l. ]6 Q. d3 n! v. `
                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
: P  {7 A0 r' ~) F- ~+ ]                    // 取系列号
( O3 x# H, }7 C# Z; R9 X/ W                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
" E0 _* S6 G  m3 C( V0 A/ R6 \                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
6 }) o9 b2 |/ T  E( I: p, o
                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
1 i# y# ]! S, ]1 x  k1 w# Z                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
1 `5 J4 B' m' s4 B
                    pSerList->Add(szSerialNumber);
. v+ [+ H  F! ?8 N5 X$ C+ |                    pModeList->Add(szModelNumber);
4 U! R+ @; Z$ }5 @                }
; n; i9 H* E9 U1 `9 b! Y            }
            CloseHandle (hPhysicalDriveIOCTL);
        }
    }
}
8 n8 x: L# C# \//---------------------------------------------------------------------------
2 R/ B  E8 s& L; _// DoIdentify
& O1 s# s3 I4 F) x( dbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
* u# q+ D6 ^0 k. Q' s! \5 C8 q{
    // Set up data structures for IDENTIFY command.
) S2 Q4 X0 B. D( c& y9 B% u    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
$ D4 Z# r" e3 T- ?3 |& c6 H) A" y    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
5 [: Q! D8 M; b( |% |    pSCIP->irDriveRegs.bCylHighReg = 0;

! B1 n' {4 {: ^, Q6 P5 W    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
" J, N' i  D" s$ g) E: ]    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
+ u# Z5 V$ P9 |+ u
    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
% S( }1 D8 W+ T( ?0 ?    pSCIP->bDriveNumber = btDriveNum;
6 p+ e7 V$ x- N- L, Y    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
; D. R0 g/ K* d1 H6 H' r
    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
5 y' X9 H' o; S           (LPVOID)pSCIP,
" O, P2 w6 ~& g) O* f           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
! }3 n7 _& k( |9 Y0 `, `& g0 B           pdwBytesReturned, NULL);
' M& x: l$ S' L% w) ?}
9 q3 n, ^! n6 z0 G/ D9 j//---------------------------------------------------------------------------
2 c3 I8 d  r) @// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
" {: ?" _  S( H6 C- d7 W8 x! Zvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
$ P# ?( ^/ P# W7 D, i{
: F! b! U4 Q8 Q% j: l+ Z- X+ C% B8 h    WORD wOutData[256];
( f; Z( S- x1 M6 [* X  R    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
; T* B, I3 M7 u7 p0 n
    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
+ O) Y5 ~( x& R( t. n& a    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
4 @, V/ ^; X1 ~1 Z' K" ]        bool bIsIDEExist;
' P% b- Y. d4 d7 B/ d" g# x        bool IsDiskExist;

        switch(nDrive / 2)
6 i% Y, o4 i: T+ n        {
  _- Y/ M- C5 f! z  \* H* H! O, `  ?7 m            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
8 w/ \( u: z' l& i            case 2: dwBaseAddress = 0x01E8; break;
; e; H/ A/ I+ ^; Y" v8 ^            case 3: dwBaseAddress = 0x0168; break;
        }
7 S4 ?- r5 K9 d$ }
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
6 ]9 B: p2 L% q7 n
        // 进入Ring0
4 }! A# L9 @3 Q% Q        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
, `( ~! e, a+ R6 h  d    }
2 Q9 k; d  b# V. ?
* M. O9 t& D( k7 G/ u7 A' K5 m    // 开始读取
) g; P% {; Z- X% {0 E$ U  v* Q    for(int nDrive = 0; nDrive < 8; nDrive++)
/ y$ I$ U) E; p. i0 ], S    {
0 J0 W9 _$ X3 v3 O        WORD dwBaseAddress;
' w- R% R" B" t5 w, w; k        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
% c* r  N4 r& ?! K. B# \' |        bool bIsDiskExist;
        switch(nDrive / 2)
' Z5 [" z& O% g5 K6 k7 b        {
7 W1 Q* L' `" Z( I8 h            case 0: dwBaseAddress = 0x01F0; break;
8 t' W1 @0 z% l, n1 H' Q            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
1 E3 f8 \! y6 K0 Z, ?" u! s            case 3: dwBaseAddress = 0x0168; break;
        }

: I& j; \8 H2 N8 ^' f: d        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
  J! |  [8 g0 t% s4 S6 u1 @
! }; L2 v8 |; w        // 进入Ring0
% L- {. f& q( u1 G        bIsIDEExist  = false;
        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));

        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

/ K+ O3 d! l0 @! u) _: H5 X* j! K        if(bIsIDEExist && bIsDiskExist)
        {
3 Y5 a* [" @1 F1 ~5 ?            DWORD dwDiskData[256];
1 F: X/ W# q0 p5 I' t3 S            char  szSerialNumber[21];
+ F( M# l' {; s8 t( g/ ^            char  szModelNumber[41];
5 `2 @1 q$ a3 G: s$ @' A4 [+ G" Q! g
            for(int k=0; k < 256; k++)
8 @3 p: c& ^. b" a: m                dwDiskData[k] = wOutData[k];
" o! c8 g% e2 J5 r% l6 m
0 e5 v4 P# W8 U, M! q2 r8 j) F            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
( j3 X4 u) i. R            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

            // 取模型号
$ C+ b  d+ p8 f            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

3 r4 _2 q: B, O3 e5 |9 u            pSerList->Add(szSerialNumber);
# L6 G: I; H  f6 M            pModeList->Add(szModelNumber);
* w8 V4 v5 Z; k0 n6 ]* a. w        }
. {0 i% ~% G( C1 G    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
6 ]( G) D! m4 b/ ^. w}
) |- w! z+ ?- A$ {' M( z//---------------------------------------------------------------------------
) e6 c% @' p. y3 I' y/ B1 m5 p// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
3 C! U6 N6 ]% _! f// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
/ m3 o3 A, f& k//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
- N8 S  e) y0 J  v- s  F& ]$ T) M6 s( e//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
: }8 ^2 P. I  T+ P        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
1 Y  t7 ], Y" `7 ~* `{
    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
& a$ C+ v' d0 v& N4 k7 b    const int nHookExceptionNo = 5;
& t, P% P1 {) j
6 \+ y. D. U+ L2 d/ c9 @/ O    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
' E( E% s: b0 Q; M; _, W    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;
0 d" G% B: A& z
    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
' V$ m& j, a5 S9 p: `    const BYTE btBusy = btBit07;
, K; S* }, ?# ]" D0 Q8 }0 m# B    const BYTE btAtaCmd   = 0xEC;
! S& G$ J5 t1 M  Q    const BYTE btAtapiCmd = 0xA1;
: s. n% J0 F2 p' P" ^
4 f: i! g/ s; p( Q% I' E4 \    __asm
  U. W: o; T5 F" o2 [% M) E    {
        // 必须先执行这条语句
  n, Q7 }! a. R+ d2 m        JMP EnterRing0
& P7 u+ V: P' i6 X/ y& X
        // 定义过程
" n( O1 D7 K3 y/ B2 @        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc
" Y8 I2 Y" Z/ k
        MOV  EBX, 100000
! u- k$ c+ p6 H+ j' H) s        MOV  DX, dwBaseAddress
        ADD  DX, 7
9 g& w4 M+ \2 c7 X
        LoopWhileBusy:

( f4 d6 p. ]" {6 a0 g5 Y        DEC  EBX
        CMP  EBX, 0
        JZ   Timeout
: _, W1 w/ l) q1 @! X1 M5 l1 ]        in   AL, DX
7 B2 ?: z% O) b7 a' [        TEST AL, btBusy
" E( L) v+ E8 \: ]        JNZ  LoopWhileBusy
        JMP  DriveReady

- V+ r; B. l" o# G$ x2 y        // 超时，直接退出
        Timeout:
        JMP  LeaveRing0
& f6 W1 A+ D. |7 r& |        DriveReady:
        RET
0 v2 W) E$ v5 ~6 b) z2 N% G        ENDP   // End of WaitWhileBusy Procedure

! J1 F% j1 e8 E# n% i& _  a) B6 m        // 设置主盘和从盘标志
        SelectDevice proc
* y" D! o% }8 r! [1 m
        MOV  DX, dwBaseAddress
        ADD  DX, 6
        MOV  AL, btMasterSlave

        out  DX, AL
! R. d" i8 o! }5 I) X        RET

* @+ U5 ^, O6 V% E+ d; u$ |        ENDP  // End of SelectDevice Procedure
9 [7 T4 v# M- s: S
9 o( H$ Y$ w# h& B1 Y* C2 t        // 向IDE设备发送存取指令
7 X+ W& G7 B% C* `        SendCmd proc
# o" I6 i9 f1 j. W$ D/ j
$ E: g$ R4 z$ y; J% w5 B, Y        MOV DX, dwBaseAddress
        ADD DX, 7
! E- M& o; F1 a) H9 c: R% K* F        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
        RET
& h& ^: k% \  Z; y% V+ P        ENDP  // End of SendCmd Procedure
# o: ?7 @* E7 m- W& i( z
        // Ring0代码
        Ring0Proc:
+ Y8 T7 J: i1 [% L, S, p        PUSHAD
/ T/ C# F/ V% K        // 查询IDE设备是否存在
$ ^, D: G7 a) A5 r        MOV DX, dwBaseAddress
7 a1 \7 H( [9 N% w# g* o  o+ a        ADD DX, 7
        in  AL,DX
% S6 }4 m9 ^! V  [0 O- p
        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
9 I# p0 J( _6 \* z# Y        CMP AL,0xFF
2 g' i% U4 A5 F( ~        JZ  LeaveRing0
        CMP AL, 0x7F
/ T2 V2 D, V# ~( ]- V$ I$ b        JZ  LeaveRing0

: w  r) E0 ^/ O& r* F  I        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1

        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
1 x, v; K, q& N9 m        CALL SelectDevice

        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
5 k8 t0 R5 W: x' B        CMP  btIsFirst, 1
        JZ   LeaveRing0

* q  h: P4 K/ l        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
' y+ W. ^6 l3 }2 O        CALL WaitWhileBusy

8 f' f0 D  Q' N" l7 X  Y+ R        // AL的值等于cBit06时，不存在驱动器，直接返回
. o& t: _& K( V9 C        TEST AL, btBit06
) y1 \5 ~  T6 n2 K, @9 ?        JZ   LeaveRing0

$ U8 I& F6 _4 M+ L+ [; w        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1

        // 发送存取端口命令
+ L$ p: z% N0 R' K% Q4 ~0 {( E6 u        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
$ h& N7 P0 q: E        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
+ r( [/ @/ X2 U        CALL WaitWhileBusy
" e, |8 d; E) q  G! G3 e, N
* u2 u6 n& O7 Q2 E3 f        // 检查是否出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
9 @5 K/ a: ^) o$ n& o  w
" i0 ^4 n/ A5 }% z* H" ~        in   AL, DX
% h$ K; Y" F( P  v1 _+ \
0 @4 U* T& p: x4 n/ C* S        TEST AL, btBit00
) ?) L! W, @( L% D        JZ   RetrieveInfo   // 没有错误时则读数据
. {/ f  m1 D9 y$ [9 @( I1 P
        // 如果出错，则进一步尝试使用ATAPI设备命令
  x  ~) D7 N# ]        CALL WaitWhileBusy
" {4 g. A+ J4 |' E5 ^7 N/ Z        CALL SelectDevice
$ ]% B. O# f6 p$ y        MOV  BL, btAtapiCmd
' @9 Y/ B4 x' v; u7 Y* [- S. R        CALL SendCmd
. Q" b4 ]% |; L$ t& \8 |5 D$ n7 T        CALL WaitWhileBusy
1 r5 N5 n6 k; n4 w9 E) |
        // 检查是否还出错
        MOV  DX, dwBaseAddress
3 f6 y8 W- n, L' w! c9 A        ADD  DX, 7
        in   AL, DX
        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回

        // 读取数据
; a! x0 a) B: k1 |, E        RetrieveInfo:
- W5 I5 B  i! m% v+ Q( l) b
! H/ t3 I- w- ]$ ~        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
5 ^: x+ B2 j5 Y, I        MOV  DX, dwBaseAddress
        CLD

        REP  INSW

        // 退出Ring0代码
        LeaveRing0:

        POPAD
        IRETD

1 C! o# @& S3 \, ]" G6 Z        // 激活Ring0代码
        EnterRing0:
' B5 b0 {5 ]3 w8 U& Y
$ f6 q3 \9 R0 @: R        // 修改中断门
: ~/ I1 @* Y& J; k1 {$ h6 L        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
9 |  C- L( u2 ]$ w  M' q" i        ADD EAX, nHookExceptionNo * 08h + 04h
2 v( Y8 a8 r: t        CLI
7 M* t! W8 ^& M8 K  y+ M
; ^. U, J" N( _/ n* R; G6 {        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX
4 ~  a* O7 F7 P- }4 p% y% {
& ^' }% E  t5 |        // 指定新入口
        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX
4 a" \+ Y* B# T3 Y& P9 y
        // 激活Ring0代码
        INT nHookExceptionNo

5 G% E7 k. W2 \5 R' F2 {3 `0 _        // 复原入口
        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
0 M. M. ~# T( N; M1 R' T/ V        SHR ECX,10h
8 [4 R9 [$ i9 c- A" U        MOV WORD PTR[EAX+02h], CX
0 D% Z$ P5 t) `, y        STI
, K# j! C3 @6 D1 Q    }
    if(!bIsFirst)
! }+ ^1 @- O/ |  x, i    {
) `7 m6 O! P! V& i/ d) a; v        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
$ x7 e4 T( T) i! @: G% h& l4 s        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
- g5 V- ?& [- ]0 R}
: ~2 S  O1 ]4 f3 h4 Y6 J/ W//---------------------------------------------------------------------------
2 i5 m+ Y9 a' T& q; F. B// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
1 E/ [* ]  C. A{
+ s( U* z5 P8 q7 Y    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}