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

天云上人

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

1. 
   & @- V" o2 o: [0 V
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
     G" l/ q, Z) E; Z6 e
5. #include <iostream>
   
6. using namespace std;
   
7. #include <comdef.h>
   3 e+ w! Q% n& @% U3 i$ O
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    
13.     GetInfomation();
    
14. }
    
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    6 J. S- _- F6 N8 M! \
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    # D1 ]! E  t9 p* d- R: L% A5 @) C
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    3 z$ w6 J9 T3 C) e& H) w# |
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    " F, K$ D- ^8 x9 P
24.     if (FAILED(hres))
    ' _+ B) f  M5 |  c! F1 V8 k4 U9 Q
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    . T# N$ o( m& ~: D
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    : r: @) h+ @3 L# E
30.     hres =  CoInitializeSecurity(
    2 r: y8 R$ Q' |- v9 v, Z! ]( c
31.         NULL,
    5 L  A, p+ p6 _! T, G
32.         -1,                          // COM authentication
    2 \6 F+ c: R' U. r
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    ' X" v3 ^2 u# \$ w% R, J
37.         NULL,                        // Authentication info
    0 N8 K5 @+ w" ]$ ], v
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    % t2 S* h" P$ u# N, D
40.         );
    
41.                      
    
42.     if (FAILED(hres))
    
43.     {
    % [& K) }5 c0 _/ z2 a6 o5 H
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    0 D9 C6 b- l& H
46.     }
    
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    & X9 U0 ^, o& k
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    
52.         CLSID_WbemLocator,            
    
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    ; k9 c. _" d1 d3 y
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    % a5 K# d6 r9 {5 z# P
57.     if (FAILED(hres))
    ' A$ w9 t6 e. K+ x" d
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    
62. 
    3 P1 i' Z* N% y2 q
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    2 r+ X& B, Y/ i7 g, p* s; k
64.     IWbemServices *pSvc = NULL;
    ; ?* {6 B9 F* G7 C+ u% o2 W
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
    : x) ?: ]1 h8 y/ O# b5 X$ r' p5 J
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    ; A# p9 b& A# Z2 @. a7 u8 p8 `
71.          0,                       // Authority (e.g. Kerberos)
    " u- L0 I. r# Y. f2 I% v" ?. \
72.          0,                       // Context object
    $ O2 ^$ ^$ m4 d$ }4 H* y
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    
75.    
    
76.     if (FAILED(hres))
    5 G, o$ L( r  `8 X, i; M& @/ `
77.     {
    : T9 ~3 R1 w/ \* n' Y+ u7 F+ N
78.         pLoc->Release();     
    5 u* S& ?/ i2 o/ _, M' q' w2 N
79.         CoUninitialize();
    4 r: S) h6 t6 x; @# q7 |
80.         return 1;                // Program has failed.
    
81.     }
    $ I. l5 k, Y& ]) v. |9 u
