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

天云上人

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

1. 
   
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
   
5. #include <iostream>
   * m  S% B  j1 h3 ~; U( Z/ I
6. using namespace std;
   
7. #include <comdef.h>
   9 ~/ [& X3 v2 D. D* @+ _
8. #include <Wbemidl.h>
   
9. 
   / E. C: u  ^6 a9 n6 m
10. # pragma comment(lib, "wbemuuid.lib")
    , v# q" Q% g. h/ N
11. CpuIDDisk::CpuIDDisk(void)
    . e( H  W7 r$ l
12. {
    8 |" \5 C- y2 @- b2 G" h
13.     GetInfomation();
    * m7 e0 W, ~  g7 Y9 f* h- ]! \
14. }
    ! J5 T2 E9 @- y
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    " b% T. l+ n2 K, f
17. {
    : G% ]; m, s5 |7 L
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    4 g- T1 S: g7 y" R
21.     HRESULT hres;
    3 h2 Z* x! l/ d5 A# H
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    1 Z! e3 b; L) \
24.     if (FAILED(hres))
    . P, F6 y: h& S0 s. [, l
25.     {
    : }, b0 p7 e6 A- _: I3 X( s
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    5 L& S" K& s0 [% P, X8 x2 I" J
29.     //Set general COM security levels
    " f4 J! ~6 T0 L/ g6 O& u
30.     hres =  CoInitializeSecurity(
    $ b) L/ A! p# o, |* ~& j
31.         NULL,
    
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
    4 w* b. k7 y, v) d9 N* j
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    3 H: d2 i! M- K% g1 ~2 d) q
40.         );
    
41.                      
    3 G6 p, m2 E6 d* i. A* ?* t
42.     if (FAILED(hres))
    
43.     {
    * H3 m7 Z8 f: M4 _
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    
46.     }
    ! [+ L( E$ r, `$ C  }$ {* o! x
47.    
    6 W$ P. u% y( t" x
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    / F0 x! j9 s6 f0 _6 }" K
50.     IWbemLocator *pLoc = NULL;
    4 I# k! x0 d# J6 d) ]) k
51.     hres = CoCreateInstance(
    + f) V& Z; O& {8 K
52.         CLSID_WbemLocator,            
    6 C$ m: J1 h; w4 z+ c6 x% T9 d  W
53.         0,
    
54.         CLSCTX_INPROC_SERVER,
    / q( v# p% r  P# P' w# h7 M; T$ ?
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    % y: z, B4 h6 W+ Y. S9 D6 |9 \+ b
57.     if (FAILED(hres))
    * A* \3 e: U3 j& w; y6 J
58.     {
    
59.         CoUninitialize();
      g! k9 H4 V7 |$ r0 L0 S
60.         return 1;//Failed to create IWbemLocator object
    4 o  m- A& J9 D# z* K+ r
61.     }
    
62. 
    0 {# C4 E* J7 C
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    3 s8 _8 _* j. o5 Z% Z
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    # |) N+ m% O6 a  `, N( B
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    
68.          NULL,                    // User password. NULL = current
    ; b; k. H  G! o6 @
69.          0,                       // Locale. NULL indicates current
    7 u: D! e, j  l4 d
70.          NULL,                    // Security flags.
    
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    
73.          &pSvc                    // pointer to IWbemServices proxy
    : ]8 L+ ^+ t: E6 ~9 K1 n1 P# c
74.          );
    
75.    
    # {7 u  u, U) o! F
76.     if (FAILED(hres))
    
77.     {
    1 B. q1 [& g' \% F4 E
78.         pLoc->Release();     
    
79.         CoUninitialize();
    7 q, c/ K$ u/ X/ F3 d
80.         return 1;                // Program has failed.
    
81.     }
    
82.     // 步骤5： Set security levels on the proxy
    
83.     hres = CoSetProxyBlanket(
    
84.        pSvc,                        // Indicates the proxy to set
    
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    : w: |+ Q: N- A' t$ z9 @6 W
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
    - n: ]: V8 Q+ h& Z8 z3 c7 e
90.        NULL,                        // client identity
    2 k: _( b3 J( n' s
91.        EOAC_NONE                    // proxy capabilities
    7 k) ~2 t) A0 L  O, G3 T
92.     );
    
93. 
    & y# ~  p0 T. a! G0 ?) I
94.     if (FAILED(hres))
    
95.     {
    ) G& z) v6 p, w, ]9 @3 J; M
