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

天云上人

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

1. 
   
2. #include "StdAfx.h"
   " `" q$ n# F2 @7 f! H" J2 K
3. #include ".\puiddisk.h"
   1 q' I( [, D: V( G8 k5 L
4. #define _WIN32_DCOM
   
5. #include <iostream>
   
6. using namespace std;
   7 h/ l9 ^/ c" A/ ^, }, q8 z" ~
7. #include <comdef.h>
   
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    
11. CpuIDDisk::CpuIDDisk(void)
    * A; X$ J( s, n! X* _  U  t5 j+ k
12. {
    
13.     GetInfomation();
    6 Z# V4 r, ~; W
14. }
    + ^( n3 U7 g. x+ D
15. 
    6 S; b4 r! V; A( w5 z0 ^
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    + b  i% w3 B1 l- Y" m, {
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    0 j% z  @, j) p7 ^. q+ b5 w. |; A7 Z1 G
20. {
    2 Z0 O6 Q2 N% M6 v, ~5 O; j
21.     HRESULT hres;
    
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    
25.     {
    1 e5 [# Y4 B' A3 W$ t0 s; a
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    / o% Y9 p. B4 }, I4 O
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    & p6 v" F4 p6 B, K% v  i! u: B& Y, e) q" C# m
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    
40.         );
    0 g( z  |/ ?% b" H% o6 B4 v" U
41.                      
      I/ L9 b- j- Z7 G2 G0 e
42.     if (FAILED(hres))
    0 V% K& ~, V- M. l& P% [: M* X
43.     {
    
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    
46.     }
    " ?0 o0 g9 Q% I* L; E  c% Q
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    # ~% ~- v/ m# v: b/ I( C" t
51.     hres = CoCreateInstance(
    
52.         CLSID_WbemLocator,            
    ! n0 f" u8 T& R+ B9 p( l5 _4 |
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    ' l) }2 D+ h( s; z% U! h
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    
57.     if (FAILED(hres))
      b) A( h7 R) w3 e# ^
58.     {
    ' @$ ~, p- H4 v/ Q- q) E& Q- t
59.         CoUninitialize();
    ) R/ y+ _# K" B6 ?! E7 y
60.         return 1;//Failed to create IWbemLocator object
    7 y* G5 }3 \) X6 ]' b+ k* Z" M- ?
61.     }
    
62. 
    % x1 @2 s, @$ N  N0 j) N2 N7 ?
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
      |8 V' J" \* @9 a/ v
65.     hres = pLoc->ConnectServer(
    4 y6 d9 Q4 d9 e6 l
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    5 R& c7 m$ ?' Z% m3 x/ }
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    
75.    
    % G. u* W& `8 V, p! i( g# a  I4 m6 R
76.     if (FAILED(hres))
    
77.     {
    
78.         pLoc->Release();     
    + B7 V& u0 {3 I# P6 C
79.         CoUninitialize();
    8 Y3 n0 I: v+ J* k! f
80.         return 1;                // Program has failed.
    8 w5 ?3 x3 \0 {: D8 s1 v
81.     }
    & X) E) ?0 ~3 I) O1 O* P: A
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    ; k. {, i+ t( `0 @+ ^
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
    ( ~4 _& @( v( j1 n0 R* A
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    9 w7 V& ^) T) K
90.        NULL,                        // client identity
    ) ~. k$ |$ k2 h; K" B) _
91.        EOAC_NONE                    // proxy capabilities
    2 o5 s7 k, p; m! ?3 m
92.     );
    
93. 
    / w5 t4 E" C0 U6 `+ ]
94.     if (FAILED(hres))
    
