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

天云上人

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

1. 
   & ^; p1 j: n  ^7 c# u
2. #include "StdAfx.h"
   . y" J$ I6 i7 X/ Z) K7 Q
3. #include ".\puiddisk.h"
   " G2 u' X1 F  C3 I. w8 c
4. #define _WIN32_DCOM
   
5. #include <iostream>
   8 U% [4 p) g) U0 ]: e
6. using namespace std;
   
7. #include <comdef.h>
     x2 @6 w. ~7 I+ h5 b
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    4 r& p) K4 J: F% b' ?3 Z0 U, ^
11. CpuIDDisk::CpuIDDisk(void)
    5 M( |5 g4 s1 _" d( g
12. {
    + ?8 T7 R. {! {/ i
13.     GetInfomation();
    ; T) k! }& X: M$ y& i
14. }
    . ~$ F* h( H6 a" g% s# w
15. 
    ! t1 L" D* S! U# u1 g  `# u/ A: j
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    
18. }
    ; {9 D9 X) a4 e) H* W" M' L( Z
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    0 ]; R$ b- n5 _/ j
21.     HRESULT hres;
    9 T" k! K6 r) i' U
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    : l" W$ d0 ]& r8 a! L$ g' ~: B1 b) n
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    
25.     {
    ; V$ n$ R  B8 m( M
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    
30.     hres =  CoInitializeSecurity(
    
31.         NULL,
    
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    8 ~9 m  c+ ]# u% O- x( D" Q7 y
34.         NULL,                        // Reserved
    ) h1 O9 D7 V& D3 v  C  U* m8 P2 z
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    # T, ~3 v4 ?! @- o( `# Q9 m' \
37.         NULL,                        // Authentication info
    ) k& t. m; F4 d  z  W6 f2 W
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    
40.         );
    
41.                      
    ) r" s/ R0 h- `
42.     if (FAILED(hres))
    7 J# g: v" A. `  I
43.     {
    
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    
46.     }
    
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
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);
    ) I* ^/ ^1 X* A
56. 
    7 H4 Y: }& l" ]' _; l1 |& F
57.     if (FAILED(hres))
    $ o$ \4 k% I4 g+ Z' [
58.     {
    0 i/ e* ?/ o8 j. Y- \9 m5 ~! A* }
59.         CoUninitialize();
    - r' W3 s5 O1 o4 F$ J, G7 n
60.         return 1;//Failed to create IWbemLocator object
    $ @1 H+ l2 r! |4 D8 }
61.     }
    4 H" e% ~& l' Z
