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

天云上人

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

1. 
   # {0 r3 l: |5 n& u9 `7 N3 o3 k
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   
5. #include <iostream>
   1 O6 J5 y# u( A1 K
6. using namespace std;
   
7. #include <comdef.h>
   8 k$ j( F; p0 a: y
8. #include <Wbemidl.h>
   % b4 ~2 n" ]+ A5 `8 ]1 r2 [. Z' i+ _
9. 
   ! {/ l4 f$ T% e/ B: O- W) k
10. # pragma comment(lib, "wbemuuid.lib")
    
11. CpuIDDisk::CpuIDDisk(void)
    * u) t* d% }( U0 I* s3 u1 P
12. {
    
13.     GetInfomation();
    0 v- |4 f$ x0 P$ `6 R0 j/ f
14. }
    
15. 
    0 Q  f; o6 {7 @5 E. L' Y1 y7 Q( I6 U
16. CpuIDDisk::~CpuIDDisk(void)
    ; f: k, `9 m3 `1 w8 C
17. {
    
18. }
    4 U) \: v# p7 O
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    
21.     HRESULT hres;
    $ f2 S" S9 M4 ~' z+ w' M
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    7 Y  J6 }& e& [0 J
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    + u0 Y, ?% M! M: B$ N5 E3 s% `7 r0 T! a
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    ! V# ]- t* ?3 `& J" u0 d9 E1 M4 S1 _5 [
29.     //Set general COM security levels
    4 q) M, n  ]9 [' p
30.     hres =  CoInitializeSecurity(
    4 n( n1 A- X" O+ Z
31.         NULL,
    
32.         -1,                          // COM authentication
    & v5 U! V1 i9 k' u2 N: S7 Q
33.         NULL,                        // Authentication services
    5 A. s/ j9 K9 ~" R8 y) q& Z% C
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    3 n3 g0 _* F& s; m3 Z2 |
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    
40.         );
    
41.                      
    
42.     if (FAILED(hres))
    
43.     {
    + m0 G# ]. ~  y2 f* Q) a
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    5 T$ \$ R7 M7 X1 O6 @
46.     }
    
47.    
    ) i# B/ R( I$ Q' h+ I, }
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
      v  m' x* n7 ?5 ^% k
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
      F1 N0 h7 @$ U' s/ K/ k: U; \
51.     hres = CoCreateInstance(
    
52.         CLSID_WbemLocator,            
    1 f  r0 `, @# `8 H
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    : j2 k( I3 w8 O! Z! o
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    % C  y( z0 s5 A
56. 
    
57.     if (FAILED(hres))
    
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    
62. 
    ! M8 k& ^1 l! Y: c
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    " q3 ~/ Y, W4 G4 w$ Q, @
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
    / E! N% G0 U! |
69.          0,                       // Locale. NULL indicates current
    . V: t* s* k3 R6 J
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    9 U8 k/ x. R( j8 i7 V
73.          &pSvc                    // pointer to IWbemServices proxy
      j. w5 A2 Z4 M, a; a
74.          );
    
75.    
    
76.     if (FAILED(hres))
    
77.     {
    * k: q5 B4 C/ k' s9 @  }& _" Q
78.         pLoc->Release();     
    $ @: p. H1 z3 P7 f3 l: P* G, G2 i
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    ' Y3 ]0 ]: j8 M- s
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    - g1 x; ]4 S# j# z: [9 n3 N
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
    
87.        NULL,                        // Server principal name
    
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 C5 M1 i' N$ w% ]
91.        EOAC_NONE                    // proxy capabilities
    * [, b! M, V) E9 ?$ S  p$ a' G+ R
92.     );
    
93. 
    
94.     if (FAILED(hres))
    
95.     {
    
96.         pSvc->Release();
    % c, O4 M% j2 r, G& l
97.         pLoc->Release();     
    
98.         CoUninitialize();
    % x0 @/ |7 ~1 {9 }3 H2 o
99.         return 1;
    
100.     }
     
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     9 g+ P: e( F+ u* v7 g! O. ~
103.     IEnumWbemClassObject* pEnumerator = NULL;
     7 ^! c4 h/ \  I
104.     //计算CPUID
     4 K; K  G) H& F- `
105.     hres = pSvc->ExecQuery(
     % F( U' r- e9 b' y
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     $ J( ~0 F: S- q/ V# w
109.         NULL,
     / m! ~7 b. t( K# s! k- a8 k
110.         &pEnumerator);
     
111.    
     
112.     if (FAILED(hres))
     ( T0 Q6 b& f9 W9 s) j" f+ Z
113.     {
       P" }1 |7 D% [( e/ w3 s
114.         pSvc->Release();
     
115.         pLoc->Release();
     ( V" Q+ c7 W, H( I6 d+ n- S
116.         CoUninitialize();
     " _- W* c9 |0 {9 Y/ {( L2 c
117.         return 1;
     . F# @9 S  z; `; J# g9 z) s: ~
118.     }
     9 G; Q! Y% `" C1 i+ u
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     , n# g/ N' `# J2 l! b2 \
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     + X& A1 F+ G- C7 e# D
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     3 J. n1 f/ E1 T; H
128.         {
     
129.             break;
     0 f7 D2 \, V1 w8 }
130.         }
     2 G: ^5 _( W& R! k, D
131.         VARIANT vtProp;
     & }( L1 {# w: D
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     8 `' ~+ l# s  P% {9 p
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     4 u/ k. Q9 }" ?6 z
135.     }
     4 _/ I/ A7 u. a3 I
136. 
     7 i9 b9 f( `% W, |" t, ?. ~
137.     //计算硬盘系列号
     7 p" M5 f: ]- Z0 `+ K
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     6 Y' ]% G; b& U; b8 h6 z8 o0 I) O
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     8 v, b% U& ]2 F9 l
142.         NULL,
     
143.         &pEnumerator);
     4 z4 [2 M! x) w* O: |) J' U
