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

天云上人

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

1. 
   2 D# s8 x2 J/ i( ~
2. #include "StdAfx.h"
   
3. #include ".\puiddisk.h"
   & F( ^. A' W1 v& [9 h) a
4. #define _WIN32_DCOM
   / N2 |9 o# f. z6 c8 |! e9 S
5. #include <iostream>
   
6. using namespace std;
   
7. #include <comdef.h>
   
8. #include <Wbemidl.h>
   6 o* J7 ]' v. K( i
9. 
   , [' h- r$ e+ a% p1 K, U. c: m
10. # pragma comment(lib, "wbemuuid.lib")
    % E9 o/ |. S; e
11. CpuIDDisk::CpuIDDisk(void)
    8 H- t" z, K, {3 |
12. {
    : E) k+ ~( R% o9 S
13.     GetInfomation();
    
14. }
    : V1 `2 f; {" A1 u& l; d5 x. h
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    " F7 f% X  `! W$ R
18. }
    3 R# [+ F$ _- q& H2 @
19. int CpuIDDisk::GetInfomation(void)
    0 C4 B' k. d# a! ]) I
20. {
    
21.     HRESULT hres;
    5 o3 Z( `: A( p/ n, G# W
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    
24.     if (FAILED(hres))
    
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    - U% Y. t8 S  {0 X$ @
27.     }
    " e5 _* s, t+ \
28.     //步骤2：不是必须的，COM只须也只能设置一次
    
29.     //Set general COM security levels
    1 _7 X, [0 |+ U- P# i7 o" @
30.     hres =  CoInitializeSecurity(
    0 r8 R4 o, q' c& W" C. {
31.         NULL,
    , d1 z6 [- r$ s' j2 a( }: t. ?
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    
34.         NULL,                        // Reserved
    # B2 @  S2 V2 [0 \" E& l8 z1 |9 }8 |* q
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    + f( d& _9 w% G. u6 @
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    4 r6 P# U6 j; z# F  T0 S8 V, }
37.         NULL,                        // Authentication info
    
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    
40.         );
    + [" n, D  V8 O6 u4 T2 |
41.                      
    6 I; [3 m* ^  g5 ?- ]* B/ R
42.     if (FAILED(hres))
    . f/ s, ^7 G9 j1 I+ M
43.     {
      K9 j- R" X4 Z+ G& {* B5 U
44.         CoUninitialize();
    
45.         return 1;                    // Program has failed.
    3 p1 t, x; d6 }+ j+ Z8 |6 l  N, e" b
46.     }
    ( s" s! G! x2 ?0 y5 X. d& f
47.    
    # N* X& ]. T. a8 M8 o' o, r  i% a$ u
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    
49.     //步骤3： Obtain the initial locator to WMI
    6 R! c# N: q6 a' t
50.     IWbemLocator *pLoc = NULL;
    , a9 o4 O. j6 r, a# S9 J9 M6 U5 u5 F
51.     hres = CoCreateInstance(
    
52.         CLSID_WbemLocator,            
    
53.         0,
    1 G3 q. q, }8 @! e# [3 I
54.         CLSCTX_INPROC_SERVER,
    4 M& r' x0 d  F3 L% f
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    
57.     if (FAILED(hres))
    
58.     {
    ' {3 j+ F) s+ z. z' t3 U
59.         CoUninitialize();
    
60.         return 1;//Failed to create IWbemLocator object
    
61.     }
    ( g: B# y5 X; f+ |$ H+ J
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    $ j6 I8 l% U! X! l- N
64.     IWbemServices *pSvc = NULL;
    
65.     hres = pLoc->ConnectServer(
    
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    : b' ~: u2 i$ U! m
68.          NULL,                    // User password. NULL = current
    6 J5 W; R2 s5 s1 {& p, L
69.          0,                       // Locale. NULL indicates current
    
70.          NULL,                    // Security flags.
    ( S+ Q- ?: J. ]5 _# a, C0 G
71.          0,                       // Authority (e.g. Kerberos)
    
72.          0,                       // Context object
    4 d6 `' O, u+ u5 I; f
73.          &pSvc                    // pointer to IWbemServices proxy
    
74.          );
    * b+ v6 }; F* j: v  l: L! j1 a
75.    
    
76.     if (FAILED(hres))
    4 V' D0 y, V1 K6 g