62. 
    $ J6 N& l2 Q/ ~( @# X
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    0 n( B% o; v8 O, J4 j
64.     IWbemServices *pSvc = NULL;
      E' b) ~2 M5 v8 L) U
65.     hres = pLoc->ConnectServer(
    5 P  g/ W6 g7 l0 @: c- C$ U7 e! {4 O
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    6 A) K% q0 Q0 A% P; M3 f5 n" |9 L" l
68.          NULL,                    // User password. NULL = current
    
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    2 T& D: _, p6 a  }
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    3 R- T8 \  ]8 b$ C* w
75.    
    
76.     if (FAILED(hres))
    
77.     {
    
78.         pLoc->Release();     
    , G0 H' b: C& l/ H0 N7 I$ d
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    
81.     }
    8 a/ n9 V8 ]0 ]) [
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    
84.        pSvc,                        // Indicates the proxy to set
    * E2 h, s$ f' w! V  m4 p
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
    - L* {+ H( ^2 X4 @( U! _2 a
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    / I  I) k6 j+ v2 ~6 S) M( G% X
92.     );
    
93. 
    
94.     if (FAILED(hres))
    4 J8 r" k+ M' d& V2 _' t  f
95.     {
    
96.         pSvc->Release();
    
97.         pLoc->Release();     
    : y2 c8 e8 u6 k) K2 \
98.         CoUninitialize();
    ' S% }/ Z7 [+ d8 c5 O  y
99.         return 1;
    ( E. d* [* d$ D3 ?
100.     }
     ( V3 N& m9 Z9 f4 I5 J% ~/ p3 n
101. 
     
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     2 N6 w  H' l, \- h; W& F
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     : ]) R+ d9 ?( L2 V6 x
109.         NULL,
     
110.         &pEnumerator);
     + n# b7 B2 r9 `3 V3 \/ z
111.    
     
112.     if (FAILED(hres))
     ; N/ r' W8 a6 X
113.     {
     
114.         pSvc->Release();
     / O3 b. q  P. M3 _6 R  \* |/ x/ g& g
115.         pLoc->Release();
     , S$ ?4 U9 `/ I& Q2 r: o# K
116.         CoUninitialize();
     
117.         return 1;
     " r5 ~1 |% |- a( H" V4 k
118.     }
     
119.     // 步骤7：Get the data from the query
     2 q" r4 [  |4 l+ Y
120.     IWbemClassObject *pclsObj;
     / R" G0 ]6 u+ x5 i
121.     ULONG uReturn = 0;
     ) o2 I/ c2 G8 H* s5 D; n3 [
122.     while (pEnumerator)
     
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     
126. 
     
127.         if(0 == uReturn)
     & W: u- K' |+ J- D
128.         {
     , I/ \2 x8 T$ N+ _3 x7 K2 Z+ X/ W& E
129.             break;
     
130.         }
     
131.         VARIANT vtProp;
     0 C: R% c/ N/ W' ^5 ]$ I
132.         VariantInit(&vtProp);
     ! s6 `  f7 m4 f6 Y
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     % L- D+ D' D( m1 I  G
135.     }
     
136. 
       R2 @9 r, |5 |# S1 E9 D
137.     //计算硬盘系列号
     ! ^. J9 p' _. |7 d: R  F3 d
138.     hres = pSvc->ExecQuery(
     : z4 M. v. W7 r) y5 j; Y/ K9 m
139.         bstr_t("WQL"),
     * @. {5 w2 `; O% `
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     3 G9 w, _" X2 K
142.         NULL,
     
143.         &pEnumerator);
     & p" R: Y0 A6 F" x' W6 G
144. 
     
145.     if (FAILED(hres))
     
146.     {
     # v* a7 ~7 l5 r% F  a! W
147.         pSvc->Release();
     2 ?! X& T3 q8 G7 e& W, x! d
148.         pLoc->Release();
     4 Z# O" o$ e% m+ q& b9 Z
149.         CoUninitialize();
     
150.         return 1;
     
151.     }
     
152.     while (pEnumerator)
     . f# c3 V. D! I8 }7 p: {
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     0 g- |! f0 F# r9 ~: b+ H
155.             &pclsObj, &uReturn);
     % h  ^# J& S' i, P7 @" ?# \+ ?7 _
156. 
     $ ^/ O" [2 E! z/ e! A
157.         if(0 == uReturn)
     + h. ^: [: {6 s
158.         {
     
159.             break;
     
160.         }
     0 v" n; M. P6 m" i$ \2 t
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     4 ]7 E7 Q. ^% F7 C# t0 `' S
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     ! ^) l: D! M4 U' v
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     ( i: `( `6 L; M7 t! l2 w; r
166.     }
     2 Y  M# j3 S4 S6 C2 `
167. 
     
168.     pSvc->Release();
     . i, K% w+ J9 @) p( K
169.     pLoc->Release();
     
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     ! d& E  Y! _1 i- r8 H  ?# N0 q
172.     CoUninitialize();
     
173. 
     / s" F: r5 r7 L' R
174.     return 0;   
     
175. }
     

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
1 C9 M% f$ U5 p6 W8 W- U
#include <WinIOCtl.h>
#include <stdio.h>
  c% q. t& b: Z5 T) Z1 f