144. 
     0 h- S8 K" B8 r6 Z
145.     if (FAILED(hres))
     
146.     {
     5 E4 O( g9 W# k0 k
147.         pSvc->Release();
     
148.         pLoc->Release();
     " @5 o3 _8 C; @2 O
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     
152.     while (pEnumerator)
     3 f5 k6 b' K  T: @9 F* N* c5 G" \
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     $ |/ y5 F+ g5 j0 ?( o( M2 ~/ I
156. 
     
157.         if(0 == uReturn)
     
158.         {
     
159.             break;
     
160.         }
     
161. 
     
162.         VARIANT vtProp;
     ) I$ M: t$ [, V4 t6 V. p) H
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     * V( [  ]* H# I" H
167. 
     " K$ _& y, E, Z, V: ^# b
168.     pSvc->Release();
     4 [2 O6 X, b& l" R6 M2 B
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     * E1 }' s# X. A4 z& a* u
171.     pclsObj->Release();
     1 m+ y7 L, \- a, U7 b
172.     CoUninitialize();
     . M/ p' H2 Z5 K5 Y5 c
173. 
     
174.     return 0;   
     
175. }
     

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
% V& g8 ?% C9 Y- a
#include <WinIOCtl.h>
$ c$ l: z: q2 T6 {1 l#include <stdio.h>
2 U' C. U) g# D4 [) h! B/ v; q- [9 r+ I
#pragma inline
9 ]4 ?* o" o7 c5 |8 D//---------------------------------------------------------------------------
6 x& D4 }1 z, c0 `. _$ \0 C$ @7 w// IDE NT/2000/XP专用变量
4 @" `7 a# T* e# L2 }& ~#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
: c) x2 O8 `5 z' F5 L: H7 @#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
  P, O; o% `+ N2 u  j- ^9 s#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

: B; n. j, J1 a$ v$ b7 H, Uconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
  F) g1 S# l3 H- I1 @, W* M9 mconst WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

  Y* C4 a: y1 ^const int MAX_IDE_DRIVES = 4;