96.         pSvc->Release();
    6 a+ p9 K! C) R. a8 D# }. T
97.         pLoc->Release();     
    & m5 k: D8 r" B. @& d7 T& f) Z
98.         CoUninitialize();
    % m( ]2 }& X5 }: P
99.         return 1;
    - Z3 H3 Y4 c) r3 @5 F# f7 l! I
100.     }
     1 G5 q7 k& m' H( m! c0 I0 x
101. 
       h2 \  G1 @: S" L8 V' k
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
     8 D( V2 K0 W$ b4 v
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     
110.         &pEnumerator);
     7 `+ y/ e; `( c# R& H
111.    
     + P! f  |/ R4 n; K
112.     if (FAILED(hres))
     
113.     {
     
114.         pSvc->Release();
     
115.         pLoc->Release();
     % z, `8 {  p1 n! _* ^3 |
116.         CoUninitialize();
     " ?% ^2 t0 H8 _: I- \8 G& e1 j
117.         return 1;
     . S) B: N4 U/ w1 x/ b
118.     }
     # b1 G$ q: e5 m1 n# G
119.     // 步骤7：Get the data from the query
     1 A/ d3 ^0 G) h5 f8 R- ?* o) i
120.     IWbemClassObject *pclsObj;
     8 \- u9 n8 N% m1 U
121.     ULONG uReturn = 0;
     . X! E: T: B! q: z  x
122.     while (pEnumerator)
     , h' w/ S5 U" Y% t5 x! ~5 ?. }
123.     {
     
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     . v1 M! s# C0 O' `8 c: ]
125.             &pclsObj, &uReturn);
     1 F* O" n# B7 l+ l- U
126. 
     
127.         if(0 == uReturn)
     + N& H! p3 G: Q& S' s8 e. T/ y
128.         {
     % c  I- c% ]; u) T& K
129.             break;
     
130.         }
     ! I8 c% N; |$ c+ k
131.         VARIANT vtProp;
     
132.         VariantInit(&vtProp);
     8 Q1 E/ w: Q+ ?  t- E, E
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
       @, N. k# f- n
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     " k7 O' w' F% J2 |# h" d% m: s0 Y
136. 
     2 P0 [' I1 y3 H* n6 l# O1 B. N
137.     //计算硬盘系列号
     
138.     hres = pSvc->ExecQuery(
     ( R4 |' @3 c% _9 o' v. z6 w& i; |" B
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     ) n, K/ t) b& e8 e& F8 U
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
       p1 B1 C- A; N
142.         NULL,
     
143.         &pEnumerator);
     : h  c6 w- [% R5 O$ j
144. 
     $ f( a/ r$ X$ k
145.     if (FAILED(hres))
     # m0 w4 d5 i8 O; L
146.     {
     . l  M7 q$ r% U+ c
147.         pSvc->Release();
     
148.         pLoc->Release();
     : K+ g/ N) m/ W3 _0 n9 |  D6 R
149.         CoUninitialize();
     / D6 F) r4 X+ x8 ~$ q9 C8 k: E5 ^3 m
150.         return 1;
     . |7 K2 C& Y& M* y1 w& }% Q! E' V
151.     }
     
152.     while (pEnumerator)
     
153.     {
     9 o/ Y. y; U+ K: o, J8 r
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     * ~0 J2 O; K) E5 y, i6 g
155.             &pclsObj, &uReturn);
     
156. 
     
157.         if(0 == uReturn)
     
158.         {
     - W% R# E. b7 }# m) Q
159.             break;
     
160.         }
     ' x5 B& G& @5 v4 g2 X9 `
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     - Q/ {0 ]: {3 t8 j0 r
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     
167. 
     ! N# v  Y* l4 O7 |2 j
168.     pSvc->Release();
     
169.     pLoc->Release();
     8 r4 `; a1 P; G7 q# }, V
170.     pEnumerator->Release();
     . A$ ~' v) }/ H/ n, [. S
171.     pclsObj->Release();
     
172.     CoUninitialize();
     
173. 
     0 [$ ~( `5 ~% F8 F0 ]* N