77.     {
    ! Z9 U3 J8 F, e6 }! w
78.         pLoc->Release();     
    ! F; q* K9 ]! d' W1 a% R
79.         CoUninitialize();
    
80.         return 1;                // Program has failed.
    
81.     }
    6 W! ^  t% g0 C  z0 S( D1 q* q' h4 d
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
    
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    , z0 T4 n8 B5 l- Q. K
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
    # J# _2 @0 X2 Z5 v6 v
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    ! ^) g; C# z/ ^! x5 P. }6 O
92.     );
    
93. 
    
94.     if (FAILED(hres))
    . n, t1 l9 E  I$ [4 K
95.     {
    7 x, ]  |7 T6 d( v
96.         pSvc->Release();
    * _: q. r7 K1 ?$ C' C
97.         pLoc->Release();     
    1 J2 m7 c$ p* f) Q) a0 t/ Y( V* U0 y
98.         CoUninitialize();
    4 B( b, b6 t8 @8 [
99.         return 1;
    2 G7 k+ F7 N3 `- I7 X# v. @% ^; V
100.     }
     # t, e% v% ^$ z
101. 
     $ L- H4 \) z; W1 z
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     . Z' N& H8 d; v" C
103.     IEnumWbemClassObject* pEnumerator = NULL;
     , H9 T& n2 Q! N: @- a2 e% l6 a
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     4 ?% D$ H* E1 Y3 a
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     ; f8 k" x  p+ z; t* [9 G
109.         NULL,
     + _+ @3 A& O! {! _7 L; r0 T
110.         &pEnumerator);
     , Z& ]+ L  `+ v0 G3 B0 p' a" R6 i
111.    
     + a, g# K8 @% n
112.     if (FAILED(hres))
     
113.     {
     
114.         pSvc->Release();
     
115.         pLoc->Release();
     
116.         CoUninitialize();
     
117.         return 1;
       ^7 X- a4 r; _0 C
118.     }
     
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     ! U7 |2 K  _- ^+ Y! q$ H0 [
121.     ULONG uReturn = 0;
     % O! a0 U3 O. x8 i! V2 P
122.     while (pEnumerator)
     - i0 v) H2 x4 p4 r6 Y
123.     {
     8 H- C( n) m8 O( Z/ U; O) X, Q" E
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
125.             &pclsObj, &uReturn);
     3 q) J, ]6 a* g7 x/ T7 ?
126. 
     
127.         if(0 == uReturn)
     , i2 W" w) A& t7 X  k4 A3 X; `
128.         {
     ) K0 `! j: E4 k4 L# T# u& R- F
129.             break;
     & g1 M" C/ M' _0 F* w- S
130.         }
     
131.         VARIANT vtProp;
     2 u0 W2 h2 N9 ^) V, J2 Q
132.         VariantInit(&vtProp);
     3 }" p+ D! x. T( `2 z4 L( m. w
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     
136. 
     
137.     //计算硬盘系列号
     # w$ P0 m; h) t' {9 v' q! D& @
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     # ?+ s9 B8 u/ V
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
       p! \8 u) \; R( ^2 B, a
142.         NULL,
     6 x# K9 o# t4 H
143.         &pEnumerator);
     4 H" u# s3 l' a9 }
144. 
     
145.     if (FAILED(hres))
     : j0 C' C8 `9 e9 [
146.     {
     ( @% B& A/ Q: _5 V* [9 p
147.         pSvc->Release();
     . {' Y' p+ I* F% K) R
148.         pLoc->Release();
     + B# ~' h6 o. m7 x
149.         CoUninitialize();
     
150.         return 1;
     1 ^1 n, k9 Y" Q1 B/ _
151.     }
     / S, j! R( x, s3 P. U
152.     while (pEnumerator)
     3 i) K) Z5 d; d7 e5 [
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     ( o: f. X1 d! x3 e8 o* O
156. 
     5 x& F- l  M6 @2 ^, @2 X! x
157.         if(0 == uReturn)
     6 U5 W( T/ G2 c+ o- B
158.         {
     5 o5 B6 x& r3 L' [6 I
159.             break;
     $ Y* P% v# b6 I( L) _
160.         }
     : k* l3 w, P: L. a& b
161. 
     
162.         VARIANT vtProp;
     
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     
166.     }
     6 i( J2 c( N% U- M! |4 p, _
167. 
     
168.     pSvc->Release();
     
169.     pLoc->Release();
     # l' n8 v- A) o* y4 ?: R, X
170.     pEnumerator->Release();
     
171.     pclsObj->Release();
     
172.     CoUninitialize();
     
173. 
     / N4 I- J: a! J8 ?/ |
174.     return 0;   
     
175. }
     6 A( D/ F: }6 f9 q

复制代码

天云上人

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

6 b; }$ C% G" y% |# {$ D#include <WinIOCtl.h>
#include <stdio.h>

#pragma inline
//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
, k! c5 [; _0 s7 I5 e8 Y$ w#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
$ M4 f! `& P2 M- l. }* a7 {( s#define DFP_GET_VERSION         SMART_GET_VERSION
#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
& `1 V+ h. y) ~) R3 M% s2 c- w* B#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
7 k. M* F% `+ R) P9 B% e
1 g( Z1 Z$ U' Hconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

const int MAX_IDE_DRIVES = 4;
$ @) R/ d2 q1 C) Q  A. C& _
// SCSI专用变量
) x* [/ m# H* S# Z& h1 kconst 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;
* a) c0 m% {; F$ k/ E3 [
typedef struct _SRB_IO_CONTROL
/ D9 d2 a' S& h{
  Y; q8 D: w2 a) X* D' B" G    ULONG HeaderLength;
* @0 L0 C' m+ n0 p/ m    UCHAR Signature[8];
    ULONG Timeout;
    ULONG ControlCode;
    ULONG ReturnCode;
" c) x0 h- K' j    ULONG Length;
$ e6 Q* P- i+ ?( _- t# C) p9 b  u2 J}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

// 辅助函数
0 t/ X' B6 G8 z2 N6 [1 fchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
/ B/ K$ Y! g5 d7 t9 f; avoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
" W% a) q/ V( `: T: Z9 c// Windows 9X函数
: y! O8 s* k! i, L/ c# |void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
$ ?- `( M' J( \0 B        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
5 e$ x# M+ F5 i1 h5 K; x
7 R0 k3 h1 ?. Q# r+ ]// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
$ Z( A0 t- s  `* j, s3 m+ O- D// ReadPhysicalDrive
- \9 Q2 Z( ~0 O6 K$ o$ Ovoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
    switch(Win32Platform)
    {
        case VER_PLATFORM_WIN32_WINDOWS:
5 a- u$ J6 v- [3 p            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
        case VER_PLATFORM_WIN32_NT:
5 k6 l1 L. ^+ T+ }9 [, Z            ReadPhysicalDriveOnNT(pSerList, pModeList);
( G$ Y6 g0 d8 m/ f* ]  n" k            break;
        default:
            break;
1 d! S  w' N; B! V    }
- \  v6 H: y* u( Z$ y4 f}
/ @$ ]  a: s5 C9 A, a3 j" L' y//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
2 Y( ?; P) }0 t/ G    static char szResBuf[1024];
9 O% |7 P" D& F/ @9 [    int nIndex = 0;
    int nPosition = 0;
, C  E: {% g( U; [& }( F; t
    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
3 p( l; ?# q2 Z6 C        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
: W+ V) U7 Y7 x# C' C- p        nPosition++;

  p- m* x( ?! o        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
6 ~. K3 m8 d- M, t4 @1 G; [: A# A$ `, T        nPosition++;
    }

& J4 u5 G2 N( q( H: \& U; m' F( z" L: J    // End the string
" {9 G) W- Z2 q0 D, ~$ B    szResBuf[nPosition] = '\0';

4 ^9 x& O' j4 w, h2 z    // Cut off the trailing blanks
/ F% s" @6 a  }0 d3 B9 L    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';

# K# B0 X% n: h) k7 e% _    return szResBuf;
}
& J2 L0 N( J4 q, m5 c2 I% u//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
" K  i0 F. t0 i% c7 T8 N7 d1 D( K// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
    // 输出参数
0 Z5 _  [- C$ ?, S( M: M    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

8 {7 m6 S# F' N; P3 ~' o  ^    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
    {
  k7 K1 K# R* Z7 n" y* C        HANDLE hPhysicalDriveIOCTL;
+ z/ v, C5 o" `9 j        char szDriveName[32];

        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
5 h( |; x& J* X. ?        hPhysicalDriveIOCTL = CreateFile(szDriveName,
+ z0 W/ _3 o, x  s6 B: ^                        GENERIC_READ | GENERIC_WRITE,
" E+ `" ^$ ]2 N2 s% U( K' t                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
" b8 `% ~( Y5 R: ]& w                        OPEN_EXISTING, 0, NULL);
: x6 |- w8 x5 }4 [, t1 o/ x+ b8 ]
5 ?: {% I  }; ^& }. {: N+ b# A1 t& Z        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
        {
            DWORD dwBytesReturned = 0;
' N; w& e! ^( I            GETVERSIONOUTPARAMS gvopVersionParams;
/ V( l, L+ Z; h! f% S6 K
            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
  {' ?, x' f# A5 Q                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
, s! M0 a7 n% H3 h            {
                continue;
            }
# Q4 F2 {/ l; q$ I  x
! t" ^' T; N7 b; N! d            if(gvopVersionParams.bIDEDeviceMap > 0)
* T/ W+ L  }5 P: N8 B9 d            {
+ G1 u; I, l0 [* y0 Q0 C                // IDE or ATAPI IDENTIFY cmd
) M1 m+ N! y" v                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,
+ X3 z* N% R, Q0 x4 N3 p                // otherwise use the IDE_ATA_IDENTIFY command
                // 具体所得结果请参考头文件中的说明
                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
. l& y7 Y5 R9 A                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
9 q! F5 ?. f7 ^  j! r% ^2 x3 e+ ^                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

4 [/ X+ M0 \% ~* A9 Z2 }8 o                if(DoIdentify(hPhysicalDriveIOCTL,
. a; y0 c+ u3 K" C                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
. d8 ?* T/ e: N+ l+ l                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
# f! s: i5 O/ R; x& u                {
                    DWORD dwDiskData[256];
6 w$ Q5 n( i' }* S                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
6 K7 o& ^7 g0 \                    char szSerialNumber[21];
1 x  v$ h* @- R4 B9 u/ Q( J7 H6 e                    char szModelNumber[41];
# m* ]: S1 o5 o2 K; z0 E
8 t. b+ U, G8 Y. l                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
* X! W5 e9 H& R                    // 取系列号
' k$ k# z% ~6 P( q2 z# O2 k                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
) H' h, k' r' [  q# W, W/ Z( v                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
1 r$ U% G9 V! r" I7 ^; s
                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
/ t. F. [  Q0 L, ]                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
                }
            }
7 }3 z5 I. U6 u. D" e2 c            CloseHandle (hPhysicalDriveIOCTL);
! c; P+ g! S, W, u4 P6 v        }
0 I, ]- Z/ V5 `% f$ e    }
}
: r6 Y3 K# B- \2 E& q//---------------------------------------------------------------------------
// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
- [" v7 g2 m4 d' b# L$ @* a              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
3 s. U3 ~' K1 V1 ]- T              PDWORD pdwBytesReturned)
{
    // Set up data structures for IDENTIFY command.
" X/ o" A+ y; D* W' w0 K* X    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
1 W7 F2 c  Q! A    pSCIP->irDriveRegs.bFeaturesReg = 0;
! L( N$ ^0 H1 P, `" S, U# [$ T7 O3 s    pSCIP->irDriveRegs.bSectorCountReg  = 1;
% ~" N. R8 B9 f! v7 G    pSCIP->irDriveRegs.bSectorNumberReg = 1;
    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;
( `) ]* s* g: E. [$ z8 K/ ^6 N2 D! ]
; _& b; G! K3 }/ Z2 K* n    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
7 h$ \" O0 Z% ~7 y8 _9 `
% E4 S: `6 `9 S# |# M* }    // The command can either be IDE identify or ATAPI identify.
    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
0 X' d% r0 X0 D' ?+ o+ v, L) `! }3 s
    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
& V# t$ v, g! V1 q7 ^           sizeof(SENDCMDINPARAMS) - 1,
& Z$ W% D  z! n& d8 E8 v3 Z7 h           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
# F( u1 L. g/ X; u7 V( n) y// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
  f: e8 ~$ R, S9 j6 H  [+ Q) |. N/ W// ReadPhysicalDriveOnW9X
+ |0 i" ~3 k  ~/ |; E6 Q7 U# qvoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
$ D! G: u: |2 p* j9 Z1 J    WORD wOutData[256];
    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

: Z8 E  N% ]) t- q+ j% m7 d$ Z    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
. ~& r5 c( C( |: l) {        BYTE btMasterSlave;         // Master Or Slave
        bool bIsIDEExist;
8 o1 R3 Y2 y& c6 ~) t7 D! Y        bool IsDiskExist;
) Z3 f. E) C% @, O7 W9 T5 k! R
        switch(nDrive / 2)
        {
4 v/ }" X" I2 S; D. V            case 0: dwBaseAddress = 0x01F0; break;
% c$ x$ e3 A/ ~! n            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
& a5 v% d3 U. u; T$ v$ G* i        }
; t2 ~$ Q$ u; A+ J1 t( _; F# g
7 L9 D6 V0 f# Y+ \        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

$ w& P; e9 J5 [" C/ _/ o        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
: e  d& X: s6 b: K7 `/ E                bIsIDEExist, IsDiskExist, wOutData);
    }
  Z. K6 K; N, b$ I5 v
8 P& z% ?8 M6 j    // 开始读取
# [8 d5 R+ H8 ?2 _% [  ]- a) k, I    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
# E3 X* L* Q; u  q        BYTE btMasterSlave;         // Master Or Slave
! K, T) J  x* u        bool bIsIDEExist;
        bool bIsDiskExist;
9 @; {# a% R% k4 J7 U! Q        switch(nDrive / 2)
        {
0 P( Q/ @( C  n! Y) D7 m3 i            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
/ B9 Z' o* ]( H4 p            case 2: dwBaseAddress = 0x01E8; break;
            case 3: dwBaseAddress = 0x0168; break;
        }
: R2 s, w' o* D- j
        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
6 L5 R9 w5 _2 C7 U! A
  S+ r, I- t, L: g0 V- t        // 进入Ring0
        bIsIDEExist  = false;
        bIsDiskExist = false;
6 T# n" P$ a# G6 v        ZeroMemory(wOutData, sizeof(wOutData));

        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);
; b" [$ |) J1 [) B# t
5 l. j) ]7 ^) L4 P5 ?        if(bIsIDEExist && bIsDiskExist)
        {
            DWORD dwDiskData[256];
            char  szSerialNumber[21];
/ v- f" [1 @( \. P            char  szModelNumber[41];

            for(int k=0; k < 256; k++)
. _2 b* X+ }: Z1 p" N                dwDiskData[k] = wOutData[k];

            // 取系列号
/ b% q. A& ^, ]% O. [            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
$ W; j- }8 \' x& @, t# H/ i+ q            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
* n4 u, i/ k2 i' ~: L& q+ U5 [# c) G
9 k0 ], w. ?% g! A) @; L) ~            pSerList->Add(szSerialNumber);
4 V9 \9 M$ ]0 j) w' r+ ~% |            pModeList->Add(szModelNumber);
' @" K5 ]$ f9 C% W        }
  z- S# {0 C" K* L0 T% m5 d    }
    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
9 g8 U/ u0 D1 q- V}
4 N+ L$ H3 b, r: U//---------------------------------------------------------------------------
) T& l2 o3 }! G2 J% X& h// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
! [: c1 o! O3 P( k. s* p0 n' ^// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
) J) z) X5 w( C) C. g% b//---------------------------------------------------------------------------
8 |( K1 ]' A* f2 ?3 \. p// ReadPhysicalDriveOnW9X_Ring0()
//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
% H" L% [( Y; N9 v// btMasterSlave = Master(0xA0) Or Slave(0xB0)
# X5 q! p% G# K0 h) }//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
# M5 V* \4 y* b! Z; f{
    BYTE  btIDTR1[6];
. n/ w, i1 ]& f0 X0 r    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;