1 G1 J$ e! f9 [/ p3 t+ @7 `#pragma inline
6 f: C8 o/ [8 b" u+ \3 {1 @  R//---------------------------------------------------------------------------
+ f7 r, h7 p6 w; [+ o7 m) A1 m// IDE NT/2000/XP专用变量
4 W# \! _$ ~5 @& i' U' j  D* z' u  _#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设备的命令
5 G1 s) y5 K4 F/ P8 b3 H7 Aconst WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
  K4 A3 r$ K) X  h2 S; Q7 \% z5 e
const int MAX_IDE_DRIVES = 4;
7 p) b) ], g! j# \' {$ m6 Y
- t. q1 n$ `' C$ c// SCSI专用变量
! U7 c) L5 R: V3 ?' ^5 C8 k' Rconst DWORD FILE_DEVICE_SCSI             = 0x0000001B;
const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
0 e0 i% b& K2 l4 bconst DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
/ ~' K) y9 t7 e& a8 z' _
typedef struct _SRB_IO_CONTROL
9 ^  g  p! r- R; b! Z! Y4 q{
5 C5 {4 K' U) T    ULONG HeaderLength;
    UCHAR Signature[8];
1 C1 b: ?* j5 ]6 o" X5 h    ULONG Timeout;
    ULONG ControlCode;
    ULONG ReturnCode;
2 E/ n$ [/ _% W& V5 ]7 _    ULONG Length;
. j" o! C# x# C0 p2 U$ _5 o. c0 j7 W}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
! Y: ~6 Q* y6 N. Y# a2 R8 K; i
// 读取的主函数
* O' T0 f% L" N* }void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
5 R8 t7 Q: Q: t( A! M$ h- D3 q
// 辅助函数
5 g: X: C2 e9 E3 P* Rchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
& i- \! ^7 m/ _1 y4 o/ Z) T2 Lvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
' G8 D$ S' Y) V  S6 G5 v
// SCSI读取函数(for NT/2000/XP)
$ _+ ~3 @$ b" j3 u/ ?String __fastcall ReadIDEDriveAsScsiDriveOnNT();
9 K* e- N4 e$ }//---------------------------------------------------------------------------
* u0 a# U4 o' {7 W; ^7 C// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
! e4 }7 u0 O5 t- N$ X    switch(Win32Platform)
$ ?- F/ r$ E$ e) w2 F# f0 k; |    {
; x" c1 X4 l. I" |4 b8 ?        case VER_PLATFORM_WIN32_WINDOWS:
            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
% c7 V" s' S. I7 H2 F            break;
        default:
3 w. b; `1 I3 S# w+ i/ v9 m. ~            break;
    }
}
" g* n, p( @+ v+ N* w. [5 [//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
    static char szResBuf[1024];
    int nIndex = 0;
0 B3 C, D8 H* j% F    int nPosition = 0;

    // Each integer has two characters stored in it backwards
0 d) R7 a  l/ y  o    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
' Q# O5 A0 F, N8 E0 L        nPosition++;
: w) t7 L& W$ v3 j, R( w$ K
        // Get low BYTE for 2nd character
( B* N) @$ H/ e+ {& T) F, l        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
2 k+ O6 }2 w1 [. O( S8 f        nPosition++;
    }
0 a' g- Z% `1 e9 x! L
8 Y9 h: [# H; C# `6 @' z, N    // End the string
3 j6 F1 a) |! W+ b7 j/ H! M    szResBuf[nPosition] = '\0';
, g) ?2 @0 |  ?8 Q
    // Cut off the trailing blanks