7 I1 _6 M( X8 E2 A+ d6 Z  O( V9 n/ Q) Y// SCSI专用变量
0 @4 i7 |8 H0 T6 R7 Y* I! Bconst DWORD FILE_DEVICE_SCSI             = 0x0000001B;
  A9 c- L- a7 d$ v7 f1 _. bconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
  K' ]# V: {, H  r! F) ?const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
$ c. v4 d) D. l4 l: \: D
typedef struct _SRB_IO_CONTROL
4 ]( m* H& ^# o; G6 V( U2 }  H* @! h% X{
    ULONG HeaderLength;
- _- ~  q, w- j    UCHAR Signature[8];
" j+ T; `" J  n6 \: n    ULONG Timeout;
% Z9 A* v1 P3 R9 |" J( F    ULONG ControlCode;
& M+ m7 B) V# {/ p% P- U( Q: u2 i5 `    ULONG ReturnCode;
! K% `+ `+ k2 q- u- t9 N    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
7 c) w$ {' U: ?' q
+ `( I5 K* `! s/ S! s' m3 {// 读取的主函数
* P1 a$ t$ N9 @- J' Wvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
( i% D3 g, B  s6 j- i* @// NT/2000/XP函数
" @5 B, p0 X, U4 H& Q+ h: l) hvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
  O% t1 g; U2 h# K3 k        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
  x) Q0 j+ y" c7 D1 N  m* wvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

1 _2 ^7 E7 x/ C& N// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
' x8 X1 a! @+ h) e% L) o+ ~//---------------------------------------------------------------------------
, w6 ~. j# @. H; r; B# J// ReadPhysicalDrive
, X: M% v9 I, |# n5 U$ Cvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
    switch(Win32Platform)
/ _8 o' ?+ g$ E' ~2 ~4 x    {
        case VER_PLATFORM_WIN32_WINDOWS:
            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
" V+ d$ U% P, n4 w% ?        case VER_PLATFORM_WIN32_NT:
; D3 E- H% b8 y: u, ~8 L) [1 ?            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
: _2 R5 U* L; f: K) Y        default:
; V) S: m2 s5 f5 h9 [            break;
5 Q' l$ d" K. u% r% C4 u# r4 e$ M    }
}
//---------------------------------------------------------------------------
// ConvertToString
5 d, R2 V+ s+ o, ?8 Zchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
: ?. N+ U0 O7 w* e{
6 g* F2 `1 h. X3 \# ~/ O3 y# \7 {( c    static char szResBuf[1024];
/ p  b) q* ^4 z7 ~2 C. R. {+ P4 e    int nIndex = 0;
    int nPosition = 0;
) y( _/ F0 _9 k1 E
    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
6 p; V* x! r6 D# V+ ?4 [2 `% D    {
        // Get high BYTE for 1st character
2 D7 `' a! U0 Y+ Q1 e' `        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;

# x4 s' o% v9 [5 @) M0 H        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
0 _$ }0 m6 N, T  u" v( T1 d        nPosition++;
    }

    // End the string
    szResBuf[nPosition] = '\0';
6 G) f0 F, T9 \! o: ~4 Z7 S3 P: N
    // Cut off the trailing blanks
    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
' `/ _9 n# S9 Q3 m        szResBuf[nIndex] = '\0';