82.     // 步骤5： Set security levels on the proxy
    , M$ A: `) [& N( t! l5 o
83.     hres = CoSetProxyBlanket(
    
84.        pSvc,                        // Indicates the proxy to set
    
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    ! y/ T! F+ S( |7 M
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    
87.        NULL,                        // Server principal name
    5 i- B. b( G! {9 d
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    
90.        NULL,                        // client identity
    1 L+ D* x8 n; v' C+ L2 L0 o: S
91.        EOAC_NONE                    // proxy capabilities
      t) P; B/ S# e- r! u3 _3 d* ]
92.     );
    
93. 
    
94.     if (FAILED(hres))
    " _! b8 P# X, E4 G2 k3 ?$ k; U# u1 y
95.     {
    
96.         pSvc->Release();
    4 V/ A7 U8 s% H; ^- D# R; ?$ h
97.         pLoc->Release();     
    
98.         CoUninitialize();
    
99.         return 1;
    8 |9 L# t+ R" g
100.     }
     " E* [# q  n3 \
101. 
     2 Q+ p3 i) }! ]2 p: y$ e  Z+ O# o% O
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     # ?" J4 L6 J5 D. U
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     & F' B- ~0 y. ~- C7 y
106.         bstr_t("WQL"),
     / G1 N  Y, G8 v2 j1 f1 u# f" }4 g' n
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     # ^) [% x/ U. Y/ }" l2 G% k5 j% n
109.         NULL,
     + V/ ?" A1 g* P0 U/ \2 f( B
110.         &pEnumerator);
     2 D' p, K, n/ s- ]
111.    
     
112.     if (FAILED(hres))
     
113.     {
     . }. z) M9 e' u6 q. Q
114.         pSvc->Release();
     
115.         pLoc->Release();
     
116.         CoUninitialize();
     
117.         return 1;
     
118.     }
     " D! o6 x' b* q& n
119.     // 步骤7：Get the data from the query
     # U+ {+ d4 Z: ^
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     $ O8 ^& s1 r, G- J/ p- s3 f
122.     while (pEnumerator)
     , }3 P9 @; J4 i4 P5 N# }
123.     {
     ! N- Z! u5 g" W! I" R& z" s
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     # G  |+ G3 J& r  s9 z& \( k7 S
126. 
     - b9 G& O/ x' y! X# _: Q, b0 E4 O: b
127.         if(0 == uReturn)
     
128.         {
     
129.             break;
     : T' ]/ l9 j' V1 B
130.         }
     
131.         VARIANT vtProp;
     2 i) l& E+ d" D) x. Q8 ~
132.         VariantInit(&vtProp);
     % X2 z6 V: i2 Z7 ]
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     & Y$ G3 w& ]$ I$ E
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     ! B$ X1 F4 j2 l/ Q" _" u0 c
135.     }
     6 F; L! @1 e& M0 B# U
136. 
     ! g6 }7 Q" t" u" h5 N
137.     //计算硬盘系列号
     6 k" ?- W, f1 u2 ?" p0 r" `0 f& C
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     " D8 H% \3 ^" l. [0 \' q
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
       j( T5 I1 b) v  W/ r# D) ?
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     5 ?- ?: Z. W8 G& e
143.         &pEnumerator);
     * t( ^  U" |* ^7 O/ L0 {6 ~
144. 
     : }) U! j# F8 p+ {
145.     if (FAILED(hres))
     $ E8 B% h% |$ T
146.     {
     
147.         pSvc->Release();
     
148.         pLoc->Release();
       d: ~- E2 j& z% P+ z2 v  d
149.         CoUninitialize();
     9 A: P- q7 u3 z4 v* {. t
150.         return 1;
     + w/ P& P. Y" ^$ \; R
151.     }
     
152.     while (pEnumerator)
     
153.     {
     0 C2 e1 r8 _/ V9 S- _
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     5 J" F) @- M8 l4 f! C' r
155.             &pclsObj, &uReturn);
     , X" N+ A. F2 @! Y
156. 
     
157.         if(0 == uReturn)
     $ l  [0 g) ]) Q" f3 S& q) z( H
