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

天云上人

代码框架，你所要做的仅是修改WQL语句，具体可看MSDN。以下代码为简介起见，一次返回所有的CPUID或硬盘厂商系列号
. J$ P% [: e$ D! S+ u) F

1. 
     i5 `. }7 W! p" ^
2. #include "StdAfx.h"
   2 G4 T4 Q1 d/ Z  H
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   
5. #include <iostream>
   
6. using namespace std;
   
7. #include <comdef.h>
   $ [& m. ~; P4 n* m& X. [
8. #include <Wbemidl.h>
   " X0 i( J2 j5 `
9. 
   5 b8 ^: I' A! ^/ }
10. # pragma comment(lib, "wbemuuid.lib")
    
11. CpuIDDisk::CpuIDDisk(void)
    ) k$ w  u3 n8 C# N# V5 O! s
12. {
    2 p% W- P- y+ ^) W! }; _4 U
13.     GetInfomation();
    
14. }
    
15. 
    / r7 P5 `) \" g5 J# P
16. CpuIDDisk::~CpuIDDisk(void)
    # ~5 E9 i- y( |4 h1 d' d
17. {
    
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    & o, d7 \' F( \$ ~
24.     if (FAILED(hres))
    7 ?$ d2 |, D- ]/ \! [+ k' q
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    # N. S6 E5 b0 f% i
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    ! J, v( h" A1 L, S+ V
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    8 ^* i0 K+ k' k( ?* {
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    ' j+ U/ S( ]/ M; V( M6 `
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    9 C; K" a5 b% K3 D
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    & L' J' j1 s+ b: E3 |
40.         );
    6 [/ i% Q4 i; o- U# N8 l
41.                      
    
42.     if (FAILED(hres))
    ' p/ N% P" [4 _3 q( [* ^% d2 _
43.     {
    % ]: ?, B) J9 e. Z; D1 s7 X
44.         CoUninitialize();
    1 J7 {' d$ x0 G
45.         return 1;                    // Program has failed.
    
46.     }
    
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    % v4 B+ t1 H9 q9 i
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    
52.         CLSID_WbemLocator,            
    ! [3 T1 X( h9 u4 g1 y4 q! w# x
53.         0,
    " T% i* ?$ j* a% J+ B5 P
54.         CLSCTX_INPROC_SERVER,
    & N: x- i+ H1 G* q
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    & S# ^  x; v. q
57.     if (FAILED(hres))
    & n1 O' l0 L+ U; \: ]! x' e7 Y2 m/ K
58.     {
    
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    $ @- v1 {2 Y" u) M5 m
61.     }
    
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
      e% r9 i! d) l  @2 }. v
64.     IWbemServices *pSvc = NULL;
    0 n: N8 x$ f" M% l
65.     hres = pLoc->ConnectServer(
    ( A0 Z! ?. y9 x7 h
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    " o6 k. Y7 q% A/ d
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    3 w1 H# E! q' c2 Z+ j$ H3 _: E
72.          0,                       // Context object
    6 }; V8 E  c/ {# t8 Q& [- s
73.          &pSvc                    // pointer to IWbemServices proxy
    1 o6 E! ^3 V4 i1 Z# s1 K; q
74.          );
    6 L, K% C: [0 W2 e# k
75.    
    
76.     if (FAILED(hres))
    
77.     {
    
78.         pLoc->Release();     
    + Z# K) r  E6 s5 [: G& m
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    ; ]9 i; n+ K( ]( Y0 U0 S# V0 N% I
81.     }
    ; `1 t% H1 o" u( R$ {6 G
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    : _/ f- [! k3 o- n! w: l
84.        pSvc,                        // Indicates the proxy to set
    7 N- |9 ]$ H+ v; A  s' l( @
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    % _$ B2 I" `6 o% N! {
87.        NULL,                        // Server principal name
    ( l2 o2 _) C( S' E7 B* H+ c& C
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    7 e8 y+ I. {3 L
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    
92.     );
    
93. 
    5 N  D4 @/ l9 j8 q  I& B. s" U
94.     if (FAILED(hres))
    
95.     {
    $ r0 ?2 g0 A' R4 @4 l9 q& V
96.         pSvc->Release();
    ' `1 z# \$ |% \& E( a' @  g$ o
97.         pLoc->Release();     
    9 P) v1 j! P. G
98.         CoUninitialize();
    " ]. q9 p" K" N+ d  g0 y9 r; @
99.         return 1;
    1 s3 {; g; H% d8 E- a) G; O
100.     }
     / G: C2 j) x$ W, S2 ]. l" A
101. 
     + t3 {& I  r) G9 \1 Y, k; c
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     9 `! _- B0 E% j$ n/ @; t: F
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
     8 _$ \: G- K/ L, N- c1 ~
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     2 W9 H8 g( F6 r0 x! I+ x" Y
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     
110.         &pEnumerator);
     
111.    
     . I( w; v' g6 r# I3 J) W
112.     if (FAILED(hres))
     
113.     {
     
114.         pSvc->Release();
     
115.         pLoc->Release();
     , e# Q, q1 P. H5 W, G0 `$ K
116.         CoUninitialize();
     % T- `. y& |7 F6 d
117.         return 1;
     
118.     }
     0 {: q- F/ b! q# v  P
119.     // 步骤7：Get the data from the query
     5 [4 m4 Q8 S! f1 g, U6 T
120.     IWbemClassObject *pclsObj;
     4 k8 V; {; i5 ^2 z) u9 r& d
121.     ULONG uReturn = 0;
     6 S: ~) h" y' z  ?
122.     while (pEnumerator)
     
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     0 t1 t% U$ A( ]* c5 [
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     
128.         {
     8 j4 {; ~* V9 e2 u( n$ }( u
129.             break;
     
130.         }
     
131.         VARIANT vtProp;
     0 R5 }+ q8 P2 k; `
132.         VariantInit(&vtProp);
     : ~0 I) Q7 J0 V. r: C8 Q
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     $ ?" b& n% {/ g" x4 ^
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     * d/ N& |% L$ \
135.     }
     
