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

天云上人

代码框架，你所要做的仅是修改WQL语句，具体可看MSDN。以下代码为简介起见，一次返回所有的CPUID或硬盘厂商系列号
3 z* O7 m, b" x9 v( ?5 g. p

1. 
   
2. #include "StdAfx.h"
   * L# Y6 a* y8 H7 s- _8 Q
3. #include ".\puiddisk.h"
   
4. #define _WIN32_DCOM
     X! V0 {& N+ L) S8 f
5. #include <iostream>
   0 t8 F) C# x% T! C
6. using namespace std;
   2 J# z6 k; p5 Q" F/ c
7. #include <comdef.h>
   
8. #include <Wbemidl.h>
   
9. 
   
10. # pragma comment(lib, "wbemuuid.lib")
    6 D) X/ B9 `) T8 n/ F
11. CpuIDDisk::CpuIDDisk(void)
    
12. {
    7 u/ A" m0 f8 W* p6 c6 \6 n
13.     GetInfomation();
    ) \% f( |" ]% f( ^& |9 _1 ]2 t0 _) F
14. }
    % n) n. r+ a( _$ F: Z# w! H
15. 
    
16. CpuIDDisk::~CpuIDDisk(void)
    
17. {
    8 P+ g+ \3 x1 `7 {( m
18. }
    
19. int CpuIDDisk::GetInfomation(void)
    
20. {
    
21.     HRESULT hres;
    : p$ ^; f2 m1 V/ o7 f1 C
22.     //步骤1：不是必须的，COM只须也只能初始化一次
    
23.      hres =  CoInitializeEx(0, COINIT_MULTITHREADED );
    ! @& |5 g1 ]1 n) ]
24.     if (FAILED(hres))
    % w4 k8 E/ q  ]1 u
25.     {
    
26.         return 1; //初始化COM异常：注意，COM只须也只能初始化一次
    / k& j3 |, E/ k# m, W) z
27.     }
    
28.     //步骤2：不是必须的，COM只须也只能设置一次
    ' M: x1 E* l7 `6 H
29.     //Set general COM security levels
    & n9 D4 `4 M0 W+ e
30.     hres =  CoInitializeSecurity(
    3 ^# Z) C7 R8 Q& m, n
31.         NULL,
    
32.         -1,                          // COM authentication
    
33.         NULL,                        // Authentication services
    + E, Q3 R0 t0 ?& h" Z; p* m
34.         NULL,                        // Reserved
    4 E; P* t7 o# N
35.         RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
    
36.         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
    
37.         NULL,                        // Authentication info
      s( U4 e$ M5 N: i9 F1 Z$ {
38.         EOAC_NONE,                   // Additional capabilities
    
39.         NULL                         // Reserved
    
40.         );
    
41.                      
    6 C9 W( v' O& M
42.     if (FAILED(hres))
    1 ~$ P- E' G  `* c( m
43.     {
    
44.         CoUninitialize();
    ; X& w& y' x* `
45.         return 1;                    // Program has failed.
    
46.     }
    
47.    
    
48.     //以上不是必须的，若已有“::COMInit();”，则要跳过
    ( W. _. ]; X: ^
49.     //步骤3： Obtain the initial locator to WMI
    
50.     IWbemLocator *pLoc = NULL;
    
51.     hres = CoCreateInstance(
    5 s1 l% E, u# P/ U6 y
52.         CLSID_WbemLocator,            
    
53.         0,
    2 t; U, l, q1 ^, j6 C: Y5 n2 u
54.         CLSCTX_INPROC_SERVER,
    9 V' F) R2 A7 N
55.         IID_IWbemLocator, (LPVOID *) &pLoc);
    
56. 
    3 K9 r3 L% g4 P/ t: ^+ u! ~
57.     if (FAILED(hres))
    9 h) f0 Q  ^- H! O& c6 U2 f* s6 f4 E