/ N$ s) k! a, [2 w    BYTE  btIsIDEExist = 0;
1 j* z' C9 [3 {5 }* y* N    BYTE  btIsDiskExist = 0;
3 r: h; T' o2 |- R- d    WORD  wOutDataBuf[256];

8 b! W! m- F' i1 i9 X: O9 k8 Z; R    BYTE  btIsFirst = (BYTE)bIsFirst;
5 B" u; l' B, i' O# C
3 U$ P9 p5 ?; O7 q2 d    const BYTE btBit00 = 0x01;
$ b+ d; |1 M& o7 q, R    // const BYTE btBit02 = 0x04;
$ \1 c1 ?4 N! R" M    const BYTE btBit06 = 0x40;
    const BYTE btBit07 = 0x80;
& @/ V% v% h! |" Y    // const BYTE btERR  = btBit00;
& K% m8 O4 Q5 l  K/ X    const BYTE btBusy = btBit07;
    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;
6 v$ Y) i( F: c
    __asm
( G1 d/ @) A" P) g/ }    {
        // 必须先执行这条语句
        JMP EnterRing0
1 X' L9 U! v4 Y
        // 定义过程
        // 等待IDE设备直到其不为忙为止
1 G* k& \7 K" u  b& ~& Q        WaitWhileBusy proc
# f2 A. c" y3 v  @/ B
        MOV  EBX, 100000
) h' F2 n6 h& ~, A6 `        MOV  DX, dwBaseAddress
        ADD  DX, 7

        LoopWhileBusy:

        DEC  EBX