158.         {
     ( S- J( u2 {5 w# H3 F- N% R6 ^
159.             break;
     0 n, e6 Q- P5 O- f0 o6 x
160.         }
     
161. 
     " {! U& v2 A5 m3 w. O  W6 D3 h8 |% i
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     $ u) d) q# w0 ^& ~; F% W! @; b
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     0 x/ f$ x: m7 L' p& R$ u0 h) H
170.     pEnumerator->Release();
     7 M( R( }' f9 K* b
171.     pclsObj->Release();
     ; b  B1 s* P3 z# k& o
172.     CoUninitialize();
     
173. 
     1 n) u- i* I+ q4 G; `
174.     return 0;   
     
175. }
     

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
2 t9 X$ f- }# M, i7 A9 U7 E
: V! W2 B, t. m/ [5 E#include <WinIOCtl.h>
#include <stdio.h>

& K+ P: c" y& y1 E2 B#pragma inline
//---------------------------------------------------------------------------
% U" v. k6 J( I2 r// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
. B$ y. j' F# f3 r$ f#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
% q1 c1 G) V. p2 z#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

: q" {# s8 {1 |$ cconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

( M) y( B2 g5 ?" G/ L: x1 ~const int MAX_IDE_DRIVES = 4;

// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
1 u) C) f7 u6 Y) A9 oconst DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
: x0 P9 {3 ?2 s1 n' @+ ^; P& k6 Z7 P
" `' E* [2 W& Y- q2 i1 stypedef struct _SRB_IO_CONTROL
7 X+ T& \8 C: k{
    ULONG HeaderLength;
2 D& F" w2 y, A1 a    UCHAR Signature[8];
5 V& ?7 v( ~# L. ]; F    ULONG Timeout;
% J5 n7 y8 L: r! |8 B* G& N, {    ULONG ControlCode;
    ULONG ReturnCode;
    ULONG Length;
+ G6 g% |' b0 Z! @}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
% D; y/ r+ ~, }
// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
4 F2 t6 `% o  E
. r7 ]. i" b5 h9 e2 u( J8 C// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
. N' i8 u  H3 K' I// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
8 b) B. Y4 x( `1 s+ u0 Gbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
0 E' k" X. |$ |1 ]        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
" C+ O  S8 d3 W9 `6 e# W# V) pvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

" T# s; K+ j. S1 e! ^// SCSI读取函数(for NT/2000/XP)
+ @, W) B& V. U5 c3 g, I: bString __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
$ l# ]6 ]7 W" m5 o. lvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
) ~# u% s% a2 }$ ~2 l5 X% I{
9 s; S3 y0 k4 o- b- [9 s/ ?    switch(Win32Platform)
    {
        case VER_PLATFORM_WIN32_WINDOWS:
            ReadPhysicalDriveOnW9X(pSerList, pModeList);
2 z) V- N- A! t6 a            break;
6 L6 O; g6 r4 \5 [% D6 a        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
# ?6 l/ i+ O  m9 `' Q9 `        default:
            break;
6 B" z3 h) A* ~    }
' ]2 f2 X  w# k  M* @/ {( |& ~}
, D% C; ^+ u/ G  k8 N//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
& U" F/ g% T, e' s% u- b{
    static char szResBuf[1024];
    int nIndex = 0;
( S* Q, S: W8 n1 @; p" T) ^: Q    int nPosition = 0;

- P( z5 x' r# _    // Each integer has two characters stored in it backwards
/ w  L. ^) X4 u7 C: U# E7 `6 E( ?% d# W    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
3 D, E  G! n3 u! m5 V8 [9 I        // Get high BYTE for 1st character
4 z* v3 k) o3 C! ^. I        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;

        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
    }

    // End the string
: Q8 D2 d6 \# k) F( H2 D    szResBuf[nPosition] = '\0';
" b. @: ~$ L/ d% d4 A8 W0 J4 h
; r$ ]2 Y% \6 X! {' }    // Cut off the trailing blanks
. \- t, }  c2 B' N: C! \- w. v    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
; ]; K/ A+ e! r0 s        szResBuf[nIndex] = '\0';

    return szResBuf;
}
% t# u$ y7 H4 F$ S//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
& P( c$ b( O  w; x// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
! i6 a5 P, v, A, R7 h* s& m2 s{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
$ G& R) L$ ]  |, w6 c% `2 B
! S7 _' o& ~$ F/ d/ e  N    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
  E' A: e2 K+ y% g& _, I        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];

4 }+ E) U! o) W) W6 s        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
3 q, S+ n, I$ `( z1 d                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);

        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;
8 l' c( ~5 Q( G1 s% s8 _2 p2 d
            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
5 ]+ t4 S& w  Q/ v
            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
: V$ z/ x/ n1 ?7 m6 @8 t& v4 l' D            {
                continue;
