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

天云上人

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

1. 
   
2. #include "StdAfx.h"
   " A5 ?% E. R8 i
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   
5. #include <iostream>
   
6. using namespace std;
   & X- e  c$ [3 ]7 D
7. #include <comdef.h>
     S/ ?3 N, C/ @/ v, H+ E0 F1 ?
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    . p" [- T) ^' n" c8 p
13.     GetInfomation();
      O3 ?$ r# r2 x8 j3 v- k
14. }
    
15. 
    ; X" e: w5 D( V" K" G
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    
21.     HRESULT hres;
    ! r& @% ~$ h& P/ S
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    7 x8 i7 M$ c; g. Q/ A4 i' q8 ^
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    3 b7 `5 h2 ~" Y3 b
31.         NULL,
    % k) N5 w5 W. ]& A
32.         -1,                          // COM authentication
    + ], ^$ Z* q2 e; R  o% k2 j
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    ( G- }* ^, U4 w) g7 I& `& R6 u
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    5 W- s' v; G3 ^) \% B, r
37.         NULL,                        // Authentication info
    2 i) O7 u3 G  R5 @6 ^& f& {
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    
40.         );
    
41.                      
    ; m* w3 W" _* e+ k% a( J. I$ F
42.     if (FAILED(hres))
    
43.     {
    
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    % ?& {: u& V2 f7 U0 e/ d3 M. \; q
46.     }
    
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    . h  j  H+ D6 C7 \
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);
    4 U3 Z0 U8 v) j9 M. s& L0 T+ Z
56. 
    
57.     if (FAILED(hres))
    
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    " n2 i- L9 h" a* e  n8 j
67.          NULL,                    // User name. NULL = current user
    & u7 P. V, |4 x9 n) [4 s2 ^1 b! f
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    , Q  @0 a/ O$ X9 s5 \; ^# C
70.          NULL,                    // Security flags.
    2 g- e% l* E. v
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    1 c- O% X4 h; C9 f
74.          );
    
75.    
    
76.     if (FAILED(hres))
    * _) h6 H% Q2 P6 i8 y  P7 K
77.     {
    $ C$ j: j4 g2 V$ h6 p, y
78.         pLoc->Release();     
    
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    , t) ^' L  X. p# L( E
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    5 q9 u, r+ f8 ]1 B) X
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
    2 S' q/ m; J- ~5 M8 w& X
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    : T8 x, m  R$ [/ a2 z6 h
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    7 l; `( [4 ^" G4 g  U
93. 
    
94.     if (FAILED(hres))
    
95.     {
    . _9 v! }: }0 \5 Z
96.         pSvc->Release();
    
97.         pLoc->Release();     
    
98.         CoUninitialize();
    2 l  H' @2 `9 C- ^, k
99.         return 1;
    
100.     }
     * J; Y5 T: @! H1 T
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     ; _8 K7 c7 a1 K% l( N3 f. c
104.     //计算CPUID
     5 S& @5 U+ Y3 J- ~
105.     hres = pSvc->ExecQuery(
     9 |6 \' L+ ?  \! G6 V4 S
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     1 `6 L0 j$ d! `0 c, B
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     8 m7 [! ^6 e) F6 s
109.         NULL,
     7 _! W7 Y; M% L+ y: |# S9 o/ j
110.         &pEnumerator);
     8 `, M0 m! U7 P8 N3 ]# ^8 v
111.    
     
112.     if (FAILED(hres))
     
113.     {
     
114.         pSvc->Release();
     * R# K) s+ |5 ?" q" L' C
115.         pLoc->Release();
     5 Z% l  I+ a) J3 i% f
116.         CoUninitialize();
     
117.         return 1;
     
118.     }
     0 x* y; N0 n5 B2 O: _& z5 w* F
119.     // 步骤7：Get the data from the query
     5 ]% ]  K, Y- Z9 `  x' ]7 H
120.     IWbemClassObject *pclsObj;
     ' r! D& a$ \; s
121.     ULONG uReturn = 0;
     ( S9 N. y5 M7 z* L- q
122.     while (pEnumerator)
     ( }& Z5 A7 N+ ]4 a$ G5 u1 V* \2 z
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     6 F0 N& A* h" e  {% c4 r+ ?8 T* ?7 k
125.             &pclsObj, &uReturn);
     
126. 
     3 I$ q" @. |8 I; Y0 i# u; Y9 t, M
127.         if(0 == uReturn)
     