58.     {
    
59.         CoUninitialize();
    3 ~. K/ h1 H# P0 ]: W
60.         return 1;//Failed to create IWbemLocator object
    8 B5 q1 U+ Q: |- C7 S5 S
61.     }
    2 r2 @! t* H0 {' D
62. 
    
63.     //步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
    
64.     IWbemServices *pSvc = NULL;
    " j" l6 ?! q- c- {  X- r
65.     hres = pLoc->ConnectServer(
    
66.          _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
    
67.          NULL,                    // User name. NULL = current user
    ) V* p/ p+ ]* I' N2 V! [
68.          NULL,                    // User password. NULL = current
    ) p% |. \; @, C4 }( B6 ^0 K5 c
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.          );
    % K/ N& I( G5 Y, M
75.    
    
76.     if (FAILED(hres))
    5 }- n0 S- \; |) `5 n
77.     {
    
78.         pLoc->Release();     
    3 ]' p: c# P5 W3 ]: ^
79.         CoUninitialize();
      P0 B; W9 I! c3 m
80.         return 1;                // Program has failed.
    
81.     }
    3 |/ k2 l  [" C* a9 f
82.     // 步骤5： Set security levels on the proxy
    , }$ M$ b! I$ Q! H9 V
83.     hres = CoSetProxyBlanket(
    
84.        pSvc,                        // Indicates the proxy to set
    4 k1 L2 ^$ h1 f- L
85.        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
    
86.        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
    
87.        NULL,                        // Server principal name
    - n) H2 |8 ?9 V( b+ ^/ s* J8 {
88.        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
    ! e% f  U7 t5 D( E3 E* B4 ?$ o
89.        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
    
90.        NULL,                        // client identity
    
91.        EOAC_NONE                    // proxy capabilities
    5 n3 C% Q! b9 o% D5 a' m
92.     );
    
93. 
    
94.     if (FAILED(hres))
    
95.     {
    & j' q. H4 u% o$ o
96.         pSvc->Release();
    
97.         pLoc->Release();     
    
98.         CoUninitialize();
    
99.         return 1;
    3 Z3 {2 p1 w4 [
100.     }
     
101. 
     + |) F3 z: b1 x7 {9 K. _+ {
102.     // 步骤6：Use the IWbemServices pointer to make requests of WMI ----
     
103.     IEnumWbemClassObject* pEnumerator = NULL;
     & Y) L3 \$ f$ t% Z; S& c: O
104.     //计算CPUID
     
105.     hres = pSvc->ExecQuery(
     
106.         bstr_t("WQL"),
     
107.         bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
     
108.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
109.         NULL,
     % ~1 R0 L  O. G+ O, I2 ^
110.         &pEnumerator);
     # W, R( z7 g2 n8 t/ R1 j$ w# z0 P. c
111.    
     
112.     if (FAILED(hres))
     + ~! k* F$ E- i: w+ g
113.     {
     
114.         pSvc->Release();
     ; f6 @3 ]: ^* |5 Y& B1 p7 J* y
115.         pLoc->Release();
     
116.         CoUninitialize();
     3 H7 ]! _/ T' I" _) ?) N$ n$ h
117.         return 1;
     + b8 h- [5 j  H( e& \  y2 v% G
118.     }
     - F' P( M0 b6 x) \9 |
119.     // 步骤7：Get the data from the query
     
120.     IWbemClassObject *pclsObj;
     
121.     ULONG uReturn = 0;
     
122.     while (pEnumerator)
     7 g. @: F7 O8 G! k9 U5 P# t
123.     {
     2 B# h  }+ c1 |
124.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     7 u# q  \% i! O$ J
125.             &pclsObj, &uReturn);
     " @5 D# ?9 p2 @8 w1 h0 T
126. 
     
127.         if(0 == uReturn)
     ) f' f, v' h& q1 r, A2 q
128.         {
     
129.             break;
     + ]' n8 ]& y1 I4 ]# x5 U1 j2 V
130.         }
       \( v& n# R, l3 \) d
131.         VARIANT vtProp;
     ( u$ d9 Q9 F2 \, N/ z+ L
132.         VariantInit(&vtProp);
     
133.         hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
     9 ~5 S( Z$ C: }* p4 u+ P
134.         strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
     
135.     }
     
136. 
     
137.     //计算硬盘系列号
     ) b: s/ z9 P4 x( @/ V) r
138.     hres = pSvc->ExecQuery(
     
139.         bstr_t("WQL"),
     
140.         bstr_t("SELECT * FROM Win32_DiskDrive"),
     ( T9 q" d4 \2 v  b1 l8 ^
141.         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
     
142.         NULL,
     + D- Q, h8 B' q+ ~* w
143.         &pEnumerator);
     & l9 }9 \$ d' T# s
144. 
     ) P3 w/ t* G6 x3 L  T3 k+ @3 c: ?
145.     if (FAILED(hres))
     
146.     {
     
147.         pSvc->Release();
     0 g6 [* Q: T+ l
148.         pLoc->Release();
     ( C5 M) ~7 m- r# H
149.         CoUninitialize();
     # N( T1 T6 ~+ L2 F, i' W6 v$ X
150.         return 1;
     % u& [! r9 f6 c$ \
151.     }
     0 f$ x$ o3 w7 u" u, r( T3 r5 a; S9 m
152.     while (pEnumerator)
     8 o2 h9 v  l% @/ V+ l1 ~: b
153.     {
     
154.         HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
     
155.             &pclsObj, &uReturn);
     
156. 
     
157.         if(0 == uReturn)
     
158.         {
     
159.             break;
     $ g0 `( G/ |* o
160.         }
     + f# k9 ^  \  k% D/ a# f& J