4 ?% O( @& {2 t2 I& a+ {( w            }
- D1 d; W' A4 E. \7 f+ x/ L, ?
            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
                // IDE or ATAPI IDENTIFY cmd
                BYTE btIDCmd = 0;
# R7 O2 ^# o  n                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
7 [3 K; J+ q8 V                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
' o% @% c$ l* I2 T; F                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
1 k- t. u7 J' v. i                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
; Z7 |. N& A& K                {
. F$ v2 n' ^2 p& g                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
& ^7 z' R- z, m( K1 Q5 C                    char szSerialNumber[21];
                    char szModelNumber[41];

, H% r9 Z' \8 P                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
% F) d, i6 ^& H; w5 ~% ?  K1 y                    for(int i=0; i < 256; i++)
# J/ g9 F, J7 r; p( ]( `6 }# ?                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
$ D$ W% N( p% Y- k  C( B( s& U5 r                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
: D2 p2 N% V0 Y: Z+ r                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

% Z& |  R: S6 C: U                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
/ t% _6 j* `& s/ A% a( y! N3 [
                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
6 F1 t- u) z8 F8 w! r% P! |                }
$ R* `8 }9 V' N2 }2 f! }            }
5 t8 I" v$ ]3 h2 U            CloseHandle (hPhysicalDriveIOCTL);
# z7 ]6 [' L* Y2 q8 k) e- C9 U        }
    }
& N! m& B. J  {$ H, h}
8 i) Z- c3 ?) @) R* q: W7 t" I//---------------------------------------------------------------------------
// DoIdentify
. n, a; A/ f; p% Cbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
. a8 |: ^  |! D5 f6 C" P, ~              PDWORD pdwBytesReturned)
{
2 r6 H& F" ]3 g* p8 \: I" r% M    // Set up data structures for IDENTIFY command.
3 j* X# L* \3 F: i/ r- U    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
1 x) _! U3 I; V4 T5 H    pSCIP->irDriveRegs.bSectorNumberReg = 1;
( t8 q/ m' M. N+ Y- h, W    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;
! N- S6 T8 A- c9 G
    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

0 t/ p+ @, W8 e* m8 `    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
: Y7 v# n! a4 Y           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
: Q* O5 S7 j6 [}
2 T1 [; Y. L* `8 K//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
( J6 `2 p5 \) y( F1 ]) O2 dvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
2 p$ i5 g' N, c6 c% B, z{
, K- r; ]4 q; `. r2 l4 R    WORD wOutData[256];
4 N' @4 \! Y3 A    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

! g9 q: l5 ~. y- _    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
9 J0 u. t) W% b    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
. f! g% A" b7 s% X1 P. t! H    for(int nDrive = 0; nDrive < 8; nDrive++)
; L. x. D& H5 N5 F    {
        WORD dwBaseAddress;
% l7 z2 E* p/ l; ?( b        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
        bool IsDiskExist;

        switch(nDrive / 2)
        {
; T9 d" U# J1 T/ t$ k            case 0: dwBaseAddress = 0x01F0; break;
4 d3 H$ j0 r- `# Y            case 1: dwBaseAddress = 0x0170; break;
3 b% Q9 q! ?# I8 v: y            case 2: dwBaseAddress = 0x01E8; break;
$ M4 B' ?% w! G8 [( M            case 3: dwBaseAddress = 0x0168; break;
# n8 {! X, L6 c8 u* s        }
! @$ f4 H* z  s# f, s# t7 Y% g) s# e8 K
' d3 c" ]( _/ R3 g: c        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
! S" Q! n: |: e, V! G5 x- n8 `7 V
0 l" Q2 ]. m* @' k% W8 d+ o! ~        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
8 y( k$ \8 y4 A- l8 c$ n  Z                bIsIDEExist, IsDiskExist, wOutData);
    }

    // 开始读取
9 {& v1 W3 Z2 w- [3 ?    for(int nDrive = 0; nDrive < 8; nDrive++)
( _3 y* U! k& r1 b    {
) ~- e( l, `) U/ K        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
5 x; X6 M' Q! K4 ?% ~' K: }        bool bIsIDEExist;
        bool bIsDiskExist;
        switch(nDrive / 2)
        {
, T  V. g' X. Z( j            case 0: dwBaseAddress = 0x01F0; break;
# Q+ J6 S) j9 U; C6 F            case 1: dwBaseAddress = 0x0170; break;
6 V( h  L" Q" f6 _+ a            case 2: dwBaseAddress = 0x01E8; break;
! n( s1 A6 U, k4 {( z# U            case 3: dwBaseAddress = 0x0168; break;
        }

        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
+ s7 x& C; b! t4 ~# n& B( I- _" z8 a
" e- S9 k$ E% i. S! P+ i        // 进入Ring0
        bIsIDEExist  = false;
        bIsDiskExist = false;
4 K- u2 o, A' u1 s        ZeroMemory(wOutData, sizeof(wOutData));

( j4 G+ S5 U8 {; l7 p, n        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

        if(bIsIDEExist && bIsDiskExist)
        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
            char  szModelNumber[41];

- w  g) K! P) v3 {; I6 p3 O            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];

% Y) u+ _2 k* }            // 取系列号
+ q. [$ ^0 m. Q            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
' N2 Q* ~0 c: |1 v  d; Z* o# B
2 T9 b; w- f9 v) H            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

# V1 e4 I/ c5 n7 v' H            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
. R; r8 D/ q1 n! I0 Y# Y        }
6 x' q7 x1 B7 [    }
0 p8 P/ F: h, u% G    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
- t6 i$ g' v8 U7 H7 Y9 {// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
9 R/ @, M- F7 X  X9 m  B// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
! ^) ~% L: s) n* _& T% v# h//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
9 [9 k3 E5 d( y! o        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
    BYTE  btIDTR1[6];
5 J6 J2 E7 A/ {( |) ^& q    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;

: o) k9 w( B/ f( ^& Z6 W    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;

6 K  x9 M* j# Q  K& D    const BYTE btBit00 = 0x01;
" u) [# ^" U9 Y7 Y    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
5 ^2 M2 ^& q; N, M3 ~& r    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
1 p) L0 l% s0 z$ k    const BYTE btBusy = btBit07;
& F2 c  k  [8 h    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;

. }. {3 c7 C% S$ C0 M    __asm
7 i2 ]% e, {9 l3 Q. w6 h! e+ t- Q& y. [    {
! K! q' j. y" R( q* y        // 必须先执行这条语句
3 E* j( y3 l& o* v+ Y        JMP EnterRing0
2 l' l. }) K* C; W  G
6 }1 l0 b6 ^- V; X- @) G        // 定义过程
        // 等待IDE设备直到其不为忙为止
# ?4 q" }# E4 `  n4 D2 k0 q! k' V        WaitWhileBusy proc

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

        LoopWhileBusy:

        DEC  EBX
7 Q8 T/ D3 A6 r        CMP  EBX, 0
        JZ   Timeout
        in   AL, DX
3 I- P' F4 V' q7 n+ u& v        TEST AL, btBusy
9 O% Q0 G6 K2 R1 b        JNZ  LoopWhileBusy
        JMP  DriveReady
& z' e8 [# Y( ~/ z* y
1 r+ ~3 W; }* Z        // 超时，直接退出
8 V- b; S3 c0 m" r' K. h/ q        Timeout:
        JMP  LeaveRing0
        DriveReady:
        RET
: f/ g  S& X4 q3 ]# \" J        ENDP   // End of WaitWhileBusy Procedure
( `- y! ?: m) H( V! e  ^6 T) \/ s
        // 设置主盘和从盘标志
6 m1 I' d$ r% @0 z; D        SelectDevice proc

        MOV  DX, dwBaseAddress
; y4 U4 ]6 S! m; T. ]1 t0 N        ADD  DX, 6
+ s6 P- V- x* n4 I" t1 G$ o! d. d        MOV  AL, btMasterSlave
; e; z% `+ C: z$ }0 K
        out  DX, AL
6 [- h& m: w, [2 u) _3 ]$ ?& @" O        RET
! m% J4 A* d: E
" k9 W7 b* Y* j! _# j4 b, M        ENDP  // End of SelectDevice Procedure
  K- E0 \. a) Z! f! i5 T
, Z% ?% S: q' q        // 向IDE设备发送存取指令
3 l' \. s: s: N9 l8 |        SendCmd proc

        MOV DX, dwBaseAddress
2 x! E% C6 v0 Y3 t' K8 w8 E7 q9 f        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
        RET
! f* |4 r( u4 t- B/ K        ENDP  // End of SendCmd Procedure
4 [' }. @9 O/ k. q! \
        // Ring0代码
        Ring0Proc:
        PUSHAD
        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
        ADD DX, 7
" N" u. O) j' @- b% I3 U: q7 [  q! K. B2 l        in  AL,DX
( b# L" p4 Q8 z' E9 N
        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
# R" J" r3 @4 X3 e$ T2 r8 [$ j. w        CMP AL,0xFF
        JZ  LeaveRing0
7 c5 ]) u! W: S$ ]+ B1 i9 f0 q0 u        CMP AL, 0x7F
        JZ  LeaveRing0
; w  L, {- ]% `6 E, _! g. ~
        // 设置IDE设备存在标志
5 Z- z' c7 S3 l! t        MOV btIsIDEExist, 1
6 I5 Q7 T! k% Z% Z6 c& D! K
* `# I. p; D$ V$ d( R& D( H# n        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
        CALL SelectDevice

! ~3 Y2 }' i" M6 x) b        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
" S5 Y5 M3 O% ?1 X7 Y        CMP  btIsFirst, 1
% D! n5 ]% ~8 I2 U5 J  G8 i  c% N9 S3 ?        JZ   LeaveRing0

        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy

) P8 \7 g9 w: x/ p% z        // AL的值等于cBit06时，不存在驱动器，直接返回
% |7 W. f+ l4 o- z; X, G        TEST AL, btBit06
* q- Q0 A3 e7 d9 t/ G        JZ   LeaveRing0

        // 设置驱动器存在标志
0 g$ ~, n/ x4 F7 l1 \/ ^        MOV  btIsDiskExist, 1
/ e& ~5 V9 W( w) |* G
' h; _* n% A: N        // 发送存取端口命令
& I& ^2 G* T# d3 Z        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
  t7 E. ^+ ?( ~+ w% ]        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
( C" `& P# m: ^( I$ x/ `6 t        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
! n% g# k* S6 b( m; F0 |7 w        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
        CALL WaitWhileBusy
  E6 `; [3 ^. @2 [) E
        // 检查是否出错
        MOV  DX, dwBaseAddress
2 g- U, `' a+ i( @9 o" I        ADD  DX, 7

        in   AL, DX
& g8 w% L6 ^+ d' d( x. y' U( I( l
        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
. ~/ Q* u. A5 P
0 ^+ O6 @( D% p& J# \1 }- s6 u        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
5 {: P/ |# a* d* U# {% y# K  i        CALL SelectDevice
        MOV  BL, btAtapiCmd
        CALL SendCmd
) }" }- V6 l3 n* F& M+ ], \        CALL WaitWhileBusy

  p8 o) u% M. t! f% W  u/ p        // 检查是否还出错
        MOV  DX, dwBaseAddress
2 @$ Z; v! |8 b+ w, p2 H        ADD  DX, 7
        in   AL, DX
        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回

: ?+ [3 W. |2 G7 ~1 s: Y) e        // 读取数据
! I( l5 \' N1 C4 d' w, U        RetrieveInfo:
; ]$ l7 H# {( j0 ~1 t4 C
3 c5 k7 {" `5 p( W, K# q        LEA  EDI, wOutDataBuf
! A% f$ F4 P, u- ]- J9 T6 q  l$ {        MOV  ECX, 256
        MOV  DX, dwBaseAddress
        CLD

4 j7 r  {8 O- w5 O" a        REP  INSW
4 p0 A0 _" S' R1 `1 E& ^
        // 退出Ring0代码
        LeaveRing0:

        POPAD
        IRETD

        // 激活Ring0代码
; S4 L+ v/ a  U$ \) u- M! x        EnterRing0:
: `( S  N& H  [& E- q' z' w
        // 修改中断门
        SIDT FWORD PTR btIDTR1
  D5 ^, g9 p" N        MOV EAX, DWORD PTR btIDTR1 + 02h
! U/ u& {( m: s  ?$ b        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI

        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
+ j7 x& R0 O' [4 f! `        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX
* g& x3 u! r+ [1 W& v4 L
        // 指定新入口
' b3 y3 T8 l+ K" Y* }        LEA EBX, Ring0Proc
/ b( C9 h$ t8 ~4 k/ ]        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX

        // 激活Ring0代码
        INT nHookExceptionNo
2 U  [* w- D- I
        // 复原入口
        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
        STI
- a/ h' ^4 @7 j' v$ V  v3 c; J* O    }
% o. S/ J, z) Z3 X* d7 ?' X    if(!bIsFirst)
7 `7 N1 R# A1 N4 A# }1 b" s& Y    {
        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
. z1 O$ K% _+ w5 P# l# m        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
( ?! e1 x& w, W  W- p% p, z2 o}
# R+ g9 R; }$ H! V) ^//---------------------------------------------------------------------------
// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
) t+ |/ G( N5 @2 x' @- T- Q{
( l. w, e# X% R3 B3 a    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}