128.         {
     4 i, v% W, z: H& Z: h
129.             break;
     
130.         }
     8 R8 E: a5 y+ U
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     + y2 w+ d6 T5 i  K4 o
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     5 ^1 p! M" t' Y# L+ D
136. 
     # D, O2 T3 e7 N- w  E, `; [
137.     //计算硬盘系列号
     8 g* O2 u0 O" j: U
138.     hres = pSvc->ExecQuery(
     8 n" ]' A4 t# c, a1 Z
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     7 \% |6 x) ?  }
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     : W' p8 x, c: _$ n" j" e$ M. Q
142.         NULL,
     
143.         &pEnumerator);
     
144. 
     6 {: [7 ~6 S) P
145.     if (FAILED(hres))
     
146.     {
     1 v3 f- w& @. P5 w' H' O* G+ s1 v9 a( A
147.         pSvc->Release();
     
148.         pLoc->Release();
     
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     4 O! |( [3 ~  a, J# N
152.     while (pEnumerator)
     
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     : K- s  B; r& j4 u! ~/ q% u2 w
155.             &pclsObj, &uReturn);
     
156. 
     
157.         if(0 == uReturn)
     
158.         {
     * m) `: ^) u# H$ j
159.             break;
     5 ?( Q9 @' A, {) j6 t- F# v
160.         }
     & L+ P5 S8 q( J: m6 \# Y$ y  {7 G
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     
167. 
     " k1 b' T- q0 L3 e
168.     pSvc->Release();
     
169.     pLoc->Release();
     ( r0 c' z( [1 T
170.     pEnumerator->Release();
     ; U* ]( ~1 [: o6 g2 x- H! x
171.     pclsObj->Release();
     
172.     CoUninitialize();
     
173. 
     ! r' M' T8 u, S9 I% h: b
174.     return 0;   
     
175. }
     6 O& W' q' ?3 Y' x, h# H5 z5 b1 g/ L! T

复制代码

天云上人

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

#include <WinIOCtl.h>
#include <stdio.h>
& [, b2 f' u6 s0 O$ u2 S
#pragma inline
//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
4 B, ]+ k7 }1 C; ?#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#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设备的命令
* i+ w) K6 T+ u7 w  {/ J
5 R  V5 O: a! `/ hconst int MAX_IDE_DRIVES = 4;
& e" e# ?! ~. q/ N/ r3 s
9 \% h% Y& e/ |3 o// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
* h8 f. w! c% E( e7 sconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
0 E! L5 s9 x4 [const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
/ X. u4 w0 ~( W, S
* B" j3 l6 W# }9 M" B+ S% _typedef struct _SRB_IO_CONTROL
4 y7 [+ n, [9 ^, F" _{
0 n7 H6 O* |( L    ULONG HeaderLength;
    UCHAR Signature[8];
2 [$ U3 N0 N+ O( P" f    ULONG Timeout;
' ?2 I2 v# s' q    ULONG ControlCode;
- ]$ z1 t4 E$ h7 Z# f8 y. b" `$ S    ULONG ReturnCode;
3 p7 B, Z3 H$ W6 e    ULONG Length;
, ?6 _/ v' ~; K" I' O1 z}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
! [0 u) j3 N7 Y6 k  H- G
// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
4 t9 j: F0 P1 E
" k% X& V* d7 d7 M' a9 c& z// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
2 L7 y$ V' ~) K# e// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
2 W, l6 Y7 Z" `6 z3 Z  e5 P% h) x5 ^        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
7 n5 D2 a# R% C3 @* K7 S) {void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
) ]  ]" c+ J/ G" r! z
$ q- W% W* |7 s2 H& [// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
& \8 |4 y" ~4 Q2 P0 qvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
( d% X9 `& m  U: j( Y6 l+ v9 n{
. w# h6 d4 u1 v( W; o. q9 f; g    switch(Win32Platform)
    {
7 \8 K4 K9 `# J/ O7 h9 ?/ x        case VER_PLATFORM_WIN32_WINDOWS:
4 j, ]- i$ g& ~1 }4 ?& N9 k* D: Z) h            ReadPhysicalDriveOnW9X(pSerList, pModeList);
! {5 d) h2 \7 O: [+ O+ I) w* T            break;
        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
) Q# t& x& I+ O& Z; t0 e2 I            break;
- m' x; F% `' j$ [" s        default:
            break;
1 J2 V9 i# K1 _    }
}
7 ?+ [: O' Z5 Y//---------------------------------------------------------------------------
# J5 z, i  D+ N- g5 C8 e// ConvertToString
6 O4 h7 `9 |1 a# \6 Y( D! D% mchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
2 [7 k0 i! I& @4 y- j4 w: H* @) F{
; y% T: z; r, p/ g# M! c6 @1 |: `2 K% e    static char szResBuf[1024];
" J1 V5 Z4 i/ M0 i    int nIndex = 0;
    int nPosition = 0;

! G6 h5 G  _/ r, o! u4 V. ^    // Each integer has two characters stored in it backwards
$ G3 X! `3 ?9 k- X4 r- h' l/ R    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
/ ?$ r* s% F* A- U, K! C0 K    {
/ c2 `/ _& `0 V        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
. h$ N/ ~# O- q) n1 E        nPosition++;
, P; H+ L$ P6 Q6 i( f3 t0 r
( K8 n, T5 ^% A# g8 K6 L        // Get low BYTE for 2nd character
6 _8 B# n+ r, d        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
    }

    // End the string
$ p4 o9 ^- l. Z4 l  U* C) ]. w1 W    szResBuf[nPosition] = '\0';

    // Cut off the trailing blanks
- H: D. H/ w9 U    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
) L3 E, }; l5 }  X        szResBuf[nIndex] = '\0';
9 _- a  ~+ g0 R+ u1 }# F+ S9 W5 B
    return szResBuf;
3 P# y# y9 \# Z8 y* l4 @% q}
//---------------------------------------------------------------------------
3 O7 A5 N/ o, b// Winndows NT4/2000/XP 代码
: V- {0 O" x5 F, m9 m4 @! E: k//---------------------------------------------------------------------------
: [6 s4 |; |1 j- p5 m& J! Y// ReadPhysicalDriveOnNT
* J' t" l2 A( m- L: r& q: [: g) _void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

; T/ G/ X" D- U% ^) X$ _    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
* s- K/ @0 K7 g, Z. u        char szDriveName[32];
0 K# v5 J, o8 Q- D$ o9 M
8 m. v# Q7 O$ q        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
! O6 L) p! ?" M9 K& t7 |9 v0 f        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);
9 p/ q' `: s. I0 H& G! L$ n, H
        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
& r/ z7 b0 [' n) A4 E9 b2 l% ]6 P        {
8 S7 ~; x5 i8 r3 |            DWORD dwBytesReturned = 0;
5 h& o3 M* Q: y7 E4 R            GETVERSIONOUTPARAMS gvopVersionParams;
2 f6 I- X( @( B$ k9 u# R
. g1 i3 V, ]% ~            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
- Q! N7 @" ~* d+ P9 p
. x  L. u' N( F            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
! n' }! |& H  m, d% U' T% V                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
            {
                continue;
$ [9 {3 ]$ i6 x$ q" G            }

            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
                // IDE or ATAPI IDENTIFY cmd
                BYTE btIDCmd = 0;
2 F/ B# P3 d+ e$ Y2 x0 J# W                SENDCMDINPARAMS InParams;
                // Now, get the ID sector for all IDE devices in the system.
' z. Q* w5 j: I& {                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
( f# V" A$ Z9 {( @+ h- d* V                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
6 t5 C- \& _! K3 w) k( ~                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
! ^( T% Z! E0 s$ I/ H. _5 e$ C
% G* Z2 C$ Z9 ?4 Q# L5 L                if(DoIdentify(hPhysicalDriveIOCTL,
; M# C- ^) S( q* P0 ~                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
% G- w' V; V5 g) g0 d1 S$ D                {
) N* o" X  O; W8 }                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                    char szSerialNumber[21];
                    char szModelNumber[41];
* Y0 x% `  w* w1 k, Y$ S& s( @% o2 Y
6 W3 Z, U' s8 }0 F& @# _4 D! i                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
0 X6 f8 s/ b) [% u: r7 ^9 `                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
0 g. W2 n4 ~" m                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
: M4 v" h: X  H; Y6 Q# g" a/ X. J
1 f1 b% j: l& s* {9 J                    // 取模型号
- Z. G" p1 a% L& V  m3 v                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
$ E% C' I4 a- Z7 Z3 ^                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

* O' u' S1 t+ x; a$ ]- Z                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
                }
            }
- t6 Y  B' m9 d1 i% v- e: l6 @6 g            CloseHandle (hPhysicalDriveIOCTL);
# z% z. e! k5 J; n        }
) g4 E# G4 ?8 c5 s  O    }
' y) c. n! ?% U  R}
. j9 t+ }9 U1 X* f//---------------------------------------------------------------------------
$ J$ f" A0 W; o) l: Z// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
{
    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
4 z+ F$ ~# }, n  z' \$ U/ ]0 c+ }    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
* x# {$ O' `: W5 V1 a    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;
( J+ o: W/ s5 y! d, m; O3 R
- W* b# ^2 |1 i$ x" g    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
; ]/ R, N5 q2 c$ v4 T. \# P- H, X6 o    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

- ]8 Q+ ~8 K8 `+ v& S3 k    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
& M. I+ D" F9 I: z+ H2 K. J    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
* D( i% m6 i: P6 l
    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
* b/ }1 E3 P9 K5 Z           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
, s" {! e* d1 G4 ^           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
. u. y  A' \4 T( H7 \: ?: y    WORD wOutData[256];
    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
3 J! Y, a! y) g1 k1 g# f
! W6 O, v/ X4 _: w    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
* I' ?7 H" O% i5 Y" G+ Z! E    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
# p/ G! f  O4 C4 W% X! G" @# M    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
) @. L( l8 S' o. e. j: M, z    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
/ h5 Z8 ?4 i! ]        bool bIsIDEExist;
0 f' ]- Q- R7 u$ U# Z( a  Q        bool IsDiskExist;
4 z' o* W' e% d
7 ^+ q( m5 I  W$ r! S" L% s        switch(nDrive / 2)
" E: y" e; q' F& ~- S        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
# B5 J% O+ e* U- I( a            case 2: dwBaseAddress = 0x01E8; break;
; ]9 x4 D7 r% ^( ~            case 3: dwBaseAddress = 0x0168; break;
& ?$ e: W  C, j) B9 k        }
# v; E# m3 h$ b2 p
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

        // 进入Ring0
8 ~# E% a$ d" Q- {, k8 ?' s        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
9 L2 b* ]9 c( Q$ f9 g                bIsIDEExist, IsDiskExist, wOutData);
, b, d9 X- ?1 y- \, k- {    }
% N6 K; @1 ^0 S- t
    // 开始读取
    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
) x. f4 V* y. C+ l0 G( U        bool bIsDiskExist;
3 j) l& {4 U4 A- l+ |& s! C4 I        switch(nDrive / 2)
  L% R3 u8 ?+ F: E        {
! N- k1 v% j# D2 o9 F7 _  u6 B            case 0: dwBaseAddress = 0x01F0; break;
' A1 ]. s. k2 ?' O! }            case 1: dwBaseAddress = 0x0170; break;
3 F" d$ y- ]1 r6 w( ?- w! |            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }
' I0 P$ P, y5 h" A8 [; z9 o) B3 ^
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
3 p* M( p( C- e: H8 X# e
3 Y5 A1 a' ]/ o" v0 B        // 进入Ring0
) n/ G7 g( I' p- O  G        bIsIDEExist  = false;
        bIsDiskExist = false;
2 c, j: Q6 B% q) m. I        ZeroMemory(wOutData, sizeof(wOutData));
! k$ S4 ~+ k5 v" i  y0 k, Z% L+ R
# Z  v) J0 z' o* k$ T+ O        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

! T6 m% L% q7 H        if(bIsIDEExist && bIsDiskExist)
! u2 T  G/ q% |5 t: H* z0 o" J/ A        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
: K# ?# `, V6 ~% |            char  szModelNumber[41];

" U6 \: G6 b/ G& G" }1 s  O            for(int k=0; k < 256; k++)
; W7 Q& `/ z/ b; @                dwDiskData[k] = wOutData[k];
2 H7 c8 [! u4 }# A
            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
% m0 a! a* G) y  L3 v            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

- s) J) M* d5 u  ~            // 取模型号
  \% J  O& M) A' i& ~; ^/ r            ZeroMemory(szModelNumber, sizeof(szModelNumber));
# Q( S8 v* i: D* H" K# O$ t            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
, T2 F9 v& a; e- a; l" q7 i
2 i. N$ ~& f" ~) a& E2 u5 L            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
* m; B6 q- f. |+ h* `9 K- b4 v        }
3 Q& I- I. }2 V( N. h$ u5 |* M$ E  a    }
  q# M& H  I# v# K+ w    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
/ r1 T' o, w3 r* f5 r$ R// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
* ]9 @) N# C4 G  \5 N/ b//---------------------------------------------------------------------------
# j. Q6 R: V8 A8 {9 Hvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
- Q. L9 m6 u4 y4 S. W        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
    BYTE  btIDTR1[6];
- u8 d4 x+ ^4 Z    DWORD dwOldExceptionHook;
* I1 \7 _+ ]! X' j6 i; p/ U8 }    const int nHookExceptionNo = 5;
1 A6 e% i% G( j" v4 E; f4 o
. p1 k$ u, [, j; r/ k    BYTE  btIsIDEExist = 0;
% {  P5 }3 h! h% j    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];
+ E+ o- k3 j; w
    BYTE  btIsFirst = (BYTE)bIsFirst;

4 W: u8 T. F9 o( r, u# q' S  v) {) q    const BYTE btBit00 = 0x01;
! o4 c( x9 {  X9 w* C' F4 q    // const BYTE btBit02 = 0x04;
0 ?8 x1 K6 Y, r: p. Z9 ]    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
) X4 T! [( _. c9 t    const BYTE btBusy = btBit07;
* y; }% Y* y( U    const BYTE btAtaCmd   = 0xEC;
3 y+ L- y6 l! o* f    const BYTE btAtapiCmd = 0xA1;
" V! E: G5 |: A1 F3 p
) j% C5 \& ~  h/ G) j; I/ ~    __asm
    {
        // 必须先执行这条语句
# |: B+ X1 t; [        JMP EnterRing0
+ m4 v6 A/ u9 [1 |5 N: E8 s: S
        // 定义过程
        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc

7 Y4 l8 q. c. y        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
        ADD  DX, 7

- R* Z) y/ f5 X! t2 A% H4 v! o! v        LoopWhileBusy:
" Y7 E5 n+ Y" c$ c* \
/ n4 {# B5 s/ t  z        DEC  EBX
1 Z. H; V; Z* A  Q1 M& e        CMP  EBX, 0
        JZ   Timeout
/ B, V. I  i8 u) `: s5 m  ^: g        in   AL, DX
        TEST AL, btBusy
+ w" l# V& c+ u: w        JNZ  LoopWhileBusy
" f$ @" R# _. w, A. h4 d+ I: F& `$ g        JMP  DriveReady

6 |' ^8 s7 ^5 f) R8 s9 F% {( {        // 超时，直接退出
; h/ n7 i! r9 z4 @9 k2 H        Timeout:
1 g/ c, B1 O% M7 H        JMP  LeaveRing0
/ f- b' F/ W+ R5 h$ k$ g) c# b, ?, E: ?        DriveReady:
$ {! x1 j3 t- L. Q: Y# U5 e% L  c        RET
( ^8 G; ]- s" ]5 _& b3 c8 T        ENDP   // End of WaitWhileBusy Procedure

( K9 \0 T  ]1 g2 G        // 设置主盘和从盘标志
5 K  o# z* R  h        SelectDevice proc
. o+ H; t; [4 d
! o( w' j; F( K  ~        MOV  DX, dwBaseAddress
- h1 S" a5 o7 b0 d        ADD  DX, 6
        MOV  AL, btMasterSlave

1 l1 Y' o; @  w8 C! y        out  DX, AL
        RET

        ENDP  // End of SelectDevice Procedure
1 b7 d5 {) ~% ~4 t
        // 向IDE设备发送存取指令
7 f% D9 `/ \0 n9 W! E# o' q        SendCmd proc
% z$ x& `! G" u  S
1 R+ A+ z: i* r( U/ {        MOV DX, dwBaseAddress
" t9 t& {+ j9 W) t  R1 v        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
8 j7 T$ ^# n0 f" o% b3 j        out DX, AL
, C% J) G! z. n/ I, k% p* M$ Q        RET
% M4 J9 P4 t1 a6 z% S! Z6 U& Q# l5 C        ENDP  // End of SendCmd Procedure
$ h8 z5 S/ P. k2 u- K5 g3 h
+ J3 B: D. R1 a. [        // Ring0代码
% j. v% ^' N$ o, }" ?; V        Ring0Proc:
        PUSHAD
9 c. B/ I; f2 Z/ T5 [# e$ V% k2 u3 b        // 查询IDE设备是否存在
1 P0 ~  ?4 E; n  `        MOV DX, dwBaseAddress
& s( i% a* }# U- _% O- o& }6 g! p        ADD DX, 7
        in  AL,DX
) ^/ S" P& U* R! _
        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
        JZ  LeaveRing0
) ^4 q; k" S! D+ i& e4 G4 S* |        CMP AL, 0x7F
        JZ  LeaveRing0

& g& n: p2 Z6 T        // 设置IDE设备存在标志
6 J: i* v( w' s9 P5 @5 P        MOV btIsIDEExist, 1
6 x8 {8 Y/ Z' M% g* g2 B' k9 c) J! B
' f3 h# y* X" R+ j  v        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
& Y: x( T( t; i, k* T" i        CALL WaitWhileBusy
        CALL SelectDevice
3 r9 o0 o% n2 Z9 o% e: ^, n8 g
        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
        JZ   LeaveRing0

        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy
9 R6 H# z; u8 o7 Q
4 }, g& H7 O8 n        // AL的值等于cBit06时，不存在驱动器，直接返回
/ D) l3 I4 ^8 B* C        TEST AL, btBit06
! U0 r! D- i9 j% l' V8 @5 _        JZ   LeaveRing0

( J' }2 l. i8 w( {        // 设置驱动器存在标志
" c$ `& V& U$ [        MOV  btIsDiskExist, 1

        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
4 T# ^3 S" `# Y( u7 k        CALL WaitWhileBusy
+ S3 x4 d/ V: G! v1 Q; \) V6 F        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
4 u) w" `. r+ [  b; O- s1 g' j" k- `        CALL WaitWhileBusy
$ v$ m* q  {9 v6 a& N8 u* D  c2 Z) g
        // 检查是否出错
$ c; d1 X* j; J, p        MOV  DX, dwBaseAddress
+ ?7 o( ^! U0 W7 ?+ d" H1 w; @        ADD  DX, 7
* J' @( A0 x" i; @! u" Z  M
        in   AL, DX
5 d& {' e6 P  Z
' ?7 ], m7 _) _; N        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据

5 h# w: T9 y8 S  h1 E4 I+ ^* A        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice
        MOV  BL, btAtapiCmd
, e) ?" ^1 R* m. b        CALL SendCmd
- I  I  z! A$ k/ y        CALL WaitWhileBusy

        // 检查是否还出错
0 R- z' C$ f9 v2 ?  R2 u        MOV  DX, dwBaseAddress
3 y, [6 Q7 L8 d& S        ADD  DX, 7
        in   AL, DX
  p) e0 v" C; w; [6 M+ {        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回

2 }% o. J1 j. T        // 读取数据
        RetrieveInfo:

' ^" I( {* V' p2 m2 F! g% k        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
        MOV  DX, dwBaseAddress
        CLD

        REP  INSW

        // 退出Ring0代码
        LeaveRing0:
5 s2 Z+ C; n2 M0 d
# U; i# k1 x/ L; Q7 J        POPAD
        IRETD

        // 激活Ring0代码
) \# Z- q% C2 R8 E$ C        EnterRing0:
& n7 Y5 b7 H$ O% ?( p' D& p0 w6 Z
( _8 E7 L+ N- Y0 F        // 修改中断门
        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
3 X' t. n$ _; o8 c; O        ADD EAX, nHookExceptionNo * 08h + 04h
/ e/ S9 D/ ~/ s$ g        CLI

% t( c, \) l' B        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX
8 `8 S7 x3 g- [: i) u, O
        // 指定新入口
0 Z* W& M- l; g8 t8 m: x        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
" s. U" Z) l1 z/ j; j$ I- R; E        SHR EBX, 10h
( `3 Y) _0 y1 M) D% [        MOV WORD PTR[EAX+02h], BX
  E0 `3 t5 a2 M, ?/ t) B
        // 激活Ring0代码
! y' g# X; ~6 x        INT nHookExceptionNo

" K6 F( d5 N9 J5 S        // 复原入口
        MOV ECX,dwOldExceptionHook
! @( ]+ \! l1 W) \1 s9 {        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
        STI
; z5 w5 r# C8 C2 Q4 L    }
    if(!bIsFirst)
  ~$ O+ k: V/ z7 Z    {
        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
7 C4 Q2 I* ?- Z1 Z* t}
  y# b" N  A+ V% B//---------------------------------------------------------------------------
0 N2 ^, q+ w4 k; @2 r4 ]" d8 {// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
8 L% Q, q! G1 ~# i4 Y$ i{
) M  u% u' b, K# M) u    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}