! ?& C! Y- j3 L' I0 D" c( i5 S+ C0 \    return szResBuf;
" U9 m1 w7 j' N( d; G9 j}
8 l4 T( Q5 i7 l/ u; [//---------------------------------------------------------------------------
3 d9 I4 N0 G6 \/ L$ W& Q: y// Winndows NT4/2000/XP 代码
4 e& o# Q: m2 d" s  m2 d//---------------------------------------------------------------------------
# @1 a( w8 j9 s) U// ReadPhysicalDriveOnNT
9 j/ }5 ~" h4 wvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
! I0 b4 a, l9 k& o: U. g6 G* B{
9 L. @7 i' g! B& ]! V  j% e    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
( n$ l0 ^6 U! A& V    {
        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];
' j7 O* r6 \- {# x9 W
        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);
. [: y7 \* j% g
        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
. f7 j5 O5 a: t" }        {
7 T! y) o; B" R! H* Y' I            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;
: D1 T6 h, ^$ U( X$ a. r
2 u5 f# @# x; z, j5 K! b" O            // Get the version, etc of PhysicalDrive IOCTL
' ~) _& U& F$ a7 F/ v2 t            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
: {, g' x1 x- ?4 n& f, H' n
6 }' Q- ^, ~5 \: ~! H9 ]4 K            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
            {
                continue;
            }

            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
                // IDE or ATAPI IDENTIFY cmd
                BYTE btIDCmd = 0;
                SENDCMDINPARAMS InParams;
, U/ w5 a2 \; w                // Now, get the ID sector for all IDE devices in the system.
6 K1 Q0 v1 U0 F8 t  ~' u' t# r                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
& B4 f' ?& K' ]1 F  e0 l1 ]* Z" l0 v                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

3 _* B0 }/ C! ?7 U1 D                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
* v1 |0 Y! g. y/ x) ~                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                    char szSerialNumber[21];
5 O# a) ?. g4 Y5 N+ n                    char szModelNumber[41];
6 l# H: B* b' Y8 u( A
                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
' A* q, H3 T3 t                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
3 |# e' S4 n0 r& f% r/ R                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
* E4 L) P" ~8 g- f                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
3 s- V8 G1 d; j# T( X5 N
                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                    pSerList->Add(szSerialNumber);