2 g1 u: i+ M, {        CMP  EBX, 0
        JZ   Timeout
1 }6 ?9 w8 ]' h9 k        in   AL, DX
8 ^- X& m. U1 i+ L0 ?' }        TEST AL, btBusy
        JNZ  LoopWhileBusy
8 f. n+ \. f* U  {7 E        JMP  DriveReady

/ U6 k) J( z8 [  S; \7 \        // 超时，直接退出
% O1 \! X9 d, q  [% i/ X* h' e2 A1 t        Timeout:
        JMP  LeaveRing0
" R; s0 d( l7 Y4 D7 M5 K8 H        DriveReady:
2 _, g% Z( q- F0 {6 e5 `+ n        RET
        ENDP   // End of WaitWhileBusy Procedure

5 g# Z! Q, x4 V# S        // 设置主盘和从盘标志
* E- Y' v1 M  q3 {' g        SelectDevice proc

. K* A+ f- {  l" u8 k8 l' r8 ~        MOV  DX, dwBaseAddress
9 Q, A* ?$ G9 b8 B" `) K        ADD  DX, 6
        MOV  AL, btMasterSlave
' A8 X% K" n/ w8 e) m
        out  DX, AL
) I. `+ {2 o' l4 v: C        RET

0 H+ D4 }' H& q& R. }$ A* t2 R' F        ENDP  // End of SelectDevice Procedure
/ s0 |, r( j2 J  A' b+ N: ?
$ @* g( H, u7 P% r        // 向IDE设备发送存取指令
        SendCmd proc

        MOV DX, dwBaseAddress
0 a0 H  H2 o" u9 b6 J        ADD DX, 7
        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
        RET
& D/ X3 G: g! f$ x( |        ENDP  // End of SendCmd Procedure

        // Ring0代码
        Ring0Proc:
        PUSHAD
1 p1 C4 d/ _( Z8 _& P        // 查询IDE设备是否存在
, x6 [; o( t. b2 R- h        MOV DX, dwBaseAddress
        ADD DX, 7
: ~$ R3 g3 X: _/ |0 I        in  AL,DX
. b" J- [, y  z, f' r. ?: p
+ e5 M& c' T$ t2 a        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
        JZ  LeaveRing0
- M, u( c& ?; G% `        CMP AL, 0x7F
        JZ  LeaveRing0

        // 设置IDE设备存在标志
        MOV btIsIDEExist, 1
; t! F! w8 C- E5 ?% H# I& `- V
        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
        CALL WaitWhileBusy
        CALL SelectDevice
) V! N5 J2 Y0 x) |5 r. j) v
        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