136. 
     8 }6 Q- ^5 q- c1 l" X3 w) I8 s
137.     //计算硬盘系列号
     
138.     hres = pSvc->ExecQuery(
     " V" o4 |0 [: }) c
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     & W/ ^! e$ Y6 Y$ X
143.         &pEnumerator);
     
144. 
     % u; R( K  {" \( T
145.     if (FAILED(hres))
     
146.     {
     
147.         pSvc->Release();
     
148.         pLoc->Release();
     . U; h' q+ b' f, n- I
149.         CoUninitialize();
     ' q' T; G& H9 G& o# ]
150.         return 1;
     : B7 m: v* @/ ~5 v
151.     }
     
152.     while (pEnumerator)
     
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     " c' h- w9 \/ H9 p
155.             &pclsObj, &uReturn);
     
156. 
       H3 _: e0 ^& G
157.         if(0 == uReturn)
     
158.         {
     2 R4 I8 c5 Y/ @* a1 ]( r2 [& g4 w, n
159.             break;
     / a8 H* h8 d: v# x0 B
160.         }
     , u* q- V. x( V  T5 V  h$ O3 s3 D
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     + q+ x6 z  E6 H
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     1 J1 q& z0 z0 q! T5 D7 B
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     2 |5 I+ t! L3 X. J" D
166.     }
     
167. 
     
168.     pSvc->Release();
     5 ^4 E- p  \; s, T* ^# P$ S1 l* M
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     
172.     CoUninitialize();
     5 L5 M2 m# `9 X3 `1 d* |% v! L" U
173. 
     5 [4 b: C7 T7 n" W# g6 i/ W6 w
174.     return 0;   
     ' }9 ?$ S) K& U* g7 j1 o
175. }
     

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
+ Y; Q1 K3 ^0 w. w; z
#include <WinIOCtl.h>
#include <stdio.h>
+ a1 C3 g( L0 i) B& p
, I  ~+ z5 L- D4 {& v3 t& v3 M#pragma inline
; I: v4 ]& h+ h- Q1 c( Y7 h. O//---------------------------------------------------------------------------
! n4 ^6 l% E0 u0 g6 a7 |7 w3 ^// IDE NT/2000/XP专用变量
+ @& q, e! E' E+ L7 z$ x$ K#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
: w' S  _  s: x3 V#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设备的命令

& L; C& d+ a. n' H; Nconst int MAX_IDE_DRIVES = 4;

// SCSI专用变量
7 O+ w- t# w6 h8 r2 D* M( q. D# e, s" Bconst DWORD FILE_DEVICE_SCSI             = 0x0000001B;
const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

typedef struct _SRB_IO_CONTROL
{
    ULONG HeaderLength;
    UCHAR Signature[8];
- o0 I; b; `1 w    ULONG Timeout;
3 y6 D6 J& E5 J, S2 J5 ]7 Z: D+ r    ULONG ControlCode;
    ULONG ReturnCode;
    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
; {! R+ z( W8 P5 P* p
// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
; I8 F; }' O& ?. p0 Zvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
7 W6 p% t, j, y' {- J+ g! Z3 `bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
  f9 l0 g1 h, E& Z0 e" G        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
( I8 D$ S) |5 v# i( A+ M! |        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
7 ~2 V" ^) L$ W7 \- l, H9 L, zvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
# v$ k: X, e) K4 |7 o1 y) B{
    switch(Win32Platform)
2 o9 `. g1 ]3 r  t    {
5 Q: A2 k2 @3 q+ ^( z: Z! {' E        case VER_PLATFORM_WIN32_WINDOWS:
1 p) C8 T# F# ^9 R            ReadPhysicalDriveOnW9X(pSerList, pModeList);
, r0 O) r; r7 c$ \            break;
        case VER_PLATFORM_WIN32_NT:
' F2 D4 @- _3 x# T1 \            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
3 k* M0 j3 V! y( j. l7 L        default:
            break;
, w; m) N% K6 r% p: E$ {    }
}
//---------------------------------------------------------------------------
8 O! r& [8 A4 g' E. y0 M9 G- x// ConvertToString
0 @, T! _% H, _% p( d' Cchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
    static char szResBuf[1024];
    int nIndex = 0;
    int nPosition = 0;

    // Each integer has two characters stored in it backwards
- s; m5 Z2 ?- [    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
% J5 r7 V' j7 a6 E& v. z        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;
$ _7 ^" ?8 O5 b$ H
        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
    }

    // End the string
7 V7 r0 T8 |' _- c* Y* N7 v    szResBuf[nPosition] = '\0';

    // Cut off the trailing blanks
8 ]1 Y& u3 F( S    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';

    return szResBuf;
}
' T' [, H* x+ I, O$ l/ s//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
* [# h; }3 ]* O4 b0 D+ {//---------------------------------------------------------------------------
& f3 k  I  K& d% ^  O1 A// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
2 |( i2 h9 t3 r' o: L    {
) I3 S) G$ P  j% r  E        HANDLE hPhysicalDriveIOCTL;
9 J, @, y: T. M        char szDriveName[32];

) F0 q" |2 ^$ {) v9 K        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
, u9 D8 y% f- z9 e5 e& ?5 B- P7 N                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
% J7 t. l2 x4 L' ?: ~6 z% V- i                        OPEN_EXISTING, 0, NULL);

" k$ L6 R% {5 A. Y; v2 ~        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
8 l' V% r- [) y& m        {
' F& y# U( ]' g            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;

  P) V1 ^2 K# x* V4 D            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

, ]0 ]* ^4 R. y& m% h            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
$ X$ m" [7 M" o                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
            {
* S5 ]4 W6 }( U& a3 a                continue;
            }
9 u- u4 W7 i1 S
4 f0 l- e3 V. i+ @# Z2 J            if(gvopVersionParams.bIDEDeviceMap > 0)
( `; e$ ]) h( F) \) @& P2 d9 v            {
  i, Q3 B& e7 ]( J. w& C5 v                // IDE or ATAPI IDENTIFY cmd
                BYTE btIDCmd = 0;
9 J3 {) `% o/ }3 B+ ]                SENDCMDINPARAMS InParams;
& l# E9 K* p  y, N, }6 |. D                // 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
                // 具体所得结果请参考头文件中的说明
+ k+ F, M# s- f3 b) @3 h                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
, V% Y; |/ o, m* u  c2 @                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

" [, d1 O6 D8 S4 k; {                if(DoIdentify(hPhysicalDriveIOCTL,
9 r) S/ G' F) w4 b4 }                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
! Z/ e' w. r. w- K( }& S+ N' _                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
0 m3 [- l7 H- i( {6 J                    char szSerialNumber[21];
3 P1 u: v' ?' w0 K7 k1 E/ b! e1 n% l                    char szModelNumber[41];

                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
4 a% V' ^" N4 y2 V$ t, f" p                    // 取系列号
& w$ T: m# W; E% t                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
9 O( Y( X! F2 c6 R% U  Z( ?                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
$ I0 s/ W" Z( K0 F6 ?2 o                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

$ ~" x5 i! r# G( _3 Q6 E  R# F+ g                    pSerList->Add(szSerialNumber);
( v% T( }! |% a. I                    pModeList->Add(szModelNumber);
1 C9 X1 T- Z2 n- h1 P8 W" F# w                }
! z6 d# N. H0 B- m* A            }
% u9 t! B. B' t* N2 B9 b4 E) X            CloseHandle (hPhysicalDriveIOCTL);
        }
    }
" Q/ J  Y$ f, f8 L& P) V}
+ @# X5 Z1 r. }) w6 ]//---------------------------------------------------------------------------
// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
1 O( T* j$ ^1 h& `0 `0 G2 h5 Q              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
{
" u: M9 m! e( T: O3 E    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
6 p! k) u" U0 R' K9 d1 x    pSCIP->irDriveRegs.bFeaturesReg = 0;
2 l: z! m% Q5 c2 m5 p3 R1 m# ^    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;
+ k8 a- m9 D, L8 w0 {3 O
# z( Y0 M& g5 V, ?9 K' w! z2 S    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

8 O! b& f+ s6 H8 l    // The command can either be IDE identify or ATAPI identify.
# a2 U. O5 P1 N: F$ E$ U: y9 ^    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
6 b6 e9 J. A* ^* U. o1 e
    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
4 b4 W6 Q! D6 |  C           sizeof(SENDCMDINPARAMS) - 1,
# O0 ^5 ]" h1 s% b% o9 r           (LPVOID)pSCOP,
, K* Z2 {; W/ p! a+ P           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
/ P; ?8 a" A2 l" M- p* R5 X( \# H& i}
//---------------------------------------------------------------------------
$ ^* n7 [, R1 B3 Y// Windows 95/98/ME 代码
: c1 h# |; v8 U, O" S//---------------------------------------------------------------------------
8 S; F4 r4 S  c( E( O) I// ReadPhysicalDriveOnW9X
# Q/ X. [7 x6 O9 O7 z7 Y* }void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
+ ^* T, `2 O% d" W& A  @{
. c6 q- s+ g& v5 ?    WORD wOutData[256];
2 j* u2 w' Z' Z3 ]: s    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

1 S4 y  U6 n8 q4 `4 ]; P3 B    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
2 Q" v5 e" `3 g$ `' `. g, Z0 j    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
$ N' j! Y/ a+ h$ @    {
5 _# Q- m9 s' S' p# p4 s2 [        WORD dwBaseAddress;
; E) P8 S- S0 Z# n$ e        BYTE btMasterSlave;         // Master Or Slave
) X2 l9 W# c+ F        bool bIsIDEExist;
! B1 t% S& _) K3 \# P* }; ~        bool IsDiskExist;
+ l9 z# S. V5 Z
7 d, T% @9 f$ b, _- o. n: |/ x        switch(nDrive / 2)
' R0 P. n/ v$ |! B* z' N( N0 ~+ _        {
/ F% r# {: F4 A            case 0: dwBaseAddress = 0x01F0; break;
$ ^0 @# |; e! f            case 1: dwBaseAddress = 0x0170; break;
9 _7 v/ {6 l, C' `9 u            case 2: dwBaseAddress = 0x01E8; break;
1 T8 r/ G* R6 y4 O: x            case 3: dwBaseAddress = 0x0168; break;
        }
' T1 w/ k- d# [
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
/ T# v9 G+ a7 ?+ ]$ m) n& s
        // 进入Ring0
7 b+ q  h( w$ T! h6 }3 ?        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
    }
. h  b, a* A8 f4 o& `4 Y5 C3 B
# G1 o3 a- ^, j) L7 l. ^    // 开始读取
! Q) S! E2 `" w& [) T9 x5 e    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
/ l" M! `5 K8 {3 V' O        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
1 |! ]9 C/ T9 c; U        bool bIsIDEExist;
" l" |% l! \; s. G& k( n: n        bool bIsDiskExist;
        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
1 K8 q) w# _5 q) ]8 o) r+ f            case 1: dwBaseAddress = 0x0170; break;
: g8 e( ^( v) R% w) c" y, m9 v            case 2: dwBaseAddress = 0x01E8; break;
/ `# v# E! c) ?            case 3: dwBaseAddress = 0x0168; break;
        }
$ m$ l+ V: ], ~
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

0 ]1 f! I3 {5 P  {5 i4 G" ^; d        // 进入Ring0
- [, {4 x  I3 l; n5 b        bIsIDEExist  = false;
: M7 a3 O4 q; S        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));

        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
2 f5 d0 Z. f# G% ~) u/ ~9 [& _, D                bIsIDEExist, bIsDiskExist, wOutData);

. i3 l! h. u5 `3 G; [+ [        if(bIsIDEExist && bIsDiskExist)
5 x! o( k: G0 i. g0 g+ `  s; `        {
6 {  [; E  P5 A% q0 Y- R            DWORD dwDiskData[256];
            char  szSerialNumber[21];
4 R) n- Y/ j; h1 K5 W2 h5 N            char  szModelNumber[41];

2 `) P6 {( ]" V0 s' @; P; p- h            for(int k=0; k < 256; k++)
' C, i, _$ \  m3 \                dwDiskData[k] = wOutData[k];
# h7 p) T  C2 @' |' q9 D0 I- q3 w
            // 取系列号
# e3 p/ z% ]6 @5 M+ L            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
0 t  r( ^. C/ u" _. i            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
' D4 o2 s! @2 r) i4 N, K. N+ v! f
            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
/ o7 V  f. F" s5 ^5 S4 i# H        }
" n  l$ w$ C3 I% t0 j( U    }
7 r9 T& c2 g7 q) F$ c2 u) u- Z8 q8 X; Y    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
6 q8 R, D- A/ w  V2 r: \// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
( {5 S- w, D& U8 W//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
" I; f3 v+ N; y+ V3 L4 G4 i  S" \//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
: G( C! q5 v2 y/ g% P6 bvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
! d% t" ^) u5 U' B1 |        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
+ \! P& Q/ M8 e4 z{
! a5 l0 [9 w  n4 R3 H    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
  q: P; \2 M5 ]; p    const int nHookExceptionNo = 5;

. K0 m2 q8 }+ G5 ^0 c9 L    BYTE  btIsIDEExist = 0;
, f  Q, N0 I; ^# `- R& A' w    BYTE  btIsDiskExist = 0;
) k) I& O) o6 ?- x- r  \% g    WORD  wOutDataBuf[256];
3 j) f. Y2 V, w# H0 ~: H1 r
) O; t- ~& H: z    BYTE  btIsFirst = (BYTE)bIsFirst;

    const BYTE btBit00 = 0x01;