6 b) c3 }; ~7 H                    pModeList->Add(szModelNumber);
9 N; v6 \2 E! A, V                }
% `" d- q# _& C. q            }
            CloseHandle (hPhysicalDriveIOCTL);
) A3 I/ h- W' o) [! ^        }
    }
% p3 Z$ Q& h& @9 T1 v# ]}
6 ?! z% [' B1 `7 k; l7 q4 h& U& ~0 k//---------------------------------------------------------------------------
8 C7 g- b% _3 @: j0 ^0 t// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
4 x7 T6 G% m; e& Z              PDWORD pdwBytesReturned)
, H3 o/ K: A; b! |$ n, c9 `- g{
! z! f# D  P/ \7 C5 l    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
- Z) W5 w; B$ x7 i, r/ D  k. o    pSCIP->irDriveRegs.bSectorNumberReg = 1;
& l& E: O9 p; e2 T. n, t    pSCIP->irDriveRegs.bCylLowReg  = 0;
, |" t# ?- N  H* x6 M4 t    pSCIP->irDriveRegs.bCylHighReg = 0;
; Z  A4 q5 U3 D6 j' l
    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
" C. S- K! U3 H2 L    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
, v7 k$ Q( j2 ]    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
6 _& Y4 I; n8 {$ k8 h
, o: f8 d8 S$ ]; s/ J0 W  P- H3 T, F    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
* Z, I: l% d8 a7 [0 I6 M7 R           sizeof(SENDCMDINPARAMS) - 1,
  K- W' }5 S0 L; ?4 c  N           (LPVOID)pSCOP,
1 M* G5 k+ t& i           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
6 Z, X8 M6 i3 [% C* n; ?9 Q8 n//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
, s' F; E/ t  N( `& @1 L// ReadPhysicalDriveOnW9X
: y/ D, a+ n! A: x( yvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
    WORD wOutData[256];
0 `; U( o. b' v$ `; H" u    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
5 X7 S1 X( a; k$ {$ d    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
+ q- \" a0 V9 ^8 l$ b* t& b+ ^    {
        WORD dwBaseAddress;
- x8 u+ a+ n, g; V        BYTE btMasterSlave;         // Master Or Slave
" j- f. d% K4 Y  A        bool bIsIDEExist;
1 J* q4 A5 {' J        bool IsDiskExist;
1 @8 u8 R7 T1 A# k8 E+ x& P
$ d+ |4 n+ z. g5 t: D. S        switch(nDrive / 2)
5 H' N; Z: o' U  E0 j, _        {
            case 0: dwBaseAddress = 0x01F0; break;
0 h  X5 i" Q5 r& B! F8 m+ @            case 1: dwBaseAddress = 0x0170; break;
$ r4 W, L: q; r' r5 K            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
. ?0 t9 m; j: l7 d" n) I        }
; @/ ^. r- l! R" _
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

        // 进入Ring0
0 ?/ m: ]( n4 ^8 e3 G) r        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
    }

    // 开始读取
  H* R! U  k* V& W$ G    for(int nDrive = 0; nDrive < 8; nDrive++)
: M, F3 m! ^; f: b) l    {
        WORD dwBaseAddress;
( O* r3 d- z! X/ S, U" m        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
        bool bIsDiskExist;
5 t( E: ^( q( `" U$ M9 O; u) |9 V        switch(nDrive / 2)
( q) Y+ e, t  U; D' f2 m7 f- V- }        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
# R; N. z% E% N' q            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }
) Q0 J: ]9 l9 ~
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
. z- z2 i, \: w# K- L. \
        // 进入Ring0
; ~4 b3 h- y5 B, e4 b9 w6 C        bIsIDEExist  = false;
        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));
) |4 P* [* X* l% X- N9 c$ c
4 _# I9 |$ v1 @  V7 L0 z        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
6 H+ s: D5 q2 h                bIsIDEExist, bIsDiskExist, wOutData);
% p& \/ f; X8 B& z  ^8 O/ x
% V3 x$ c8 H7 |; f. B        if(bIsIDEExist && bIsDiskExist)
" x: e. y! p/ Q        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
' V/ U8 [) K, |( h: y9 g! z: F0 ~            char  szModelNumber[41];

            for(int k=0; k < 256; k++)
0 t4 |1 o/ W4 a# J( H                dwDiskData[k] = wOutData[k];
* g8 O2 h, i% X* E
' c2 W, ~$ p3 l. _            // 取系列号
" I9 |( ^; R: C4 _# f7 z            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
7 m8 X' p3 V+ y4 e7 G5 R+ g            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

! `3 D4 {- j4 Z4 w" o            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

* `; u/ L  p' X9 X, U            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
1 o1 Z% w6 o# t! r' k        }
    }
5 M: j, B2 q0 y1 ?4 Q9 U( e& \    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
* i, @' b+ b+ `3 l, e; y4 f// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
# W; v) H9 H) _3 D5 m6 T% u* I//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
0 G- l  E4 ?* p3 s" a5 T# V// btMasterSlave = Master(0xA0) Or Slave(0xB0)
% Z! j2 e+ N' X. [. Z6 ?0 V//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;
+ r8 Q  \  w2 h# F. L1 H# X# p( u
    BYTE  btIsIDEExist = 0;
; Q5 p2 \! F5 m& N# H    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;
4 y' s6 q. h0 R5 u6 [: X; j
! I7 Z6 w% J7 c* O" {    const BYTE btBit00 = 0x01;
7 S4 S* H- D$ c8 R7 u    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
# C5 B7 \- @: ]* ?4 j; x4 s% `    // const BYTE btERR  = btBit00;
7 F/ [0 }/ ]  y    const BYTE btBusy = btBit07;
! Z8 G8 G$ k1 j( h9 c6 ?8 n' P: e    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;

    __asm
    {
6 Y! B$ a4 M$ z- P) x  C# r& _        // 必须先执行这条语句
        JMP EnterRing0
1 w1 a4 |) A' E/ ^/ s4 T; s
        // 定义过程
        // 等待IDE设备直到其不为忙为止
# \$ Y7 ~4 A+ U! l2 @4 I: v/ P        WaitWhileBusy proc

        MOV  EBX, 100000
% c. H; H+ D& _8 P# X6 ~        MOV  DX, dwBaseAddress
1 q# G1 S+ c  n* ~0 h        ADD  DX, 7
! J$ P3 R7 Z: Z/ I5 `
; m* P  E& I* p* h0 r        LoopWhileBusy:
8 K* v0 W; ^5 @/ x
        DEC  EBX
        CMP  EBX, 0
        JZ   Timeout
: p6 E$ t- a) r% s        in   AL, DX
/ i! Y& x+ O7 A* V1 X        TEST AL, btBusy
0 m. j4 N4 K) T5 G) b/ Z+ ]        JNZ  LoopWhileBusy
        JMP  DriveReady

        // 超时，直接退出
3 @/ |, \2 q# R, N        Timeout:
1 p4 T5 h. u4 b' a0 F$ y' a( z& A        JMP  LeaveRing0
' k: ~! y' B5 y! {        DriveReady:
        RET
: u( _- S6 H  j& ~( u$ n1 E        ENDP   // End of WaitWhileBusy Procedure
# ~! p7 B! n( Q% S' s6 f
        // 设置主盘和从盘标志
: @; s6 X5 p1 ^* L5 w2 N: I, I        SelectDevice proc
& b' u4 C" F# ]; o; l, [$ K
        MOV  DX, dwBaseAddress
& q' F4 G/ N# n4 Q0 N3 N        ADD  DX, 6
) W! s3 S; p; {+ k, V0 q5 H        MOV  AL, btMasterSlave
& x) A3 @- F  N& Q
        out  DX, AL
3 F6 {# C4 F5 S/ @& K9 j. h        RET
7 M6 R3 c" E" k
5 K6 m. q; I& X# ^  r% o6 \/ R        ENDP  // End of SelectDevice Procedure
2 @  u* f, D6 n0 L/ m% d
        // 向IDE设备发送存取指令
        SendCmd proc
( J) Z% S5 I1 h5 l4 d
        MOV DX, dwBaseAddress
$ f, @. C% l3 n9 M4 h: a/ d; C        ADD DX, 7
0 O: w8 f  ^5 H4 Z        MOV AL, BL // BL是主从盘标识，在过程外设置
5 q. l/ U' E+ \0 I- Y0 \: Z$ k& q8 l        out DX, AL
; A- C; i9 H! `$ v: }        RET
        ENDP  // End of SendCmd Procedure

        // Ring0代码
        Ring0Proc:
3 V% h. X- e" O- o- D        PUSHAD
4 r+ j0 }1 n- L+ T        // 查询IDE设备是否存在
# n' n, D! S! u) i        MOV DX, dwBaseAddress
4 v# y$ R% N6 f( @+ _: _  R' c        ADD DX, 7
        in  AL,DX

. {7 c% r# x  y; e+ `4 }        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
, r& ?, Q: Y0 `( u        JZ  LeaveRing0
5 ^0 E, r, _* B0 j+ K+ V/ l3 A        CMP AL, 0x7F
, r4 }' X+ @, }        JZ  LeaveRing0

        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1

        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
$ U  |1 Q4 _+ b" J        CALL SelectDevice
$ M" t- e+ b0 f" G$ \/ g) y
- @0 t" R* m" ?: h' o        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
/ w9 u( |  S  f& v1 c$ v        CMP  btIsFirst, 1
        JZ   LeaveRing0

4 |, j8 r* M" R* I2 `( H3 n" K        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
8 y/ m3 [" C  u        CALL WaitWhileBusy
9 z  m' K$ E" h" Q1 O  \
        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
7 b  W/ G( K  c% j( [( B        JZ   LeaveRing0
$ P: i; e8 Z; m9 |" u+ D# ~  t
# I; H& w/ u, m9 T6 t        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1
1 q1 ~0 n& g+ Z- |1 I0 f
( i. P& L9 t$ }, I( @& w6 u/ p        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
# N! _8 Q! T7 u0 ~" L* g9 L2 ^8 J$ X        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
! w  C) `" y$ B3 N$ }$ z5 U2 f& I$ Q& z        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
' h) N# B' r) g1 u6 t        MOV  BL, btAtaCmd      // 发送读取命令
2 x7 I0 y+ e! R2 }; }/ N        CALL SendCmd
        CALL WaitWhileBusy
. c* z! r: U7 v# y/ Y
$ c- p& U, d3 I0 x: ~* A        // 检查是否出错
        MOV  DX, dwBaseAddress
5 E* k- d6 n9 c" V# s        ADD  DX, 7

        in   AL, DX

        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据

( t/ `5 ~! G' \4 Z. _7 P4 Z        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice
        MOV  BL, btAtapiCmd
1 e4 g  A3 y! O5 p) z! \( b        CALL SendCmd
6 z; L  {/ V- T( c+ j        CALL WaitWhileBusy

        // 检查是否还出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
        in   AL, DX
- E6 e8 [( \9 P        TEST AL, btBit00
# K/ A8 S$ K0 C& C        JZ   RetrieveInfo   // 没有错误时则读数据
% ?( ~5 [: y0 ]# k4 m( K6 _        JMP  LeaveRing0     // 如果还是出错，直接返回
1 H+ h9 S5 N; q- @# u7 l
        // 读取数据
- q8 _$ i9 d% R2 ^5 d# R        RetrieveInfo:

6 w3 a3 M' U2 w; [7 J+ L        LEA  EDI, wOutDataBuf
* U; N$ K; F' O! `1 u, C1 _        MOV  ECX, 256
! Z" X* a  D' e( a* _" _+ s( r2 P2 u: z        MOV  DX, dwBaseAddress
$ D7 T. y: A$ `6 j. Q% b6 K- _& k        CLD

        REP  INSW
+ }' R" P5 N. D# h2 h$ b
( E# `/ d9 R4 d- w, w3 P        // 退出Ring0代码
        LeaveRing0:

        POPAD
% y! u: c& b$ }6 f* u7 L7 l  c        IRETD
' W: ^& H. k+ N- s9 b
        // 激活Ring0代码
        EnterRing0:
1 L% Y' @0 b  O; P
" _/ e0 Y" H, V7 R        // 修改中断门
$ [; X: h! d" W$ M% k        SIDT FWORD PTR btIDTR1
2 N. Z5 M! ?9 C% U3 J) L3 x        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
- Z7 p. f$ d/ F& ^        CLI
# R9 U" ^" M7 c( E- m; l; H4 v
        // 保存原异常处理例程入口
* n, G' Q9 `9 Y: H5 _5 G0 B4 m- e! j3 V        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
0 S. [9 t# ?/ u3 c$ E0 P6 r        MOV dwOldExceptionHook, ECX
3 }3 p$ a  |  M' d7 U
+ U0 Q4 ]5 ~) l4 w        // 指定新入口
; P$ e; |/ y0 Z1 B, o/ N3 `        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
. F0 S# Q; V4 }# t0 W        MOV WORD PTR[EAX+02h], BX
/ ~" S( c4 g4 C, P4 {
+ R4 V" S8 r( r' o& w' f0 B        // 激活Ring0代码
        INT nHookExceptionNo
/ E( g, @+ l9 m" y- t
        // 复原入口
        MOV ECX,dwOldExceptionHook
2 |+ @$ V- i$ U* o        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
% @- ?5 M) d" o# Q7 V% L4 J        MOV WORD PTR[EAX+02h], CX
        STI
    }
    if(!bIsFirst)
    {
        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
5 o* r; \" A/ z, A3 |3 Q/ d}
* c) G, }3 ~/ Y//---------------------------------------------------------------------------
) s4 Z5 a- X8 n( F' u" q// 调用方法：
& a' W+ x  v" qvoid __fastcall TForm1::Button1Click(TObject *Sender)
{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}