( p1 I0 X5 A$ x- Y- `        CMP  btIsFirst, 1
        JZ   LeaveRing0

        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
        CALL WaitWhileBusy
0 @# q( g/ ^) q8 u
8 ?; Y% x  y9 ^( e4 l0 h6 i        // AL的值等于cBit06时，不存在驱动器，直接返回
        TEST AL, btBit06
        JZ   LeaveRing0

5 |8 O6 c6 k. V+ J, m3 G) m        // 设置驱动器存在标志
        MOV  btIsDiskExist, 1
" P* }6 R3 N: W+ G3 v6 s6 G
        // 发送存取端口命令
& r3 h. G4 ?& H* u        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
* p7 P5 A* W) f" w        CALL WaitWhileBusy
        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
) j! C( k5 [7 [2 w        CALL WaitWhileBusy

        // 检查是否出错
+ I4 F9 x! i* }4 \        MOV  DX, dwBaseAddress
        ADD  DX, 7

9 t$ J5 J; R" O* m        in   AL, DX
' U; {7 f- ^5 _6 ]' {8 H6 ~; j5 y
3 p8 \  W: H0 b! A  G4 q9 j3 E        TEST AL, btBit00
        JZ   RetrieveInfo   // 没有错误时则读数据
  P- r2 u( O6 U
- X" `6 Y) H' P' G0 N        // 如果出错，则进一步尝试使用ATAPI设备命令
) z8 a- o, y- @        CALL WaitWhileBusy
        CALL SelectDevice