95.     {
    # f6 u2 H$ J! J/ n
96.         pSvc->Release();
    
97.         pLoc->Release();     
    
98.         CoUninitialize();
    5 |# M+ _+ m# O* o3 x
99.         return 1;
    + [9 h/ ^' i1 ]/ m) M
100.     }
     
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     8 Q, a- ^& D* p: J* m* i+ s
104.     //计算CPUID
     6 @4 x" f7 k" [9 n$ a) _
105.     hres = pSvc->ExecQuery(
     $ {& @& J: x, a) _# h
106.         bstr_t("WQL"),
     ! ~( s0 o4 y+ T) A2 I
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     % o1 |- E( M( G5 t6 d% v
109.         NULL,
     
110.         &pEnumerator);
     , t; c+ N. Z5 B; N4 i& D
111.    
     
112.     if (FAILED(hres))
     " e6 l$ T/ [4 x* ~. G
113.     {
     
114.         pSvc->Release();
     
115.         pLoc->Release();
     9 P/ z% V7 ^; V8 I
116.         CoUninitialize();
     - W2 z3 V0 Q) R: I8 C- D8 N
117.         return 1;
     : ^# j+ t$ b1 O* ]& x/ V- |+ D
118.     }
     ! b' Z0 R/ M- D) G: h9 s
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     ! ^- _" T/ D. {
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     
123.     {
     . e! d  G4 Z! j7 h) d$ u
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     / t3 ^0 T* i1 |; O( f
126. 
     
127.         if(0 == uReturn)
     
128.         {
     
129.             break;
     8 p+ A: T/ P5 E' s4 j
130.         }
     6 {8 S- d: Z! f" T6 Q
131.         VARIANT vtProp;
     % p1 H& j& E' Q. p$ _3 p+ |
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     - v: }/ ?4 z/ e( l
135.     }
     9 h+ d# ?. f" Z
136. 
     
137.     //计算硬盘系列号
     " O) a$ s+ E% J) M% f. G6 M# E. D, b
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     ) s& P8 Z: _/ M, Z/ A0 B
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
       @/ _, j" l# f
143.         &pEnumerator);
       @/ U1 _2 A& j% M3 U  @
144. 
     - ~; g: Z) [4 O8 y$ z# V
145.     if (FAILED(hres))
     
146.     {
     
147.         pSvc->Release();
     
148.         pLoc->Release();
     - N! K2 m* }7 I: E! s2 U& I
149.         CoUninitialize();
     
150.         return 1;
     ' q2 |1 R2 L; @( L3 E% S- k
151.     }
     
152.     while (pEnumerator)
     * @& h4 ~8 A' R" ]7 `$ D) q; ?2 t
153.     {
     $ ?8 V% n# s/ H- _
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     7 P  S. Z) ?7 A. q- L5 X( i
155.             &pclsObj, &uReturn);
     ; m2 u* X* w$ Z
156. 
     
157.         if(0 == uReturn)
     