161. 
     
162.         VARIANT vtProp;
     - @4 a2 [' _& n$ ?2 Z. |4 n
163.         VariantInit(&vtProp);
     
164.         hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
     " Q5 W  y0 X3 `6 s- A+ F
165.     strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
     # |5 X! K( C6 t( t0 O0 K# W- C
166.     }
     
167. 
     
168.     pSvc->Release();
     % i# p0 U- @$ t7 H8 Q
169.     pLoc->Release();
     " m( I+ D4 F4 P9 b
170.     pEnumerator->Release();
     , O, D) u1 H% {: c1 H4 }4 @
171.     pclsObj->Release();
     
172.     CoUninitialize();
     # P( u. B/ m( k; j7 B4 C% u2 _
173. 
     
174.     return 0;   
     
175. }
     3 l: J+ Q! P- O4 p6 E! D& C

复制代码

天云上人

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

* o2 y! d. y* s: y( E#include <WinIOCtl.h>
#include <stdio.h>

#pragma inline
5 {) J4 o- h/ J1 K0 u//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
. Q9 d+ A7 Q* f! }/ w! N#define DFP_GET_VERSION         SMART_GET_VERSION
/ d' ]- q' e' \#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

3 J% l  M+ R, s" c' V- K3 o0 s3 qconst int MAX_IDE_DRIVES = 4;
  D+ t( M& }8 m5 o
// SCSI专用变量
4 |  ]5 M8 v  N- w& I9 uconst 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
1 f+ ~9 b/ |* g# Gconst DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