3 u. ^0 M; r+ t+ f1 M3 {        MOV  BL, btAtapiCmd
- g5 l/ J; O& d) i" v% v- _        CALL SendCmd
        CALL WaitWhileBusy

        // 检查是否还出错
) G6 D. E& R* s' ~* q* a9 T; {        MOV  DX, dwBaseAddress
        ADD  DX, 7
        in   AL, DX
( O( s- o$ Z: Z0 V0 d( a        TEST AL, btBit00
6 v& a1 r9 Y' X  R( m$ S3 d8 U        JZ   RetrieveInfo   // 没有错误时则读数据
        JMP  LeaveRing0     // 如果还是出错，直接返回
' S$ i9 `- o( I* Z% X
/ N3 p" V9 E7 S: A' u( z0 P        // 读取数据
        RetrieveInfo:
& }" [3 X2 X0 U( n7 \0 S* E! E
9 u# s$ E- s% |( C        LEA  EDI, wOutDataBuf
/ ?& W- Z$ e- ]( V% X$ y1 P        MOV  ECX, 256
        MOV  DX, dwBaseAddress
8 i$ u# ]- J8 ~' h' g        CLD
5 @1 \0 i8 }. N
' j+ T3 ]9 i0 s        REP  INSW
- _% u4 K3 A2 s
- ?1 i' `+ A7 X9 {        // 退出Ring0代码
, U9 `5 ~3 q6 a6 X6 E+ a$ `        LeaveRing0:
; |  {; l* F  ]8 l
$ ~. M  G6 w5 p9 Q        POPAD
7 |( r; a. M( I. p% ^9 _( \        IRETD
$ H4 i' i! O5 c- C
        // 激活Ring0代码
        EnterRing0:
! G6 F9 i3 `( N* C
        // 修改中断门
9 V5 r3 V- D- G! j        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
        ADD EAX, nHookExceptionNo * 08h + 04h
        CLI
: W" t! J) e. R* ^
- f; j( S) w& Y: w& i        // 保存原异常处理例程入口
- y6 G6 d2 R9 p9 `4 h7 {! B        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
        MOV dwOldExceptionHook, ECX

. _! f2 Y5 ^/ q5 ~7 S* R  O" m# ]        // 指定新入口
; q4 T; e( p; B* T) _        LEA EBX, Ring0Proc
" D4 P0 o$ o0 |6 H( A        MOV WORD PTR [EAX-04h],BX
% o) c, Z2 Z' Y4 C. c2 ]        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX

        // 激活Ring0代码
8 R4 T# ?# x7 U- Y# ?  V/ z' p        INT nHookExceptionNo
9 |( e2 y( g! H2 s2 E
4 P9 c9 k. o) o/ {0 R/ y- z        // 复原入口
        MOV ECX,dwOldExceptionHook
        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
        STI
2 s, ^& d# t/ I# X( z3 P5 D    }
    if(!bIsFirst)
5 [5 v( m) P1 a" I' }. s2 f' P9 I3 z    {
        bIsIDEExist  = (bool)btIsIDEExist;
        bIsDiskExist = (bool)btIsDiskExist;
        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
( A% a3 [! M8 S}
5 Y3 N9 m* v. [: q//---------------------------------------------------------------------------
// 调用方法：
) i3 p* w0 h5 F( v( h5 ?1 r  lvoid __fastcall TForm1::Button1Click(TObject *Sender)
/ N% V; d4 ~( @7 j; a4 @! `1 B{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
# r1 Q& H  f+ x* ^}