! l* A* M+ K5 H    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';
/ A9 f- `9 Q" f
    return szResBuf;
: ?; Z* z2 j- r* z& r}
//---------------------------------------------------------------------------
* T7 l$ q+ l* W& J- a& @7 J4 `// Winndows NT4/2000/XP 代码
( }2 M+ V! i% c- K/ s! Q//---------------------------------------------------------------------------
4 A0 q7 f+ I( q! @1 `/ S// ReadPhysicalDriveOnNT
* F" ^2 b* }$ C* kvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
) b* o+ _( V. [: N{
    // 输出参数
- m3 a1 F  }4 z/ R2 m# u    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

3 k1 o3 U2 J/ v5 v- d  ~    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];

. |! S2 K( W% x- g4 j3 h8 ^* y3 E! o2 X! |        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
                        GENERIC_READ | GENERIC_WRITE,
' g5 ~7 v6 j" U  D, B5 A" L4 g                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);

! N5 A- O" D& R9 t  m        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
            DWORD dwBytesReturned = 0;
0 J; U* f+ m) l            GETVERSIONOUTPARAMS gvopVersionParams;

! L* e+ A8 K; @* A3 }& j$ D6 z" C            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
% y, M% S4 h* @4 s/ a& T( y            {
# ~. U4 v) [- g/ n. r                continue;
3 W7 Z$ j/ _6 Y+ K            }
! U$ S8 R4 L+ _% F
            if(gvopVersionParams.bIDEDeviceMap > 0)
% y! ^/ a2 e; m: l$ Y  m( U            {
  u9 D) P# y9 K' b% m: ]                // IDE or ATAPI IDENTIFY cmd
* V+ d9 f4 w3 {' F9 f  \" Z                BYTE btIDCmd = 0;
+ p* z- E' o2 Z- n, X- d                SENDCMDINPARAMS InParams;
& }7 V6 k% g0 c6 _. ^" C                // 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) ?
  m) h7 x. ]9 P7 a, P                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
1 Y4 L! g& O% r6 Q: C* F$ B/ g% t9 j) Z                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
# b3 A, M4 g  `. J                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

3 V5 h! f( ]$ {# r) A8 j  ]                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
! ?3 w- R, @; L+ F  B' a/ N                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
5 b3 U5 A5 Z% V: B) _8 `                {
) F" w3 m" I( b, @+ }                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
/ @( j* J6 x3 f                    char szSerialNumber[21];
                    char szModelNumber[41];
. Q8 x3 `# N9 A+ o8 y: E) `
                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
$ Q! Z7 W+ E" `1 x4 _8 D                    // 取系列号
5 W+ [  R% E3 \5 S2 `                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
8 r  M8 b; u, d5 v/ V" b. q9 _                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
  A: T  w# D' D+ O; l. @, i
1 {5 |* R/ ?- o! u& r" B                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
% e* j5 Z9 _7 j% b& ~  S% k; f  @5 u                }
            }
6 J$ J7 X/ M+ j7 A* x4 x7 l/ }            CloseHandle (hPhysicalDriveIOCTL);
7 d( u. o% [/ _. }" o9 u  T) R        }
    }
2 K' ]6 C' b& q}
//---------------------------------------------------------------------------
// DoIdentify
! i. u  a8 e. H  I' |) n! @bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
) [: s7 b5 Z8 |& K              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
{
    // Set up data structures for IDENTIFY command.
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
9 Q* T4 m9 N$ b( f! l; `  }8 {# E; a    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

1 \5 y2 [. n2 s+ |! H    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

% X) n" o0 u. Z* ~    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
7 e& L) b% m4 V, ]* J$ t. u$ {  L
9 X$ J. n5 z) `2 c  D    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
$ A5 @9 X& k" n3 i6 S; A           (LPVOID)pSCOP,
* c+ C6 z( o, k4 {           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
4 a" ?0 Z# D  {+ a( |+ ?. K           pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
  \% A4 E  \: V6 l1 @9 R; L// ReadPhysicalDriveOnW9X
4 Q# M/ S% A# Y( dvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
( F' k; N- `4 D{
' q+ a9 |' y5 x  R- G& v    WORD wOutData[256];
    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
  [& u% m1 O4 J    // 避免蓝屏的出现。（期待高人能指出原因）
. p, P& [. q5 Y  M( i3 [1 P0 a4 s* V    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
( K# A) F/ k8 I: {- z7 g        WORD dwBaseAddress;
; C$ ^( T# _* _& U! Q        BYTE btMasterSlave;         // Master Or Slave
/ a8 q% \3 I# R; @* q" ]        bool bIsIDEExist;
        bool IsDiskExist;
; J3 Q; g$ u* K  A
* h2 }1 A: {5 A/ ?0 g+ l5 @4 {        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
/ Y$ |! o4 m5 h% o- ^2 w# J            case 3: dwBaseAddress = 0x0168; break;
0 E# K9 B: D8 _  I- z  P, K% W        }
% n3 _- a3 M: z4 N4 }3 v
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
% Y; f* j# T: p' A4 t3 _; b
+ c3 k3 E) ?! j4 i7 W4 ^        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
    }
2 f0 v. \; e! J/ N7 `  q
    // 开始读取
    for(int nDrive = 0; nDrive < 8; nDrive++)
; p: h1 |; e: @# F9 {+ @6 n    {
        WORD dwBaseAddress;
- J; z- B) u1 t4 B  O# O        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
2 k% |0 q$ x* r$ V# i8 U6 k        bool bIsDiskExist;
        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }
+ a3 x1 M4 V% f/ ~% q
: v% W: `; G" m, ~) R" l+ a        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

        // 进入Ring0
: P8 B" m$ B/ j8 p        bIsIDEExist  = false;
3 q. X# I7 {" ^/ ?6 @& Z' b+ ^        bIsDiskExist = false;
) \: P/ C) J9 c( R( r        ZeroMemory(wOutData, sizeof(wOutData));
7 j$ z5 O# q% o) l
        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
8 v- G  K& F; Q5 ?; N4 g0 K                bIsIDEExist, bIsDiskExist, wOutData);

        if(bIsIDEExist && bIsDiskExist)
' U! f+ l  C/ z% Z: o: p, M        {
            DWORD dwDiskData[256];
6 ]6 A) J8 }' Q; r5 z( Q            char  szSerialNumber[21];
            char  szModelNumber[41];
- x, Q9 G9 i" x* ?" K
7 p+ h  p3 F: q' @% |            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];
9 m' E2 d  w6 g9 |' M+ c1 {
- y3 z2 ?- @! K1 C2 V            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
/ X3 d3 Q, f7 f8 o+ S            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

            // 取模型号
: e" e0 O' O" Z6 v- o            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
) |7 _. g* a, Y/ l, t
            pSerList->Add(szSerialNumber);
% r( t) \1 w9 t( ]% a& I& t            pModeList->Add(szModelNumber);
6 j9 e0 i% i) g5 H  X" b* g5 V4 U        }
    }