174.     return 0;   
     
175. }
     ; i2 `: h0 |2 C* k

复制代码

天云上人

本文代码经ccrun(老妖)在Win2k下试验成功.
" T! e  \) N4 i
#include <WinIOCtl.h>
( L9 B: _1 L  M: s) q, a1 D( J#include <stdio.h>
  |' S% f# K3 |* u4 N3 ^- h
#pragma inline
//---------------------------------------------------------------------------
8 [* D* r, o: w! K// IDE NT/2000/XP专用变量
/ _4 _3 Z$ o5 ]5 Y! q3 K2 F( G; e" G( }#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
9 F' F5 @/ Z- o1 p/ t( w8 M0 K* W- V! g#define DFP_GET_VERSION         SMART_GET_VERSION
0 B! |: P6 o; O& G7 Z- {' K#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

8 V' C) \7 u) k& U8 V" Gconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
. d- U$ |, y+ G, Q! i1 B
- E3 ]' O+ ]/ `const int MAX_IDE_DRIVES = 4;

2 [9 a& K+ P/ ~( t0 U# ^// SCSI专用变量
. h$ |9 X* J( i; Q% nconst 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;
7 B7 h# G, M) m6 p! i
typedef struct _SRB_IO_CONTROL
{
    ULONG HeaderLength;
9 V- [+ C0 [1 O4 _    UCHAR Signature[8];
    ULONG Timeout;
2 c) |, A9 u; I3 q7 [    ULONG ControlCode;
" n3 ?3 f, V7 V3 K1 b( r% I: Y$ z    ULONG ReturnCode;
    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

+ [" J9 W# M3 G  {# v( C// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
; T! S! @: t6 A2 r, o
* e1 M% f' f2 F+ k2 y4 d8 n$ J& e// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
+ p* o  r' ?: |+ O// NT/2000/XP函数
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
/ p' D! J. ^' e! N  W3 Rbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
# \, }7 i5 Y' [8 X& i) e7 I( |        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
) W+ D. a8 ?2 {0 x* zvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
( q% z7 n7 Q/ e' ~5 E) G        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

! t  k) a2 l/ F+ G+ l6 p" \7 z// SCSI读取函数(for NT/2000/XP)
  @: Q) g# S! O6 bString __fastcall ReadIDEDriveAsScsiDriveOnNT();
. _/ L( X9 U/ Y' d) d# h6 Z//---------------------------------------------------------------------------
$ |' m3 W+ d* P  ~* A4 V5 S8 P// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
2 ]6 f- Q0 B9 P  C0 K0 f/ l{
    switch(Win32Platform)
: o4 L+ Z: A4 h: h    {
, M: A/ k: q* n        case VER_PLATFORM_WIN32_WINDOWS:
6 [7 y* D1 Q, M& A) C' u" o            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
  Z# o$ C3 Y5 [        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
        default:
, a- v5 a8 E/ x, b$ A8 s$ _            break;
2 J" k: v, k) ?' i4 v    }
}
# J/ |7 x# C. b6 [( O//---------------------------------------------------------------------------
/ j# s6 H; q8 V& Q4 o5 Y// ConvertToString
$ n* R2 L  [( f: ]% d; ]7 e$ ochar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
4 j! G1 J: b% F* ^6 _$ s, i{
    static char szResBuf[1024];
    int nIndex = 0;
3 ^+ r! Z& u# x* p    int nPosition = 0;

    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
8 V* d+ N* G9 T. a    {
        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
        nPosition++;

! Q9 {1 w3 y( a; z: P. p        // Get low BYTE for 2nd character
. \2 E1 T) q$ p  z3 M        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
        nPosition++;
0 z, c: \3 X" i& ~; K0 Q    }

    // End the string
6 u9 n7 _9 @  P8 m6 k    szResBuf[nPosition] = '\0';

! b% h9 _: }& N( R' R% Y/ ?! i    // Cut off the trailing blanks
4 Q$ _5 ^% N' R8 h    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';
9 v' S8 m3 Z5 V% X
- V3 H* t" W. L' ?    return szResBuf;
- X  W2 C" ?4 k8 q, ~}
//---------------------------------------------------------------------------
) f2 J. K* B/ i, S- H* i+ c  y, d" b* W// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
: Q! {9 \* k  t6 e// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
. C# b9 D$ W( |$ y7 V, z{
5 u, ]0 A% b. A/ x' K0 z8 v4 ~+ D    // 输出参数
    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
& j1 V4 R$ b1 O$ ~! G
    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];
+ e6 V- ?# j+ p2 W. j) y
        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
. L( Y2 r# Q. c0 c2 a5 ~, Q                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
: _% l) e& x8 _" N8 d9 Y* w                        OPEN_EXISTING, 0, NULL);

        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
: s/ }! ~/ h7 w0 j  k) o        {
            DWORD dwBytesReturned = 0;
            GETVERSIONOUTPARAMS gvopVersionParams;
- V3 N% O: l: }4 `% ?- g
            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
9 ~' l- |3 I9 ]* f
5 k5 H' G) A$ K: L7 e" l9 @$ |7 F/ c            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
  h) L( e1 G! P: I0 J                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
, U/ s1 \  B: q" A                    &dwBytesReturned, NULL))
            {
                continue;
" M7 _, w8 ~9 @            }
3 Q  R$ g! _4 y$ v- y" r
            if(gvopVersionParams.bIDEDeviceMap > 0)
            {
) x9 b: j/ P4 Z6 v7 j                // IDE or ATAPI IDENTIFY cmd
                BYTE btIDCmd = 0;
* j% K3 i% ?  r! T& L                SENDCMDINPARAMS InParams;
2 E' I* o! j" ?                // Now, get the ID sector for all IDE devices in the system.
' |. w! F+ R: O1 p8 v$ K4 N                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
5 Z$ Q$ a1 W& l                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
+ s3 U; d% r0 m3 e                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

$ G9 v- e0 x$ n1 y+ N0 j. X                if(DoIdentify(hPhysicalDriveIOCTL,
                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
' L6 b' A9 Q& f, \: u' W                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
. _7 ?! B6 L5 p8 x2 D% f                    DWORD dwDiskData[256];
( A7 o8 ]1 s( `5 G3 Z5 q                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
3 O3 ^! T" _+ j" `. A/ o9 D                    char szSerialNumber[21];
                    char szModelNumber[41];

                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
# ?# @% x& C/ j" o+ X1 }# s                        dwDiskData[i] = pIDSector[i];
                    // 取系列号
                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

; m8 Q6 @4 o* l4 N                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

; ]3 C4 p+ j; r7 \* w+ T                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
                }
, K5 Y3 t9 s- K7 T- H            }
1 s- y# J+ ?+ c2 L5 z, N            CloseHandle (hPhysicalDriveIOCTL);
: K" E# f/ Y. e+ N        }
    }
) g$ S/ o1 j+ J7 b  |3 h}
- Q% k% w' l1 M( O//---------------------------------------------------------------------------
// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
              PDWORD pdwBytesReturned)
; ~0 a' J) l5 m& q! l$ y/ |{
    // Set up data structures for IDENTIFY command.
' a7 W2 F  `4 B  n2 @    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
    pSCIP->irDriveRegs.bSectorCountReg  = 1;
, G6 F  E9 x! }( l0 h    pSCIP->irDriveRegs.bSectorNumberReg = 1;
6 g! q; z' ~* c. m7 I: o    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;
) u" G3 D' _! y' |* A
% i4 p+ m1 b( x! @0 n" w    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
" Q* }  T+ `6 p( y+ ?
    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
9 ~8 y! r: f6 _/ V; B4 u0 \' h    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
+ z9 ?  s" {8 p0 Z
  p" w4 p7 z' o$ K; \5 P    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
9 T0 p: M$ V: a; W           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
8 f' i& x! r2 a           (LPVOID)pSCOP,
0 j( f& o% r. N9 u; G3 l           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
2 {# _5 f* m/ |           pdwBytesReturned, NULL);
% B/ B( ^* o1 N# @( F: R}
1 P6 [: f- [: C! X; t2 _//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
. M4 g' k) N9 {  r2 [( j//---------------------------------------------------------------------------
) \% U% y" S# f1 K# {// ReadPhysicalDriveOnW9X
6 M' E  I3 M4 {4 gvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
+ K" Z$ ^, A0 H/ \5 e{
    WORD wOutData[256];
    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
" _- h9 W0 }  o1 v& t. b. `
    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
* k( j4 w6 ^" M8 U* a* T    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
5 W7 D* V" h2 c/ c6 [  c! W$ h! Q        WORD dwBaseAddress;
" P7 [9 i8 t" L& \2 q9 g" r8 L* |        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
+ f. ]" I( I  d0 ]1 ?$ q6 M8 l& L' f        bool IsDiskExist;
& `& y  ^3 x: ~4 K
        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }
3 g6 K0 Z1 D; n  `* c. G
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
) I2 v; r7 K7 d# l
) M  F! f0 I+ P! ?        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
    }
9 v- y/ a: B( d2 T, `, F
    // 开始读取
1 f1 V" s! |9 z- {! a    for(int nDrive = 0; nDrive < 8; nDrive++)
3 o% W1 V% T) J$ a    {
        WORD dwBaseAddress;
7 G2 h8 e/ J+ h: s# N5 t        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
- S3 z8 f, U9 O        bool bIsDiskExist;
        switch(nDrive / 2)
        {
% Y" B' _! O0 m: V9 g' o( I0 E1 t2 O            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }
  S' m' n, T0 u/ P& a& _, M
3 g7 F$ z3 ]. Z; X1 D1 j% o        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
# }" ]& S( m; W* V0 b* M7 t
0 G1 z9 Z8 ?) ~0 c3 v        // 进入Ring0
8 B; |- r. w1 j7 {, `3 H" c        bIsIDEExist  = false;
; ~, A& q" L0 W7 n        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));
- g' ^: ?) r+ I$ l5 [- _
        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);

4 n6 t/ l' N1 H8 ?7 U. w! ]( M' n        if(bIsIDEExist && bIsDiskExist)
        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
            char  szModelNumber[41];
& z/ t/ F* L9 H) C  k- X9 J
: p5 u/ x8 ?! n" A5 K3 x. Y; B- o0 w$ m            for(int k=0; k < 256; k++)
0 E. [$ s. R2 Q. A. b                dwDiskData[k] = wOutData[k];

            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
: ~% n3 C- _$ n8 [6 t5 Z4 _
            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

9 S2 q  g, H2 g9 ~% @1 ~! [            pSerList->Add(szSerialNumber);
% n3 ?3 ^- E" k( \) o  K, L            pModeList->Add(szModelNumber);
' H: l; _& c$ C& r3 l        }
/ s' b' Z! y- b- ^$ @    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
4 P$ H3 @5 R/ a+ j// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
$ N7 ~7 T6 P, r- ]// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
2 K+ z# C' ^) W) w: o) F* x! q// btMasterSlave = Master(0xA0) Or Slave(0xB0)
8 `, @8 V: c9 i, W& Z//---------------------------------------------------------------------------
" B5 T$ b% J1 P4 H! r! dvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
{
    BYTE  btIDTR1[6];
, n( O2 Y0 |) P) R) J$ t8 z5 j    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;

    BYTE  btIsIDEExist = 0;
1 V' T% r2 u3 p1 O: g* w9 F    BYTE  btIsDiskExist = 0;
6 L4 a. v5 Q' {2 ^3 ~% k    WORD  wOutDataBuf[256];
2 d1 T7 v1 e& N' }/ o5 v1 Y
% e$ X4 \8 B, ^( n2 T& g5 x: l$ U    BYTE  btIsFirst = (BYTE)bIsFirst;
$ K( d+ W: p$ O. l  k! ]4 f2 b
    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
* T5 {% A6 z0 G/ i6 z" W" a    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
    // const BYTE btERR  = btBit00;
8 e8 |% N( _4 G0 d6 h1 b+ _! q    const BYTE btBusy = btBit07;
# m* Y; d; L; e- d- P- \    const BYTE btAtaCmd   = 0xEC;
" s: `. J+ z! |- h    const BYTE btAtapiCmd = 0xA1;
! ?8 {' w0 ?; @2 H4 b
    __asm
% w' @1 R) U' `% f5 j    {
" D- H; U2 D! I' q% ]        // 必须先执行这条语句
8 M0 T& ?; \, x        JMP EnterRing0

& @) A* Q, U: q/ N4 ^        // 定义过程
) T7 ]( Z; c6 o/ J5 }4 Y        // 等待IDE设备直到其不为忙为止
        WaitWhileBusy proc
/ A( h9 q" u/ F' K9 ~
5 V. W* r* M/ u! ^  L9 L        MOV  EBX, 100000
; `0 z  s) r3 I        MOV  DX, dwBaseAddress
        ADD  DX, 7

; {* I- _. R2 q2 e7 \        LoopWhileBusy:
! b% H' w/ a' m7 M. t5 E. v
        DEC  EBX
9 n. i' t3 [3 }5 i. F4 H        CMP  EBX, 0
        JZ   Timeout
: p# g  E  R( g! C% n        in   AL, DX
        TEST AL, btBusy
9 y  O. M/ m/ E6 j, r4 Z/ V        JNZ  LoopWhileBusy
" k& u) r# r* r, h4 ~        JMP  DriveReady

        // 超时，直接退出
        Timeout:
3 A) h! X! L2 A        JMP  LeaveRing0
        DriveReady:
        RET
9 B8 ]! [( w1 d) h+ {, e3 d        ENDP   // End of WaitWhileBusy Procedure

        // 设置主盘和从盘标志
        SelectDevice proc

        MOV  DX, dwBaseAddress
        ADD  DX, 6
6 ^6 p+ r# P) w        MOV  AL, btMasterSlave

( |9 V$ {1 N9 i$ r0 T! H        out  DX, AL
        RET

' M7 z9 ]% m* y6 W        ENDP  // End of SelectDevice Procedure
- X% Q9 _0 B' y; J) _  t. y. n
        // 向IDE设备发送存取指令
        SendCmd proc
$ W( ]  f$ \9 x9 g
, P, i" w3 N+ R3 L2 i        MOV DX, dwBaseAddress
. d6 h  I( S" c( O        ADD DX, 7
7 X, s. W& O! v        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
8 v2 h5 ~; w: Y9 y4 g        RET
        ENDP  // End of SendCmd Procedure

        // Ring0代码
6 @: G* _7 T& Y+ k4 O        Ring0Proc:
        PUSHAD
        // 查询IDE设备是否存在
; |3 z: ]7 r: R. l6 T        MOV DX, dwBaseAddress
# r; K2 o9 ]; p5 R7 s8 a        ADD DX, 7
9 f4 A7 Z. _& n: v+ ?9 d        in  AL,DX
! j- [; o& G- `' H& R
, d, |/ [! B1 C( w+ N/ m        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
        JZ  LeaveRing0
        CMP AL, 0x7F
        JZ  LeaveRing0
! D1 i) P; z1 u# X, F: ]3 I
        // 设置IDE设备存在标志
2 f: P7 S9 p; t( }/ i2 {$ \        MOV btIsIDEExist, 1

+ |( Y# l) N8 X& y        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
0 q$ X$ X* ?. A        CALL WaitWhileBusy
        CALL SelectDevice

# ^# z5 V4 `* q        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
8 g4 V% g  t# L$ e* h: |3 n  S- r        CMP  btIsFirst, 1
        JZ   LeaveRing0

, v; R3 P7 n5 s. e6 L5 {        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
; R2 J& B" N' j# M        CALL WaitWhileBusy
5 J+ x- ?- r+ @2 X, v
- K5 v$ \: q, R4 H7 D( |        // AL的值等于cBit06时，不存在驱动器，直接返回
- b" z6 v" Y& c' j; I5 Z        TEST AL, btBit06
+ P0 G5 w. o0 w' ?        JZ   LeaveRing0
6 K( `' j, n, C* L+ J, c) |
        // 设置驱动器存在标志
. l% v' L. r5 w; _. d        MOV  btIsDiskExist, 1
) D5 x( \4 d- y! u0 b1 C; r
        // 发送存取端口命令
  G$ n0 _  R- u& j% C        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
, |% P% }2 N% W1 }" |& ^9 _        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
( J/ u* K" G# W: U* S  a. t        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
        CALL WaitWhileBusy

        // 检查是否出错
        MOV  DX, dwBaseAddress
+ D" e+ m/ ?  j4 o# P        ADD  DX, 7
- s( R2 a/ F6 w- Q1 o  j
        in   AL, DX
& }6 L1 t' U9 y5 R" R. K
        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据

        // 如果出错，则进一步尝试使用ATAPI设备命令
        CALL WaitWhileBusy
+ i3 O8 U7 S7 K% \$ U; ^        CALL SelectDevice
        MOV  BL, btAtapiCmd
        CALL SendCmd
5 m6 ?' M/ e9 `0 C2 s# g        CALL WaitWhileBusy

& q- t9 v, ?# u* `        // 检查是否还出错
( P$ i% U5 R' S9 ^/ v5 ?        MOV  DX, dwBaseAddress
, S1 U1 C5 W" P; e2 |( {        ADD  DX, 7
        in   AL, DX
        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
; Q! X  k1 G$ [' [        JMP  LeaveRing0     // 如果还是出错，直接返回

        // 读取数据
, Q& I* I5 |! T/ x  T        RetrieveInfo:

        LEA  EDI, wOutDataBuf
        MOV  ECX, 256
        MOV  DX, dwBaseAddress
2 v* O+ m' \, _; h  r% p        CLD
& N' J- v4 j# P
* x8 N8 b' y( a* B% B        REP  INSW
9 b0 y# V' M  L! w
        // 退出Ring0代码
0 D  O( i/ j* f5 z  D' M7 P4 _        LeaveRing0:
$ `0 e% A+ D) ~4 ?* E: C8 @' t
        POPAD
9 V4 ?" B' R' h. d/ Z0 u6 h: J# A6 n        IRETD
8 J/ H2 Z  z9 J4 }% `# a, y, @
: S( C0 u8 Z5 D3 F* G* D7 ^  i        // 激活Ring0代码
        EnterRing0:

* e7 y. S. N1 c0 g0 }: E        // 修改中断门
! U. M, x1 F- R# l+ K: S3 d3 l        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
1 s6 J: {: z; i* q; c* v        ADD EAX, nHookExceptionNo * 08h + 04h
, S/ Y/ Q3 {8 v% v% e        CLI
. s) |- I- t( v& @9 I
" u0 J$ \' t. I5 C; J8 c        // 保存原异常处理例程入口
, {) }2 F4 a7 Y        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
1 F& Q$ W, C& B1 y: q9 C        MOV dwOldExceptionHook, ECX

- q% c- [& f; m0 V; a# x* T        // 指定新入口
3 j) W: B/ r4 Q$ S        LEA EBX, Ring0Proc
        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX
: v0 \" {1 K( L; b2 V( \$ A! D
        // 激活Ring0代码
( U) ?. a5 z4 L5 q        INT nHookExceptionNo

        // 复原入口
        MOV ECX,dwOldExceptionHook
( S4 k3 B5 f5 K$ H        MOV WORD PTR[EAX-04h], CX
/ E! O* Q- Q8 G) z0 H( Z        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
        STI
7 X) U: N8 Y3 b, s    }
8 a2 |9 `/ H) c    if(!bIsFirst)
    {
! x( g2 t: D/ u5 C        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
4 L; d* U) K8 H; p" q4 U; A    }
' t/ E* D$ T( |}
//---------------------------------------------------------------------------
/ d% b# \# n; l* v// 调用方法：
  R8 [& N7 x9 M2 v- m1 O! v6 @9 P/ Tvoid __fastcall TForm1::Button1Click(TObject *Sender)
{
5 Q& X7 m/ k7 O4 g8 X% S+ y    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
; d2 o$ e2 w/ s8 p+ A# D( T- [}
0 x! q7 R! ^3 X