typedef struct _SRB_IO_CONTROL
# r2 D  w$ D9 |: s' p0 T1 ]{
7 n: C9 }8 O. i4 [* F    ULONG HeaderLength;
0 ?2 r" ?& r' q    UCHAR Signature[8];
    ULONG Timeout;
    ULONG ControlCode;
- q, q( Q* h6 B. j) q/ I    ULONG ReturnCode;
    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
, \. s9 x' c1 S! s( `- i4 A
9 R+ S% t. \6 u7 j3 ~// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

! `. p  o; `. @2 R( D// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
5 i( l' P' _- q8 M8 |" A5 C8 A// 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函数
, v' W8 O* \% Y' Q4 ]& M8 [" `void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
6 H. X3 y# h4 l, s" D, v) evoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
//---------------------------------------------------------------------------
// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
{
    switch(Win32Platform)
    {
3 z. V" C  R3 r1 n: U: O6 D: x        case VER_PLATFORM_WIN32_WINDOWS:
6 C4 Y% r7 X( n+ N' d7 L4 i8 m            ReadPhysicalDriveOnW9X(pSerList, pModeList);
            break;
        case VER_PLATFORM_WIN32_NT:
            ReadPhysicalDriveOnNT(pSerList, pModeList);
            break;
- q, b* M3 Z  c. G        default:
            break;
    }
}
//---------------------------------------------------------------------------
( |" g- X) u7 k// ConvertToString
( w$ r7 }, Q' w6 g% R/ P* dchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
1 k- W9 m+ H! }0 {& }% l" }( z! A    static char szResBuf[1024];
7 [! R/ H( s+ w$ X( i6 t4 Z: ?. Y    int nIndex = 0;
    int nPosition = 0;
8 y) Q- l1 a8 a/ a
    // Each integer has two characters stored in it backwards
    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    {
5 ~/ N  y) z! @" S7 K' m  |        // Get high BYTE for 1st character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
& p* L- X  t) K: p$ _& _        nPosition++;
4 T: P. U" g% H& T
! k/ g" O4 q, {        // Get low BYTE for 2nd character
        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
% [# ], g0 f/ j( s1 y- f        nPosition++;
    }

    // End the string
    szResBuf[nPosition] = '\0';
4 @: p- W9 q  s& u9 \
/ t0 @; m. B: _/ m+ o# _    // Cut off the trailing blanks
    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
        szResBuf[nIndex] = '\0';
2 }; a& ^& r* k  D- o% j
/ D6 O0 k! V' C7 m( w, Z8 l9 o" B    return szResBuf;
}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
) |( U# B" ]$ B" m7 s' }! W//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
: J; A4 Y: x; v) F3 ?; ?' Z    // 输出参数
0 r+ p: z) c- |3 \: p* c' s, v$ I    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
9 }+ c3 f6 h1 O* ]6 [
) ?  \7 B3 D% p7 n% ?8 x& c) t    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
7 _) }$ t5 K6 y    {
        HANDLE hPhysicalDriveIOCTL;
        char szDriveName[32];

        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
        hPhysicalDriveIOCTL = CreateFile(szDriveName,
7 A8 U7 \/ A# {3 f( Y                        GENERIC_READ | GENERIC_WRITE,
* @8 g; \- X* ^: \: A  b9 E% j                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, 0, NULL);

        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
/ ]' Y* i; W4 u) ~6 o+ c. z% P8 |% Q        {
            DWORD dwBytesReturned = 0;
" j) @& Z- t. [* z            GETVERSIONOUTPARAMS gvopVersionParams;
8 h: J  U/ Z: i9 E" w3 m' n1 G% D5 N
            // Get the version, etc of PhysicalDrive IOCTL
            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