; r# t& k' q0 l, {/ c    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
+ i3 ~) B9 b# X0 m! z: U}
# x  T2 n9 ^; n//---------------------------------------------------------------------------
7 F- h0 W  C9 w/ I8 C8 O6 _- j// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
! y  g  L! B! a0 q) n/ J//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
( n7 `) {6 M: L/ F% L" z// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
- O  _" c+ q, p& L8 H    BYTE  btIDTR1[6];
    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;

$ h) o; K2 h8 {* Q    BYTE  btIsIDEExist = 0;
    BYTE  btIsDiskExist = 0;
    WORD  wOutDataBuf[256];

    BYTE  btIsFirst = (BYTE)bIsFirst;

% Y5 j" w' {+ b% j  X3 X$ ]2 v) V    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
+ x0 U4 B, b4 g; q% h' O5 X( x    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
$ }7 b0 o* D; n; J, h1 Q" ]8 W6 |    // const BYTE btERR  = btBit00;
- |" G7 L" {. _; h; r    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
  o& ~8 p1 ?$ W0 f0 M7 B    const BYTE btAtapiCmd = 0xA1;
: M" W% j! v: |5 G# ?6 P
    __asm
7 L$ Z# B3 \$ c7 \% Y# Q7 |    {
        // 必须先执行这条语句
# L/ y: Y# f5 H* W' g        JMP EnterRing0

        // 定义过程
        // 等待IDE设备直到其不为忙为止
7 O& d. k: E  d, J9 t8 `# C, H        WaitWhileBusy proc

: h/ ~8 D$ y5 e5 z1 b: e        MOV  EBX, 100000
& k9 u- M, L: m: x5 k4 n5 h. D; ?        MOV  DX, dwBaseAddress
        ADD  DX, 7

9 m' M# `* m- J9 h        LoopWhileBusy:
/ @' F# y/ _1 p. M0 ^: Z2 q
        DEC  EBX
        CMP  EBX, 0
        JZ   Timeout
        in   AL, DX
        TEST AL, btBusy
        JNZ  LoopWhileBusy
        JMP  DriveReady
6 Q3 p5 S0 @9 G5 N, A2 v$ f
        // 超时，直接退出
        Timeout:
        JMP  LeaveRing0
5 W, H; @' v' [4 j) i  G: E        DriveReady:
        RET
        ENDP   // End of WaitWhileBusy Procedure
3 U( S  R' j3 G- q
        // 设置主盘和从盘标志
9 l' H3 ?6 L4 C( B' q1 Q0 O; `# W        SelectDevice proc
; G% A" K, X6 H8 T6 Q" j
        MOV  DX, dwBaseAddress
        ADD  DX, 6
        MOV  AL, btMasterSlave

        out  DX, AL
        RET

        ENDP  // End of SelectDevice Procedure
' q2 ^4 T" e1 ^! j0 H6 y3 ~; x. }
6 i: q+ s3 W3 {$ a        // 向IDE设备发送存取指令
        SendCmd proc
: p. z5 l: M% S3 t) j) V
        MOV DX, dwBaseAddress
* q; o' l: \7 X# R6 G2 L        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
        RET
9 K$ O( o1 R/ o3 X4 {" Q* q5 _        ENDP  // End of SendCmd Procedure

        // Ring0代码
$ R2 a% }) _- |) o( C6 o        Ring0Proc:
6 T$ g' P3 G* j- X! V        PUSHAD
        // 查询IDE设备是否存在
9 |' f* O/ D. W9 m" s; _        MOV DX, dwBaseAddress
        ADD DX, 7
        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
+ d) U6 T$ L6 _& L) A! l; w8 @        JZ  LeaveRing0
        CMP AL, 0x7F
        JZ  LeaveRing0
0 \! c1 o1 p/ Q. ^& r! J2 M5 V
        // 设置IDE设备存在标志
6 G0 v# ?' Y1 B- I; l% u7 B        MOV btIsIDEExist, 1

        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
1 z$ h( `  |: R+ Z: ]        CALL WaitWhileBusy
6 [2 Z. F! P# i5 X' a* L7 V% j        CALL SelectDevice
+ d1 p# e$ H  x+ [+ t  s
4 h9 O$ v6 v5 J5 I+ S        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
        CMP  btIsFirst, 1
        JZ   LeaveRing0
$ g0 H* V/ a. u$ k7 H7 I$ o
        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
: H" q8 ]* \6 c' e; J7 s5 Y$ ]        CALL WaitWhileBusy

$ K5 r9 L/ h( U1 y+ e* P: m9 l        // AL的值等于cBit06时，不存在驱动器，直接返回
8 A4 x- T7 U% \" O; W  U6 E9 c5 ^        TEST AL, btBit06
        JZ   LeaveRing0
; i/ }; l# @# Z; i  Q2 ?
        // 设置驱动器存在标志
3 _8 N  E5 c5 t  \6 g        MOV  btIsDiskExist, 1
) t! v  ]: ?" p2 g9 a
        // 发送存取端口命令