2 x# B( R3 q3 u$ \8 x* [! D9 L* w+ g    // const BYTE btBit02 = 0x04;
4 M1 K! S; c! N1 Y4 L, z3 ], ]/ k2 n    const BYTE btBit06 = 0x40;
9 n  R! Z8 r/ s: |. F! q$ N    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
    const BYTE btBusy = btBit07;
9 X1 I/ C& N& [    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;
/ F0 k: m" I) J1 R; R5 y
, n* y) A. m4 E, r6 K3 v2 P9 d    __asm
6 k* ~- Q4 f, @2 e    {
; t9 R4 p8 C6 i( B3 t9 C: S6 F        // 必须先执行这条语句
        JMP EnterRing0
- O% q& E4 `6 x9 ^5 ]7 z3 O
        // 定义过程
        // 等待IDE设备直到其不为忙为止
# p3 f( L( k; A        WaitWhileBusy proc
( v/ n  d+ O! V& }
        MOV  EBX, 100000
        MOV  DX, dwBaseAddress
        ADD  DX, 7
  \% }: e/ T8 `0 d  ]2 S
  N' l6 E* H5 G+ b6 n: z4 P        LoopWhileBusy:

        DEC  EBX
8 k1 e; ~" L# O2 m; S        CMP  EBX, 0
        JZ   Timeout
& v4 o0 b6 H/ b* y) {: @5 R        in   AL, DX
9 u" k4 q% F3 z9 c, {+ Z        TEST AL, btBusy
        JNZ  LoopWhileBusy
( v; k- E3 O& W        JMP  DriveReady

        // 超时，直接退出
        Timeout:
        JMP  LeaveRing0
        DriveReady:
        RET
* w" C1 C' M5 J" o7 T$ b' C        ENDP   // End of WaitWhileBusy Procedure
1 z: S% U0 @7 w6 ~9 \
7 f/ [6 s" \5 _( i' T3 g9 I        // 设置主盘和从盘标志
$ f" a! `7 q& y* o: [* D$ ?- `! E        SelectDevice proc
, c' {* G% W9 L+ G* w( |
0 g3 o  F; i$ C  }        MOV  DX, dwBaseAddress
6 o5 l1 h9 D4 |( |" g/ l& [        ADD  DX, 6
        MOV  AL, btMasterSlave
. ~( ]0 T! E$ S" k1 }' t
        out  DX, AL
- l* s& `9 S( A& f3 R9 V; N        RET
4 p/ T7 i3 u% A# [
) D0 ~0 q5 |6 B* _/ Q        ENDP  // End of SelectDevice Procedure
- v& H/ i/ g# n) B
        // 向IDE设备发送存取指令
        SendCmd proc
. t* b$ g. ]/ ^! W
        MOV DX, dwBaseAddress
        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
7 }* ]9 y1 o# T$ k        out DX, AL
        RET
6 s8 T$ w5 k9 b4 D% y3 |        ENDP  // End of SendCmd Procedure
7 c  M8 t+ y+ f5 Z& h5 d" E5 _
! D* Y* v' Q  t3 g' B; w+ J        // Ring0代码
- r- T2 [8 }2 N" r        Ring0Proc:
. o* J) T$ i0 p  P* `+ |+ z        PUSHAD
% W% _' `( `% y        // 查询IDE设备是否存在
; B  g% e: M" G        MOV DX, dwBaseAddress
        ADD DX, 7
        in  AL,DX

5 T! L" Z- D$ a# _, h        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
) r: ?3 Z) a. S. G' j; o- k; W        CMP AL,0xFF
        JZ  LeaveRing0
* ?  |6 k) ~& U+ k# G: K        CMP AL, 0x7F
/ ?3 g" o* Z' x+ j* R  v        JZ  LeaveRing0
0 t% `/ x% Q! ^' a. `
, ~/ d2 F- u: |! Q# N        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1