0 }- g0 ?3 q- L$ k  n5 m            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                    &dwBytesReturned, NULL))
, }3 P! u& W& f4 r2 [$ Q+ b- E            {
                continue;
5 \# u+ s( P6 o; [7 V; R            }

            if(gvopVersionParams.bIDEDeviceMap > 0)
' p* F2 h% w: b$ @' A( u9 q            {
                // IDE or ATAPI IDENTIFY cmd
                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
2 Q# H6 y* T7 N; E: O* l7 b                // 具体所得结果请参考头文件中的说明
4 {' x; x: d1 B( Q/ i                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
, j! j: d  W* w: T. n                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
4 v+ E# \" V0 |# Q$ T                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

3 T# m/ N5 R; Z                if(DoIdentify(hPhysicalDriveIOCTL,
9 j9 m0 y& E* R# I& x                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
                {
# d$ c3 j, c; j& t' P                    DWORD dwDiskData[256];
                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
" i8 ?+ J1 B. h/ Y+ q1 ?                    char szSerialNumber[21];
. N+ C& x. d6 t3 Q# p" O% S                    char szModelNumber[41];
% @' ?+ d8 @: J
- @) u; _  C, c. o- q                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
2 Q( ~' T& _2 l' q3 R* r! j2 E0 ^                    for(int i=0; i < 256; i++)
                        dwDiskData[i] = pIDSector[i];
  ~2 ~1 A' u3 A& Y  J) K                    // 取系列号
5 g& {6 W1 e3 G* c, f% r7 d                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                    // 取模型号
                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
# p* P& r  h4 O8 U0 ]7 \) x7 V# D                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                    pSerList->Add(szSerialNumber);
                    pModeList->Add(szModelNumber);
                }
            }
8 `5 ~8 B+ U- A( T$ |9 l            CloseHandle (hPhysicalDriveIOCTL);
        }
3 }" C5 Q3 Y) S2 _& A( C    }
}
, q& D; f9 Y$ C//---------------------------------------------------------------------------
+ F0 l: |7 E4 r: ?// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
- e/ p' H/ {+ P% \$ Y, U, K              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
/ h% l- F: ~2 _" H$ C              PDWORD pdwBytesReturned)
; }: K$ c# ?4 v{
    // Set up data structures for IDENTIFY command.
6 K$ @8 l& F7 c$ H3 ]* x. _8 i: p    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
    pSCIP->irDriveRegs.bFeaturesReg = 0;
) b7 j6 L9 e+ o* P" a' u    pSCIP->irDriveRegs.bSectorCountReg  = 1;
    pSCIP->irDriveRegs.bSectorNumberReg = 1;
' _3 P! V: }7 r2 t: I4 K    pSCIP->irDriveRegs.bCylLowReg  = 0;
    pSCIP->irDriveRegs.bCylHighReg = 0;

, _/ Z& {1 q2 p9 X$ \% u    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
9 O" x. t: r( Z# {  Z. j' v" F    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

% T3 c' u! e: Y" W: I    // The command can either be IDE identify or ATAPI identify.
' H3 F4 M. j0 k& E6 J    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
    pSCIP->bDriveNumber = btDriveNum;
1 o' B& w" b3 ^6 D    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

7 \' e; n1 |0 N( s    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
           (LPVOID)pSCIP,
           sizeof(SENDCMDINPARAMS) - 1,
           (LPVOID)pSCOP,
           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
           pdwBytesReturned, NULL);
}
6 p8 t$ Y* [8 @) L+ l/ V/ C//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
; a; q+ r- c; [( {//---------------------------------------------------------------------------
) H6 z2 V7 _4 S% Q1 p6 C// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
    WORD wOutData[256];
3 ?, W0 F" R) W! r' v    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
6 r" z* S  R# L
    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
9 ]. g1 U2 x( ]    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
    // 避免蓝屏的出现。（期待高人能指出原因）
4 B# e/ b+ l, b    for(int nDrive = 0; nDrive < 8; nDrive++)
    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
6 l: a" Q6 Y' o" h0 C        bool bIsIDEExist;
# T: r' F  C: {5 I2 m  v$ W; ?        bool IsDiskExist;
( i2 p. I" Q2 k. y/ N& z
        switch(nDrive / 2)
% B9 i- m1 X/ }+ f. u6 x0 k        {
            case 0: dwBaseAddress = 0x01F0; break;
" D2 D! }9 m- O- O( j* C& f$ K            case 1: dwBaseAddress = 0x0170; break;
            case 2: dwBaseAddress = 0x01E8; break;
1 f/ e7 q  v6 x( b5 |: j: @            case 3: dwBaseAddress = 0x0168; break;
8 |8 F  S* [( F, S3 P6 u5 R        }

        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
+ R7 L# V: G- j0 D! t6 e- J% c* \
4 e* ?% {! B* C6 @. P: c. z' ~        // 进入Ring0
        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
                bIsIDEExist, IsDiskExist, wOutData);
/ w+ x' I8 `1 y0 K    }
- x) A/ ~. L% x
7 B5 w" ~9 I4 k) [9 m$ l( l    // 开始读取
    for(int nDrive = 0; nDrive < 8; nDrive++)
8 ]  }: f4 M/ V, [  L- c    {
        WORD dwBaseAddress;
        BYTE btMasterSlave;         // Master Or Slave
  V7 s9 v0 ]1 c; ], v+ x* {( Y        bool bIsIDEExist;
6 V7 C' t/ \( D8 Z  H# g$ o( o        bool bIsDiskExist;
% b  D- q" I; [& u1 I3 p        switch(nDrive / 2)
        {
            case 0: dwBaseAddress = 0x01F0; break;
            case 1: dwBaseAddress = 0x0170; break;
  ~) s1 `$ T* ~1 S1 t) p  y5 O% r* P            case 2: dwBaseAddress = 0x01E8; break;
: l4 r7 P# [* }  V# I            case 3: dwBaseAddress = 0x0168; break;
; M) Q1 m+ }, W& _        }
& E2 S5 v# v0 w' j" s7 s
% {- C8 t5 T! }        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
% k/ o; z4 E) C$ `
        // 进入Ring0
        bIsIDEExist  = false;
        bIsDiskExist = false;
        ZeroMemory(wOutData, sizeof(wOutData));

4 @: a& z; @- s0 E        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
                bIsIDEExist, bIsDiskExist, wOutData);
) Z. F) w8 C1 [. K
        if(bIsIDEExist && bIsDiskExist)
        {
& o, G. w( T: F  X* H& i) u" x5 l# K; @            DWORD dwDiskData[256];
            char  szSerialNumber[21];
1 Q6 l1 T; \4 N. v& M            char  szModelNumber[41];

            for(int k=0; k < 256; k++)
                dwDiskData[k] = wOutData[k];

            // 取系列号
            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
8 G0 `8 E; J4 @) t7 C            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
0 m& W3 w" [, C+ e% c" a+ z/ Z3 n
+ t* |/ W+ v+ R            // 取模型号
            ZeroMemory(szModelNumber, sizeof(szModelNumber));
            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
% W9 G: I  ^% n& _  S  k1 |
& Y: g& b# F# C. ]) ~2 u            pSerList->Add(szSerialNumber);
            pModeList->Add(szModelNumber);
        }
    }
1 T$ o" k$ X$ y' t5 t0 I    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
) M% o1 b/ M% Q! X// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
5 A: o" t. h; O//---------------------------------------------------------------------------
4 {: F2 s. E' A" r" i* o# V1 t1 M// ReadPhysicalDriveOnW9X_Ring0()
, u7 Z  N5 |% a2 F: \//
// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
' G: W0 x' C# D/ L// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
: L- r* O' I' l{
    BYTE  btIDTR1[6];
: R: U) {0 ^0 G+ Z1 P    DWORD dwOldExceptionHook;
    const int nHookExceptionNo = 5;

7 V' w' p$ x, m% N/ i) ~    BYTE  btIsIDEExist = 0;
: f) U' F5 T  _8 D7 s    BYTE  btIsDiskExist = 0;
( w6 T$ }$ G$ M* A6 H7 X$ ^    WORD  wOutDataBuf[256];
- j0 K/ g# j% G$ e* X
3 ]+ n# w4 X! G1 w9 L    BYTE  btIsFirst = (BYTE)bIsFirst;
9 Y0 D4 o5 A5 f4 Z/ P
    const BYTE btBit00 = 0x01;
    // const BYTE btBit02 = 0x04;
    const BYTE btBit06 = 0x40;
/ N' r6 R: p& S! n, _) p    const BYTE btBit07 = 0x80;
5 E" J; U, Y: L6 i% ^    // const BYTE btERR  = btBit00;
7 Q" o* ^' J8 K) Y$ H    const BYTE btBusy = btBit07;
+ k4 B5 ?- W0 [# y7 W    const BYTE btAtaCmd   = 0xEC;
    const BYTE btAtapiCmd = 0xA1;
8 I4 I) a9 S3 O% c" i& _
# L- ?# s, H* I9 I$ ^/ t- R$ w    __asm
$ M+ I' y9 `$ S    {
        // 必须先执行这条语句
        JMP EnterRing0

% R* c1 G- [! X. y9 y8 J" n* G& T        // 定义过程
4 ^4 N% C4 X% D) Z        // 等待IDE设备直到其不为忙为止
6 j1 f7 A! r$ j* E( s        WaitWhileBusy proc

        MOV  EBX, 100000
2 ?3 A- ?  i( y& G5 }$ Q+ U- Q: B        MOV  DX, dwBaseAddress
: O+ l4 }( y1 W6 `. K        ADD  DX, 7
' h# _3 `4 P' R  q! F
        LoopWhileBusy:

        DEC  EBX
        CMP  EBX, 0
        JZ   Timeout
        in   AL, DX
        TEST AL, btBusy
        JNZ  LoopWhileBusy
3 j% K2 f* j! X9 C        JMP  DriveReady
8 p9 C% N# K) m- t
8 c) |  Y, c0 m        // 超时，直接退出
1 m& C3 R- `" U        Timeout:
! |) c/ ]. P9 ?' }        JMP  LeaveRing0
        DriveReady:
        RET
        ENDP   // End of WaitWhileBusy Procedure
! d+ a* i1 {4 }) z/ a3 i
' l4 H1 C2 M+ R6 j* v        // 设置主盘和从盘标志
8 K0 B. g6 u" [: e6 V        SelectDevice proc
9 x$ U  L+ K0 |
        MOV  DX, dwBaseAddress
5 T- X  u1 N2 o5 s. F. x9 R        ADD  DX, 6
5 j. C/ a. ~& }1 h8 A4 V        MOV  AL, btMasterSlave

        out  DX, AL
6 m& {+ D" D4 w        RET

        ENDP  // End of SelectDevice Procedure

        // 向IDE设备发送存取指令
- u. R& a/ j" d/ _        SendCmd proc

% i% A6 @, W/ l2 [" _        MOV DX, dwBaseAddress
        ADD DX, 7
) o. _1 E: @2 i4 i5 c6 Y( m: f+ Y        MOV AL, BL // BL是主从盘标识，在过程外设置
        out DX, AL
        RET
        ENDP  // End of SendCmd Procedure
7 J- x# U) i5 @, h8 Y
        // Ring0代码
        Ring0Proc:
7 k! U9 ?+ J( I& H8 e( ?        PUSHAD
" e, ]4 i4 C- n! o3 ]7 e        // 查询IDE设备是否存在
4 v/ `( ~/ l! t( Z        MOV DX, dwBaseAddress
$ S- i( g3 v! ^" k5 N& M7 I& \        ADD DX, 7
        in  AL,DX

        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
        CMP AL,0xFF
$ r- H" y; j2 P& V        JZ  LeaveRing0
# s' v- J1 `5 Q9 p        CMP AL, 0x7F
        JZ  LeaveRing0

        // 设置IDE设备存在标志
) ]9 Q1 U8 B' L& J7 A% F        MOV btIsIDEExist, 1

, U4 c# w/ p3 i' Z" k6 _' A        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
- ^6 G" C; |- ^8 G2 F! K        CALL WaitWhileBusy
( f; g' ?( A5 s5 U" n        CALL SelectDevice

1 S- M9 n; H9 x3 {, D9 J% g, j        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
  U' ?' G+ |9 J4 q. w( M0 F        CMP  btIsFirst, 1
        JZ   LeaveRing0
# }: x$ R, o0 C% P2 y. ~
0 M- D& b* t7 \) G+ y% G' z8 L8 U        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
" ^& L+ T/ S  v" z; M% [        CALL WaitWhileBusy
& U/ r0 ]% D  `9 l0 R
        // AL的值等于cBit06时，不存在驱动器，直接返回
( N. j( U4 x3 a. v* ?% L        TEST AL, btBit06
        JZ   LeaveRing0
4 n2 {5 D- W& `1 U  s) C& v  h
0 }) U, A# y) a4 e! \3 x$ f        // 设置驱动器存在标志
6 Y6 |/ R' G' _5 b8 K        MOV  btIsDiskExist, 1

        // 发送存取端口命令
        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
& S* O( f8 R  L$ v- ^7 t! W        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
" p$ v7 x3 u5 ?: l! m        CALL WaitWhileBusy
( L, H7 v3 ]8 Z: b* E        CALL SelectDevice    // 设置主从盘标识
        MOV  BL, btAtaCmd      // 发送读取命令
        CALL SendCmd
        CALL WaitWhileBusy

5 h" ]" ^( a6 l9 i, L        // 检查是否出错
* Y" M3 D* Y5 a        MOV  DX, dwBaseAddress
  Y! Y0 y: ^7 C* q        ADD  DX, 7
  ^7 C+ p# ~* p/ w: D6 w3 Z# @: _$ \
        in   AL, DX
; d3 B6 Y4 J; z& W# L1 Y
        TEST AL, btBit00
8 j7 f0 ?1 L, z# h4 X4 _$ g        JZ   RetrieveInfo   // 没有错误时则读数据

; _$ k5 T- x" P/ N+ {) O+ U        // 如果出错，则进一步尝试使用ATAPI设备命令
/ Z5 B3 B6 ^; n" ~& i        CALL WaitWhileBusy
        CALL SelectDevice
        MOV  BL, btAtapiCmd
        CALL SendCmd
        CALL WaitWhileBusy

        // 检查是否还出错
        MOV  DX, dwBaseAddress
        ADD  DX, 7
        in   AL, DX
5 Y) s- z% c: b' f4 l        TEST AL, btBit00
% ]2 O) b' E! Q. J* K4 y3 ]        JZ   RetrieveInfo   // 没有错误时则读数据
" s; z* w$ d+ @        JMP  LeaveRing0     // 如果还是出错，直接返回
% B* l' @! J, U1 l4 W* s
$ D* e% p- H; Q" W2 t, i* L        // 读取数据
+ K5 G" q  l9 C2 P5 f+ `        RetrieveInfo:
7 o8 c: @& e% G0 b9 e, E
        LEA  EDI, wOutDataBuf
+ ]  _. @, [: ]0 ~5 [        MOV  ECX, 256
9 n; d: }+ p+ I4 N3 s* ^1 Y. A$ Q        MOV  DX, dwBaseAddress
9 l- X" I7 n( I" w8 D0 R        CLD
- T$ v3 r; u! A+ `& D
        REP  INSW
4 L( e$ E3 P" k* E; k% Y# n6 j
        // 退出Ring0代码
5 v8 i. k- c, S' P5 L        LeaveRing0:

        POPAD
% o, |! f* R, y. D6 Z+ i        IRETD

8 F0 _6 I' P9 Y$ m9 Q        // 激活Ring0代码
        EnterRing0:
2 N5 b' \; j' @
        // 修改中断门
+ o+ K8 u% l  D/ N$ p0 G; p        SIDT FWORD PTR btIDTR1
        MOV EAX, DWORD PTR btIDTR1 + 02h
1 E, J# ?3 v9 Q  s        ADD EAX, nHookExceptionNo * 08h + 04h
: X  ^) O! g0 ^, t        CLI
8 t- |, X8 d. c4 V4 U
        // 保存原异常处理例程入口
3 F0 }2 b9 Z$ X/ M9 u$ m+ ]+ J/ @        MOV ECX, DWORD PTR [EAX]
        MOV CX, WORD PTR [EAX-04h]
; ?7 o  g: i1 i4 A        MOV dwOldExceptionHook, ECX
, H& I3 T6 d5 a0 z; g) S
        // 指定新入口
        LEA EBX, Ring0Proc
, W& y/ r& w' i) k4 V. j& o/ x# s        MOV WORD PTR [EAX-04h],BX
        SHR EBX, 10h
        MOV WORD PTR[EAX+02h], BX

$ @. e7 B6 R' P& Y$ k2 ~        // 激活Ring0代码
        INT nHookExceptionNo
6 \; {( E# K# r, Z7 T& u% q1 x" y' E
        // 复原入口
        MOV ECX,dwOldExceptionHook
' ]* ?2 L( u* ~6 \4 B5 a        MOV WORD PTR[EAX-04h], CX
        SHR ECX,10h
        MOV WORD PTR[EAX+02h], CX
  V" \4 T; Q7 |; k5 n        STI
    }
2 `% L. j. Y( _( N* [/ U) [& }1 v    if(!bIsFirst)
    {
9 |' Z7 g; H5 X% W' q- i  z. v        bIsIDEExist  = (bool)btIsIDEExist;
" D% m3 m) X3 n) w" u9 P  ?6 b        bIsDiskExist = (bool)btIsDiskExist;
6 X2 Y) _# R0 F& L1 u        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
    }
0 r0 U7 d/ }% y& T}
% ^* L9 j# b# N9 c0 }0 x  |) O) |//---------------------------------------------------------------------------
" Y' c4 `, ~& T4 I  U$ C0 O// 调用方法：
6 ?* }7 A) f& C8 f. o, Qvoid __fastcall TForm1::Button1Click(TObject *Sender)
9 D1 ]4 `+ v5 i  P0 j{
    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
4 u! k6 g5 r- x$ g. t}
( U0 w7 f. n5 }3 _+ B