. ~5 m' R; O9 U2 b' d4 t        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
( j- n1 P) O* ~+ p) D0 V2 _7 K: b5 C        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
" D+ J# V( p9 i  L, G9 k& `3 ^: Y        CALL SelectDevice    // 设置主从盘标识
4 J3 P. W0 t- {- H& ]        MOV  BL, btAtaCmd      // 发送读取命令
! R1 x+ n8 g: T/ |: A" |2 X        CALL SendCmd
        CALL WaitWhileBusy

$ C6 x- @% y. y6 H        // 检查是否出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
& a6 ?! g% e, l9 ^+ {3 \
        in   AL, DX

+ {, s% x8 a/ h. J' o        TEST AL, btBit00
- l$ V4 ]7 [  p: l% |& R/ q5 q        JZ   RetrieveInfo   // 没有错误时则读数据
; {) e4 d2 G! M' Y5 q8 z
        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
$ u8 w6 H, ~; b+ D1 [7 D        CALL SelectDevice
- C0 w: f( K5 d# H        MOV  BL, btAtapiCmd
% t/ E' q: L- G" u        CALL SendCmd
        CALL WaitWhileBusy
6 u# x" ~$ Q, F# ]" j5 ?* i
        // 检查是否还出错
        MOV  DX, dwBaseAddress
, l1 U& I/ l- z/ O  S8 @        ADD  DX, 7
% R% W$ ?* _; J) R5 O+ V$ t8 I        in   AL, DX
4 s$ v( A: W. e$ p+ O$ t        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
* V+ S6 u- g* r1 H, d6 G6 H+ \        JMP  LeaveRing0     // 如果还是出错，直接返回

( W) ]5 l1 Z" d# i, i        // 读取数据
) L, c. e& b- ?2 i        RetrieveInfo:
+ [  C. }! \6 p" T1 a& ]6 q
2 n6 F/ M7 x4 @( p        LEA  EDI, wOutDataBuf
6 S+ P8 H0 E- \  l& w& z5 I        MOV  ECX, 256
        MOV  DX, dwBaseAddress
3 t5 [7 W7 \3 V/ j        CLD
2 q. J* R8 V4 h+ \* W
5 `( s3 G& p& }. K- P        REP  INSW

        // 退出Ring0代码
2 a; F6 X0 b8 w' u        LeaveRing0:

        POPAD
        IRETD

( @0 C: [* d; H1 }  P/ L; f        // 激活Ring0代码
1 {! b2 F) V, \: T        EnterRing0:
) S, ?/ ~! t& ^+ [% G4 P1 f0 t6 B0 t% F
  f5 G4 ~& D% ~: Z        // 修改中断门
+ K! G& p5 d/ B, ~6 r1 R        SIDT FWORD PTR btIDTR1
  D6 w! O* k: }, E        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI
  j; Y* H7 q( P9 _+ G
        // 保存原异常处理例程入口
4 T- y6 d' [4 W" l+ G5 M  |        MOV ECX, DWORD PTR [EAX]
, O4 h9 {/ V+ Q/ J        MOV CX, WORD PTR [EAX-04h]
6 I* d9 {: g+ r  y1 B        MOV dwOldExceptionHook, ECX
. Z, j6 q9 Y6 O4 ~* p* Y
        // 指定新入口
9 {/ Y3 h/ J9 M* {: D        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
% F8 D, l; y& i, B        SHR EBX, 10h
8 s5 W) D+ m  E1 Y        MOV WORD PTR[EAX+02h], BX
* \9 _5 M# `7 s9 Y
        // 激活Ring0代码
        INT nHookExceptionNo
5 ~5 O& ~0 p5 v* q
, A+ z/ f2 |2 a7 T        // 复原入口
        MOV ECX,dwOldExceptionHook
$ q* O" U; |5 J, g        MOV WORD PTR[EAX-04h], CX
0 t1 f/ |+ a. D" m2 j6 J7 T        SHR ECX,10h
4 p7 s" m: O0 f. v        MOV WORD PTR[EAX+02h], CX
        STI
# f% R7 A, I* i6 W; |    }
    if(!bIsFirst)
. P4 w# i- u* D, h    {
2 A8 z3 ?3 `5 H3 Y        bIsIDEExist  = (bool)btIsIDEExist;
" A3 N5 d* |9 P0 `: {        bIsDiskExist = (bool)btIsDiskExist;
/ ~: U6 @2 h. g1 m        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
/ b7 d7 K# z  R/ t" Y4 c    }
}
//---------------------------------------------------------------------------
// 调用方法：
# l4 a" w  N& }- rvoid __fastcall TForm1::Button1Click(TObject *Sender)
{
& v9 Y; B( C$ N9 @# a2 e3 H    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
9 w. y' v* s% ?' R( B# A& _0 Z}