# q: H0 o( L3 b* K/ Q& b        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
        CALL SelectDevice
4 y0 ?6 n4 ]: E# F
        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
# v) R  L2 Y' r4 x. k& Y/ }8 @, j        CMP  btIsFirst, 1
        JZ   LeaveRing0

        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy
/ G. k! F% ]3 Y  ^* o3 r+ x
( t( h; K1 {4 ^( `( s1 Y        // AL的值等于cBit06时，不存在驱动器，直接返回
- q1 s/ @; L0 O. F( @2 Y9 a        TEST AL, btBit06
        JZ   LeaveRing0

        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1
2 x2 k$ a5 B4 K+ A% t
        // 发送存取端口命令
) V8 A* k) l/ S        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
$ ]8 w+ W! }- r9 }) u( p$ j( F        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
1 W2 v! |" b# A3 R& p        CALL SendCmd
        CALL WaitWhileBusy

        // 检查是否出错
- z* _: ^' J0 N, W+ N% c* T        MOV  DX, dwBaseAddress
3 n+ a& t* Q- V7 \1 B, d        ADD  DX, 7

        in   AL, DX

/ j( p& _  [9 n6 K4 ^6 p        TEST AL, btBit00
$ |2 C) U, p; z        JZ   RetrieveInfo   // 没有错误时则读数据
  d8 n$ c9 @( x: F8 I
- }( L5 A8 f) j) w  o9 D& \        // 如果出错，则进一步尝试使用ATAPI设备命令
/ N+ x2 y7 a+ Y+ @' |6 |        CALL WaitWhileBusy
        CALL SelectDevice
        MOV  BL, btAtapiCmd
        CALL SendCmd
* @/ b: J) P" G$ T* U        CALL WaitWhileBusy
' q  R9 z# f) L# ~
        // 检查是否还出错
        MOV  DX, dwBaseAddress
) S" T. r4 n! o# r0 F' N        ADD  DX, 7
        in   AL, DX
; R7 ^3 G4 V( G1 w5 G) h        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回

$ B6 f/ ^! w$ E6 f/ h2 y        // 读取数据
& R! K2 b1 D9 Q7 q, ]        RetrieveInfo:

6 g% h- C$ g6 r" T! @8 _6 t' k# x        LEA  EDI, wOutDataBuf
$ I2 J, m! x! r2 O        MOV  ECX, 256
        MOV  DX, dwBaseAddress
        CLD

6 A  L1 T$ ~0 @7 e/ e$ n" c2 n0 ?! q        REP  INSW

5 g- T0 {. T, X1 _% @2 Y        // 退出Ring0代码
# B4 S$ E9 y: q, j        LeaveRing0:

- K2 `+ v" ]8 v        POPAD
        IRETD
& }; H5 D  |8 J# d" {; V- d. N
- R& M! \  R+ i2 ?0 W        // 激活Ring0代码
        EnterRing0:
9 S4 ^7 R3 x1 p, U3 {* |6 i- D4 `
" U, |8 M  i7 w/ D# c        // 修改中断门
        SIDT FWORD PTR btIDTR1
& Q3 t# [$ t# ~4 Z9 U  z        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI

        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX

6 X3 R. _$ e; N/ Q9 y* b, z; v        // 指定新入口
        LEA EBX, Ring0Proc
  y# A" w8 q5 I2 L+ f4 u) ?" U        MOV WORD PTR [EAX-04h],BX
$ I) {- t2 h% ]2 j& Z7 U; y        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX
) X. k0 m" m" B4 x- t7 _+ G- A0 s  G* n
        // 激活Ring0代码
& {' K- k1 B! s. b- ]( q4 n& q* g        INT nHookExceptionNo

        // 复原入口
        MOV ECX,dwOldExceptionHook
% Q+ ]/ z( l: R3 `) j* n        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
' O7 N2 B8 ?! M) W5 c        MOV WORD PTR[EAX+02h], CX
        STI
    }
    if(!bIsFirst)
  ]* P! j5 F" O! `9 D    {
        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
. `, A% q4 b. y& c0 A    }
}
( j2 L8 m6 @5 r5 t3 U/ o& k5 b4 f//---------------------------------------------------------------------------
% [, r) f0 o- U' W// 调用方法：
9 e- a6 A7 b' h* H% `% gvoid __fastcall TForm1::Button1Click(TObject *Sender)
{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}
, c5 k, q5 w$ @  k- D2 x8 O