158.         {
     6 r( q& ~  Z6 G1 Z( v9 d& F
159.             break;
     9 g' A3 r7 C" A
160.         }
     ' z' L- C" i6 e, T
161. 
     : W6 F& A# m# v
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     ! ^. T$ c; U, i
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     + z3 Z8 z& l* Z4 A3 o
172.     CoUninitialize();
     
173. 
     + B  F7 O% y7 E" J3 b! @+ Y
174.     return 0;   
     
175. }
     

复制代码

天云上人

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

. c: L+ P. I% b3 B#include <WinIOCtl.h>
#include <stdio.h>
. T$ v' H* m7 d1 k
  h- D1 q3 N7 I% q6 D  \0 g#pragma inline
//---------------------------------------------------------------------------
( Q# L  {5 W0 |$ ^# T5 o. b- |// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
#define DFP_GET_VERSION         SMART_GET_VERSION
* W1 x$ h' ]$ A! ?( k- L8 H! _( R#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
4 @5 j* P! W9 X+ g#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
3 u2 u* Y" y/ f. M( t; W
const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
9 {! C* s7 L( nconst WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
" r- g) y) W- K8 C2 c
const int MAX_IDE_DRIVES = 4;
. y  c# @( |; t
1 V: J8 d- C6 s0 w- q0 x" R// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
* F, K- c2 l+ F* u! Oconst 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
  F* w8 K$ E4 {! [9 j! L8 V! \{
6 H& h, Q- w) N" a, g6 h8 e' I) S/ c( e    ULONG HeaderLength;
    UCHAR Signature[8];
    ULONG Timeout;
    ULONG ControlCode;
9 M- f* Y( |+ I5 k) N    ULONG ReturnCode;
# a' ]) T% i8 L! A+ ?" y* H    ULONG Length;
  i" Q% ?! A/ i( G5 [}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
% f$ o1 x* t- u% |- O9 C1 l
// 读取的主函数
2 }3 U; G% I7 q7 Y2 zvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
/ G$ d. e5 n+ y+ I* {
// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
# l! h' Z$ C0 D// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
) `) I! A0 b$ {0 T6 abool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
7 m4 I- f7 P& Q# G: ]2 A// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

; v# Z6 _2 `( e' V+ `# ]# N// SCSI读取函数(for NT/2000/XP)
  t* J. n8 o' y3 S  F- G' `, }' mString __fastcall ReadIDEDriveAsScsiDriveOnNT();
9 ^4 N6 q4 ]) G! W5 E. J8 Q! X. ~$ |//---------------------------------------------------------------------------
// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
    switch(Win32Platform)
& |' e; K2 F" z    {
6 k+ T# ~- o% {+ g& Y3 q: f        case VER_PLATFORM_WIN32_WINDOWS:
            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
0 t6 _3 n3 o& D. K* ~) S: \! c        case VER_PLATFORM_WIN32_NT:
( d( t2 w0 L: s. d- [% Q8 N+ q            ReadPhysicalDriveOnNT(pSerList, pModeList);
* a0 L# N; _: L9 L; S            break;
        default:
- q' l/ s; L% O% X# l( O            break;
" s' f8 d* n+ E+ j# V+ z) D    }
}
//---------------------------------------------------------------------------
3 w( `7 I) }! A// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
6 s. W* s( Y3 q    static char szResBuf[1024];
    int nIndex = 0;
    int nPosition = 0;

8 J) B9 b1 N$ l9 F    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
( i/ V, i2 K( m4 a    {
        // Get high BYTE for 1st character
2 C' }# j# V% K. H$ s        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
: |5 G+ d, u  F  ~0 V1 e        nPosition++;
+ K& C% |+ g* j1 @& @1 t+ D
3 h. V' c! n; }        // Get low BYTE for 2nd character
$ U# v: z& O( E' R* Y, @3 H        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
    }
% `# s. n) b2 e) b
& J# p: \. f2 M: `9 Y    // End the string
. H  n" E% k/ |- p6 z+ F    szResBuf[nPosition] = '\0';
2 A* x8 o. V% ?0 E* A' b  b
    // Cut off the trailing blanks
    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';

! W! ?2 J  A7 N8 ]5 p4 m    return szResBuf;
}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
5 h3 B( ^  S. f  m8 J//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
$ {- ~, a' v% i+ N) u5 Q6 {3 M6 Ovoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
    // 输出参数
0 }9 T% j/ E+ Y) a0 H+ N! O    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
/ Q$ {% w5 k# f9 R
$ K. H/ A8 ?, G+ h& U% k    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
$ h# W+ [- W9 Z! M+ i        char szDriveName[32];

        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
4 h- z/ E  K$ ^2 v4 X% S7 C        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);
9 W7 [& t+ [2 u
        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
4 H9 e8 W* S  j3 b. {) G" J        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;
8 ^& V7 N7 I5 z* e
  o4 I0 b: e3 `- G6 {6 U            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
3 `. `; V$ S$ }+ |8 A2 ?2 W0 T
            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
% S$ P/ }7 }' o5 U$ r' `" W                    &dwBytesReturned, NULL))
1 E, e% C6 ^# u            {
2 Z7 T7 P- d( C, m2 k/ C% n( _                continue;
            }
7 W, i+ N5 z- f, j
            if(gvopVersionParams.bIDEDeviceMap > 0)
; v3 |* I' j0 g) ]0 {            {
                // IDE or ATAPI IDENTIFY cmd
5 `6 A' G+ c- e( q                BYTE btIDCmd = 0;
                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
                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
" g$ h$ {/ B  o9 `! [" i3 C                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
: F2 r$ ^) t( g$ {! D% U                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
4 B* F5 Q: a" d5 ~) g                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
1 l1 q6 Z  P" {, Y, h1 g1 P; W                    DWORD dwDiskData[256];
( C7 x$ ^+ z/ n$ ?, W                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
2 L: y. N' ]8 [, d7 f. I1 g+ j, K                    char szSerialNumber[21];
! u0 q4 l1 [- `7 R9 |                    char szModelNumber[41];

' S! c6 M" J/ W$ E3 u! C* C                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
/ T) Z2 E) Q" H7 Q; ^                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
! Q1 T* D1 G4 E3 x  \                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
0 U/ b5 ?( d' o, i9 T' q- }                }
            }
            CloseHandle (hPhysicalDriveIOCTL);
( J) o3 Y% p2 _6 _4 I7 m$ p        }
7 F5 O2 q) R( ?1 c" U( k    }
}
//---------------------------------------------------------------------------
// DoIdentify
7 Q5 x1 ?# q& lbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
+ X/ d# D# r+ N2 h              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
{
0 s. ]$ w2 G; I8 o6 g    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
# k+ R6 u) R, }0 X2 Y    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
% h0 |  a; h5 O# h3 d+ K6 B    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;
- l& f$ ]$ S$ c9 H  J6 H. N
" z' R+ R$ b- }  }; `6 ]    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
. s  ~! P% B% y) M$ V' S    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
9 D  M! n& ~$ [# F  i# I
$ L: c  g" T- e( O% R8 _# O    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
- g4 Y- b0 W5 }  ^    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
6 j3 X. e5 r* O, V
/ n% V2 P: M; c4 ~    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
( U  }( Q# ~. x' I2 ?$ K+ `0 C8 q' M  O9 q           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
3 q6 ]5 ?6 @7 Y# K3 m2 K2 M1 Kvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
1 ?3 v) l0 i% Z; a0 x$ _{
4 I& t) p7 z3 \, l5 K    WORD wOutData[256];
    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

5 x- Z+ |7 |% y& H& ^8 R    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
+ V8 C7 [+ [& {0 Q    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
) n$ Q9 S( S+ b0 ]# }- U8 o    // 避免蓝屏的出现。（期待高人能指出原因）
& B2 L: A4 }+ R! K$ I: C7 ^: f    for(int nDrive = 0; nDrive < 8; nDrive++)
* ]' H1 K& L8 p    {
( N' A* v' j9 P8 e8 e: E( ]        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
* L7 m4 v/ |8 d: D; n7 M        bool IsDiskExist;

        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
4 s$ R0 L, w) c            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
6 q* e' y* ?2 i8 }' m3 B            case 3: dwBaseAddress = 0x0168; break;
        }

        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
1 Q! W8 J0 J8 ^" `
        // 进入Ring0
8 S; {+ L: S: J1 b  ~# ^( B" Y        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
/ u) r5 v4 M% u                bIsIDEExist, IsDiskExist, wOutData);
. t5 f+ \# b% D5 f3 _* E    }

2 h2 X( [2 z7 i5 C% E3 z    // 开始读取
    for(int nDrive = 0; nDrive < 8; nDrive++)
, m0 c9 L+ W- }" {7 N    {
        WORD dwBaseAddress;
* X- a+ i" M! e: P        BYTE btMasterSlave;         // Master Or Slave
/ g; S! W5 s5 _, b1 J! k: t        bool bIsIDEExist;
3 n6 ~0 I7 V; i) s" O        bool bIsDiskExist;
1 ~- V! Z. d' M        switch(nDrive / 2)
7 j0 w! T$ u( G3 I+ L1 t* N0 I        {
. k! N: |, n1 e' n& T9 P" z            case 0: dwBaseAddress = 0x01F0; break;
) w" M& K1 n% a            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }
. D4 R0 {1 J/ O4 E* f8 h% C
  @% |& U6 A* _        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

7 c. i9 d' x' n5 R3 Q0 P        // 进入Ring0
        bIsIDEExist  = false;
4 e4 z1 w( u$ J/ a0 A        bIsDiskExist = false;
9 y& \3 w# U2 z7 T" E+ m& t        ZeroMemory(wOutData, sizeof(wOutData));
+ A1 m; G# s0 b5 y0 x
* P" D  M" I" m& D$ y1 N        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

/ B( H, W$ L* Z7 ^2 X- A; N        if(bIsIDEExist && bIsDiskExist)
        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
  S* t" k% q3 {* e: V            char  szModelNumber[41];

            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];
0 \4 A5 h6 g4 `, \1 k0 o2 G, r
6 z1 V' t% z2 t' R+ b            // 取系列号
& P; @+ ?. N& T9 a* i            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
6 k/ X  {" Q  [0 }! X( k
/ F2 k% E2 M$ Z/ ?+ Y, O/ S$ ]            // 取模型号
( A2 q: g1 [0 T' `+ I) W7 ~( M, S            ZeroMemory(szModelNumber, sizeof(szModelNumber));
( Z, b/ t. x9 j            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
2 p. j( o9 u) }; @, n& `
5 k3 `* B4 u, E6 O5 x            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
! z9 ~3 x2 L! w$ m: |7 x8 Y        }
5 }" ?7 j; ?( F0 y0 j& }    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
2 g0 G; t* Q; G" j6 R}
; @$ q( q0 }; u. A//---------------------------------------------------------------------------
+ |0 m" y/ b6 X/ X// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
* J7 l" _8 v# l* M: x0 [  I. L// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
0 h; \; c- C' @  y& _$ T//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
' `/ D7 R# a. d0 ]* \3 @; u//
" y7 m0 t4 q) F# V" k// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
* H& s$ V! y# z7 f// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
5 Q- {: l1 w9 B' i6 ]/ M, |{
7 P, H- S% c8 y5 u    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;
6 D+ P6 e- G: a& N% U6 W
    BYTE  btIsIDEExist = 0;
+ u- c1 Q/ ^4 [  {    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;
- K6 G, \3 a7 I6 w  g% ^$ p
    const BYTE btBit00 = 0x01;
+ \! x# t. J7 l+ }7 k    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
+ H1 K" }6 p4 K9 g  h    // const BYTE btERR  = btBit00;
5 R4 o; H9 G& g+ Z3 \    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
  \0 k, n; B  c' j+ b! Y% m# x    const BYTE btAtapiCmd = 0xA1;

    __asm
  [9 H! ^! a6 S    {
        // 必须先执行这条语句
        JMP EnterRing0
6 j; K, L6 ]- R# A& I4 ]6 ]/ ~
7 w. U9 w$ f% u0 B1 p4 ?        // 定义过程
        // 等待IDE设备直到其不为忙为止
2 w4 g7 N7 W6 D  d8 `8 j        WaitWhileBusy proc

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

        LoopWhileBusy:

9 ~* r3 O% l( F        DEC  EBX
        CMP  EBX, 0
        JZ   Timeout
$ d- a* \0 D9 k$ o4 ?        in   AL, DX
* W, {7 C" G5 u  s        TEST AL, btBusy
        JNZ  LoopWhileBusy
        JMP  DriveReady
- C' w4 b: E8 ~, ^9 D4 g
        // 超时，直接退出
        Timeout:
$ `$ c/ Y# c9 A2 p5 u' C        JMP  LeaveRing0
        DriveReady:
+ [7 ?* j& h2 t2 t* r* a        RET
/ C- R& u; v1 d6 Q; L, @: N8 E) ^        ENDP   // End of WaitWhileBusy Procedure

9 ^8 l6 L5 y, b. h7 _        // 设置主盘和从盘标志
        SelectDevice proc

5 v2 E: C, d% N" N& p4 j        MOV  DX, dwBaseAddress
        ADD  DX, 6
        MOV  AL, btMasterSlave
2 D, j2 i  v: `9 {, i; U5 j, w/ G4 ?
+ }; @$ x1 A! r6 D) R9 h        out  DX, AL
4 u& m2 z8 I- O. c8 w        RET
# J1 N2 r2 |# s4 H$ `
        ENDP  // End of SelectDevice Procedure

" _7 W( ?7 N; d        // 向IDE设备发送存取指令
  t2 q3 I) s. I! b3 V        SendCmd proc
% k# Z- s/ v; G* l8 N
. E8 C( e+ o' {& Y- R8 h9 W* x, r        MOV DX, dwBaseAddress
! @  \. [, O) ?/ [2 N        ADD DX, 7
* m7 N9 o4 f* K2 Q        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
        RET
        ENDP  // End of SendCmd Procedure
! l  V, Q6 i/ A. W' B1 K
        // Ring0代码
* v0 O2 E/ c  L6 P        Ring0Proc:
$ c$ @$ [0 o  b        PUSHAD
" w8 G' P7 c8 [        // 查询IDE设备是否存在
        MOV DX, dwBaseAddress
9 Z. K* }3 l) T. {        ADD DX, 7
        in  AL,DX

7 ]! F- r5 }* k: Z9 z( h: a        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
3 i3 d* k8 P- A7 a: }0 _3 Z        CMP AL,0xFF
- V3 x: X$ o9 w2 Z. A        JZ  LeaveRing0
# x) y# F/ w# u  ]9 J        CMP AL, 0x7F
        JZ  LeaveRing0
& R: b, i) v' C7 \/ \' N
5 o1 H; w: H/ N' s) e        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1
4 c5 L" n& i  z3 n
        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
5 m. b7 D: R# I9 Q9 p: t        CALL SelectDevice
, ~( R4 W2 o5 `0 t
        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
        JZ   LeaveRing0
; m6 i$ ~$ @; U/ x+ g
        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy

        // AL的值等于cBit06时，不存在驱动器，直接返回
% n0 Y" O" |9 s        TEST AL, btBit06
        JZ   LeaveRing0
: y; h4 L0 n( ~4 ?6 d" E# N' d6 k
        // 设置驱动器存在标志
+ X2 W9 I( Z5 @* o3 K        MOV  btIsDiskExist, 1
- M% s0 |5 T4 O! R4 r' b
        // 发送存取端口命令
& _* Q  T  G  s7 f; u; T. F7 O- T5 f        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
5 o6 i0 e% M  J  t8 P0 ~        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
, E( q: x* `* E+ x        CALL SendCmd
( p$ L; P0 X, n        CALL WaitWhileBusy

        // 检查是否出错
        MOV  DX, dwBaseAddress
# C) G3 m4 E! \1 G5 w+ P6 t' T        ADD  DX, 7

        in   AL, DX
* ^! P1 U3 t( B3 _
1 s6 O& ~3 M4 O, G( L& H4 i# d        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice
( d: M5 ]2 ^; i0 m% {  W# l        MOV  BL, btAtapiCmd
        CALL SendCmd
        CALL WaitWhileBusy

        // 检查是否还出错
        MOV  DX, dwBaseAddress
' ~* ?! q: c% K5 G$ t% V        ADD  DX, 7
, j4 ^# J4 ^2 [        in   AL, DX
9 s- X6 S0 t+ ?3 m, w/ }        TEST AL, btBit00
( w. S% r: A' v9 f1 M2 E! d        JZ   RetrieveInfo   // 没有错误时则读数据
. l0 `8 @5 V5 Z) V        JMP  LeaveRing0     // 如果还是出错，直接返回
  r$ W! x4 u7 h9 `1 i: |
        // 读取数据
        RetrieveInfo:
$ J9 v$ T( A( y& M
        LEA  EDI, wOutDataBuf
3 x9 J/ U$ m+ H1 }& B5 N/ r, B# i8 U        MOV  ECX, 256
        MOV  DX, dwBaseAddress
$ r7 h5 W" V" l; p) e$ [$ a        CLD
1 A5 l$ ?1 |$ j3 G( t% W0 Y$ ?
# B6 y6 T( C2 j/ c* |        REP  INSW
% t& K5 P2 ^) W9 i* \" y( }
$ Q7 l: L. _$ z  [  T        // 退出Ring0代码
        LeaveRing0:
+ O5 v$ b6 r) V3 k  H+ W9 F5 q; n% f2 o
9 i4 L* `; G: X$ b5 v        POPAD
4 D4 _: i5 h' h        IRETD
: F% s8 T7 y+ l0 a: g
        // 激活Ring0代码
) r. }0 @* l: G- B! J        EnterRing0:

  {3 U6 W4 Q9 ]# z        // 修改中断门
+ E+ d1 R- g! z+ ?4 s+ w        SIDT FWORD PTR btIDTR1
3 Z$ [+ {' g8 x& g4 _        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI
( M: z" q% @9 o" e8 W6 z' k
* ]4 }$ j* H( i* H1 O" p8 o$ }! `        // 保存原异常处理例程入口
        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX

        // 指定新入口
7 s( J9 u4 s0 G3 ^6 S$ {; Z% V        LEA EBX, Ring0Proc
: Q; Z  d# `- d4 L) Y        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
% a4 M: X2 G; k' }% P" {        MOV WORD PTR[EAX+02h], BX
6 s' t7 T6 X! ~7 e. f# z
: R, f. m0 r1 [9 b0 [' y2 H6 {) p        // 激活Ring0代码
0 M; s2 s" M. J& `        INT nHookExceptionNo

% Q2 ?. ^3 h6 Y1 V3 U7 f) o        // 复原入口
        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
/ |+ J6 U1 H3 q7 \        MOV WORD PTR[EAX+02h], CX
9 F; ^4 _6 _* X        STI
    }
) `/ _' y; J8 `    if(!bIsFirst)
    {
        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
) Y) H# _" _& m: \& x. F$ _}
% }; R* |& c) a& E& Y* m//---------------------------------------------------------------------------
5 v) A# w# l1 b' D! ?' @- G// 调用方法：
6 f( J, Y% E0 b7 i$ @! o. M! O6 Tvoid __fastcall TForm1::Button1Click(TObject *Sender)
# u7 z9 l% T! \1 @{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
: }) Q9 i2 o; h! y0 n8 m}
1 A, y4 A! _" r