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

天云上人 · 发表于 2008-1-6 19:59:06

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

3 {. `2 q8 z3 z, z {6 C! F
#include "StdAfx.h"8 d0 S* _, H" x
#include ".\puiddisk.h"
6 K! N8 c- n N3 H: s& [
#define _WIN32_DCOM
, E% U6 I$ t s* G D) [* K; T
#include <iostream>
: C1 U7 l0 \, }8 d* C9 g
using namespace std;
3 \! B( L: D% W4 Q+ j
#include <comdef.h>
% E% d6 D8 B* l% S; n% [: x, N
#include <Wbemidl.h>
1 ?8 K) d5 g7 e/ R& X1 C' f1 m
% e; n2 z7 R# j: ~
# pragma comment(lib, "wbemuuid.lib")6 t% G+ X* M/ E( _# q6 ~; f3 j
CpuIDDisk::CpuIDDisk(void)
6 K2 _- u8 m9 ^1 H* [7 C
{
0 Y" ^% S0 `/ M6 I6 V" V% F
GetInfomation();- }) S7 w: o( l8 Z- P
}
4 U, Z2 e. C8 g7 b
! T" k9 c8 s( Z4 H* m' @2 W" o5 t
CpuIDDisk::~CpuIDDisk(void)% J2 ^8 h4 G a! }; F
{
D* l+ B( |: G, h$ Q
}6 m0 D/ X& B6 V/ U
int CpuIDDisk::GetInfomation(void): k) a* `" d5 D+ ?: V
{
* ?5 Z2 l1 h# Y# r- m6 b0 \
HRESULT hres;
; Z8 t1 n. F* d. f$ Y b& |1 I
//步骤1：不是必须的，COM只须也只能初始化一次
f0 V0 r1 c2 R8 e: [
hres = CoInitializeEx(0, COINIT_MULTITHREADED );
( `3 e. U4 ]8 p# r" D# u
if (FAILED(hres))2 y5 l/ U% I3 G9 l9 k' K
{
4 [4 i( k) e- n
return 1; //初始化COM异常：注意，COM只须也只能初始化一次
; e6 a9 n: g1 W* z B* C9 W
}
% l. u; D5 z0 E6 ]
//步骤2：不是必须的，COM只须也只能设置一次* g. s' l; f# ~% v, i5 p, R
//Set general COM security levels+ g7 V+ @& j, G9 o3 z; R% e
hres = CoInitializeSecurity(
9 G, P2 r- D h9 ^
NULL, ! R: y0 f' r B( b# e9 B. c
-1, // COM authentication
, M( |! l) t" V/ i9 j; n |( x
NULL, // Authentication services
- {4 ?2 V1 o1 M. U, F
NULL, // Reserved- m- \4 S* b6 J. G
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication j5 c; r5 S, j5 C6 _9 p7 B
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation ; C1 x0 W1 V1 e* C) w( Y
NULL, // Authentication info
) {% j, K5 C c( T9 Y" e2 y0 w
EOAC_NONE, // Additional capabilities 9 _5 g# J8 e- p# ~4 ^
NULL // Reserved. Y/ U$ \' W/ ?* ^0 A0 f
);4 M( Y1 I" Q9 m$ H! Q( m+ l% Z
E2 r; d$ _5 ~0 S/ r- C
if (FAILED(hres))0 H3 e* X; [7 r A
{
5 ?1 _5 m! o" Q3 T& R
CoUninitialize();! `3 }" j+ ~: p& v! R( ?9 V
return 1; // Program has failed.
- z0 }$ W3 a' g3 i; y
}3 K4 r2 N& P) B ~/ u V
! U: N/ `7 {- e$ q- d3 {' k
//以上不是必须的，若已有“::COMInit();”，则要跳过3 q/ y- ?8 v1 ]5 \; C# G/ k
//步骤3： Obtain the initial locator to WMI " l- K3 w: E: d# x3 {; ?& |$ S2 f5 N
IWbemLocator *pLoc = NULL;% o1 B& J$ @7 |( G) s- _
hres = CoCreateInstance(
( E( h: |8 H2 a( d8 j# f/ a; J
CLSID_WbemLocator,
0 N* E1 u2 v$ S0 ?
0, . J8 d$ p, p0 M
CLSCTX_INPROC_SERVER, * U4 H; J# O' k4 G
IID_IWbemLocator, (LPVOID *) &pLoc);
w9 X+ I! D0 \
: C9 Q: P7 I- G2 D, a! q* {
if (FAILED(hres))
2 p: g* v2 }, q3 X7 N( ~
{" Q2 E B& S( j) S% b
CoUninitialize();! F8 X+ F( Q0 o. E
return 1;//Failed to create IWbemLocator object V H( o6 `! n. c3 [. H3 r
}$ t, J- w4 A/ n2 D# X5 r0 L
9 k" b$ S% ^* s4 T% f1 D% R! k8 u+ ]
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
% ` v0 L4 l0 j9 }/ k
IWbemServices *pSvc = NULL;! ^, n; @$ L7 H; B7 g
hres = pLoc->ConnectServer(
" x+ h; Q" X D# b: I' |5 k
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
8 }1 K+ ?/ @, n6 |7 [: w- q9 q% }
NULL, // User name. NULL = current user" U' I7 ]. Q0 n" N
NULL, // User password. NULL = current
$ ^% E. s, D& M3 N( S3 V
0, // Locale. NULL indicates current! F( a6 n& s8 z" r0 I" l9 p
NULL, // Security flags.
' B) {& A7 i/ j7 }" x/ w8 B
0, // Authority (e.g. Kerberos); s- a) y# Z) J# B
0, // Context object P+ R) \* L: ?( ]( `
&pSvc // pointer to IWbemServices proxy
% m, G3 `0 S$ P Z
);
. o# Q) q; y9 q5 e! l9 G
4 d+ X, m, |8 T% K# K( W
if (FAILED(hres))3 ?" u+ R5 j, h7 q
{3 @. S9 S. Y& l5 i; a
pLoc->Release();
6 L$ s+ ?; s1 M- y
CoUninitialize();: i, w: C4 O, \2 t
return 1; // Program has failed.& w: y S. f8 r7 y
}
4 a! T) n5 L/ Z6 r# P9 |7 \
// 步骤5： Set security levels on the proxy
( L* ^, V d C9 G
hres = CoSetProxyBlanket(
: j. s3 p1 L2 S( u. q: d `- m
pSvc, // Indicates the proxy to set
! l1 Y; W$ \- @$ L
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx% I- v7 b+ Y8 \
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx' ^% K- N+ m4 P* H" m' x
NULL, // Server principal name
% C& g4 A! A) g* _- q& R( L' L, {
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
$ f; H; j1 J1 H" |) ~0 B
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx; M# U8 Q7 X! o
NULL, // client identity
& T7 c& Y! e# }! c, [# r
EOAC_NONE // proxy capabilities
2 B& e+ y' L$ V$ d) c. Q
);
! e A, `# D! |, Q( a
6 S/ `* A, V/ c5 C3 p7 ~4 `
if (FAILED(hres))
) F5 Z# h, W' k! u* c( S5 n( r
{+ |3 F# \: y/ r Y W R
pSvc->Release();# d2 x* u" e7 a- t/ v; q7 W
pLoc->Release(); . e' S. f$ t/ e* k5 G) `7 a; L
CoUninitialize();
: O* z2 S" F6 R" ?
return 1; * f5 |0 G& X' _: X
}' Q2 U1 { w+ R7 _3 q
* Y9 h/ C1 P. b. c6 M/ _! {
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----2 a1 `9 b0 E& {) j, S$ P
IEnumWbemClassObject* pEnumerator = NULL;
! w+ \; B# e4 L" V: v6 j4 s p7 k
//计算CPUID( w8 r. Z3 C; D Y
hres = pSvc->ExecQuery(
z4 s; V' X1 U5 f+ w
bstr_t("WQL"), & A2 R% o# |: O- A* Z, ^& A
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
- |9 E, E o; J& w4 ?, P
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
: O0 Q( t: u# f# c' u
NULL,( L' t8 A: A5 v3 p
&pEnumerator);+ E* F( H" ?# {+ b, B9 R) h) `6 `; y
' `' m: j+ |' \3 e; X9 z
if (FAILED(hres))# p7 A) l$ O/ V2 [
{
" V9 z8 j3 e: g1 C* ~" `
pSvc->Release();5 s6 n9 F4 ^1 J% N
pLoc->Release();
5 g7 m) `5 F4 m0 N4 S
CoUninitialize();
+ Q$ N0 a2 Y1 B/ c$ v Z( v$ J
return 1;5 f% {% q9 N' p/ @! |7 S F# J
}
& M* O, k6 u7 x0 [/ B
// 步骤7：Get the data from the query
, \; q6 F- K0 h0 f, Z
IWbemClassObject *pclsObj;& ]& `8 n" y8 L/ z
ULONG uReturn = 0;/ R4 ^/ P! R9 L- h3 n+ P/ |- `1 v
while (pEnumerator)" O2 i! S7 A+ i# u" v
{& ~* J3 l$ `0 V6 O0 s9 e3 c
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, ! h v5 V O" X1 V5 ?* e
&pclsObj, &uReturn);
a% a' c3 J+ T7 J- F
: J0 I! b# e, V# o- h
if(0 == uReturn)
/ M" i( E6 ~$ |, s% A% J3 y# z
{
4 u/ d4 c- G* `. k: p
break;4 P, A, n! \& I# j1 p
}
, z+ x4 \) C1 p2 H, s
VARIANT vtProp;
% ]3 J3 v$ A( P2 E4 I# s
VariantInit(&vtProp);
' E+ l: ]6 o0 }' H4 _
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
! O1 \% u9 M5 U# z) i. y( U3 ^
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
7 m' U6 Z" y m% k9 h3 T0 T
}
+ g# J9 v4 v r; M' _, e
F0 x _0 }; i. d6 l
//计算硬盘系列号# y. Z0 M2 u- O* ^1 L' {# h
hres = pSvc->ExecQuery(" Z1 [: V4 X, v( d6 E4 i% `
bstr_t("WQL"),
/ N3 P. @" N# y9 R' h
bstr_t("SELECT * FROM Win32_DiskDrive"),5 `+ r2 M" E+ \
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
6 }. t; y8 R% f/ a) y
NULL,+ c' W9 \5 M% m# R; K4 R/ c2 J0 F
&pEnumerator);" M: |% a- g5 |3 u ^8 K
$ N7 j9 v+ I3 [9 ]) m ^
if (FAILED(hres))
4 @& u! l: ~ \6 T+ r% P, ~6 B
{8 P" H: i( V0 ^) j8 h
pSvc->Release();
/ N/ N8 U# Q" C$ w1 r7 X
pLoc->Release();
7 [9 X6 L: f3 I$ M1 F9 y [
CoUninitialize();( |2 [& g) U, d& \; F; g5 P- \
return 1;
: B3 t( [) D: Z3 @) |/ p" h9 i
}
4 {- A# L8 q* s/ _
while (pEnumerator); _+ h$ J, Z) }7 }0 L9 {& X7 X/ s
{
( V( f) C3 h! e6 U" `- I6 G
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
7 _& a3 q' L$ E( c% ^8 ~
&pclsObj, &uReturn);9 U( T; C, U2 T' x' v
+ L3 V- L! y9 `) \1 h. [- m5 w7 W
if(0 == uReturn); u3 n" v" k; u7 {% k
{
" w# U: f: g+ j8 z- ?9 V- N
break;
9 ~+ ~! x1 q: o- h: D( o1 D. m& E
}
, a& m; b% h9 N" X R& W
% t: |, P/ X% A1 Z: k/ n
VARIANT vtProp;# D9 {+ q8 t4 Q
VariantInit(&vtProp);
- ^8 P% I4 V3 i' k9 |
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
, E/ Z k7 U% p- b
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);' d3 Y% u4 K% x! _4 b8 Y
}& x) o7 Z& T9 K4 {% }' r
. H" @5 r' U" u" X+ P2 f! ?" F% I9 ?
pSvc->Release();, @5 m* Y+ Z' O* ^( d0 |0 U
pLoc->Release();
1 ?! N9 [! f- F4 P/ o( a. ? D
pEnumerator->Release();; O( P6 l' u& d2 [/ [
pclsObj->Release();
) B- f' M* N7 @5 E0 z1 m! e
CoUninitialize();$ \; V% [0 [" d0 x+ i+ Y: X5 {
* V* h& ]% U* y% X
return 0; 3 K5 l0 x+ M4 N/ \+ v
}
# M! h3 j: `$ e1 r. y0 Y4 i& r* {

复制代码

天云上人 · 发表于 2010-10-11 19:21:05

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

#include <WinIOCtl.h>
#include <stdio.h>

#pragma inline
//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
#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设备的命令
const WORD IDE_ATA_IDENTIFY = 0xEC; // 读取ATA设备的命令

const int MAX_IDE_DRIVES = 4;

// SCSI专用变量
const 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;

typedef struct _SRB_IO_CONTROL
{
ULONG HeaderLength;
UCHAR Signature[8];
ULONG Timeout;
ULONG ControlCode;
ULONG ReturnCode;
ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;

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

// 辅助函数
char *__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函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __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)
{
      case VER_PLATFORM_WIN32_WINDOWS:
         ReadPhysicalDriveOnW9X(pSerList, pModeList);
         break;
      case VER_PLATFORM_WIN32_NT:
         ReadPhysicalDriveOnNT(pSerList, pModeList);
         break;
      default:
         break;
}
}
//---------------------------------------------------------------------------
// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
static char szResBuf[1024];
int nIndex = 0;
int nPosition = 0;

// Each integer has two characters stored in it backwards
for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
{
      // Get high BYTE for 1st character
      szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
      nPosition++;

      // Get low BYTE for 2nd character
      szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
      nPosition++;
}

// End the string
szResBuf[nPosition] = '\0';

// Cut off the trailing blanks
for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
      szResBuf[nIndex] = '\0';

return szResBuf;
}
//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
// 输出参数
BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
{
      HANDLE hPhysicalDriveIOCTL;
      char szDriveName[32];

      sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
      hPhysicalDriveIOCTL = CreateFile(szDriveName,
                     GENERIC_READ | GENERIC_WRITE,
                     FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                     OPEN_EXISTING, 0, NULL);

      if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
      {
         DWORD dwBytesReturned = 0;
         GETVERSIONOUTPARAMS gvopVersionParams;

         // Get the version, etc of PhysicalDrive IOCTL
         ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

         if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                  NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                  &dwBytesReturned, NULL))
         {
            continue;
         }

         if(gvopVersionParams.bIDEDeviceMap > 0)
         {
            // 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
            // 具体所得结果请参考头文件中的说明
            btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                     IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
            ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
            ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

            if(DoIdentify(hPhysicalDriveIOCTL,
                  &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                  (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
            {
                  DWORD dwDiskData[256];
                  USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                  char szSerialNumber[21];
                  char szModelNumber[41];

                  pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                  for(int i=0; i < 256; i++)
                     dwDiskData[i] = pIDSector[i];
                  // 取系列号
                  ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                  strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                  // 取模型号
                  ZeroMemory(szModelNumber, sizeof(szModelNumber));
                  strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                  pSerList->Add(szSerialNumber);
                  pModeList->Add(szModelNumber);
            }
         }
         CloseHandle (hPhysicalDriveIOCTL);
      }
}
}
//---------------------------------------------------------------------------
// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
            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;
pSCIP->irDriveRegs.bCylLowReg  = 0;
pSCIP->irDriveRegs.bCylHighReg = 0;

// Compute the drive number.（主盘和从盘所对应的值是不一样的）
pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

// The command can either be IDE identify or ATAPI identify.
pSCIP->irDriveRegs.bCommandReg = btIDCmd;
pSCIP->bDriveNumber = btDriveNum;
pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
         (LPVOID)pSCIP,
         sizeof(SENDCMDINPARAMS) - 1,
         (LPVOID)pSCOP,
         sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
         pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
WORD wOutData[256];
SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

// 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
// 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
// 避免蓝屏的出现。（期待高人能指出原因）
for(int nDrive = 0; nDrive < 8; nDrive++)
{
      WORD dwBaseAddress;
      BYTE btMasterSlave;       // Master Or Slave
      bool bIsIDEExist;
      bool IsDiskExist;

      switch(nDrive / 2)
      {
         case 0: dwBaseAddress = 0x01F0; break;
         case 1: dwBaseAddress = 0x0170; break;
         case 2: dwBaseAddress = 0x01E8; break;
         case 3: dwBaseAddress = 0x0168; break;
      }

      btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

      // 进入Ring0
      ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
            bIsIDEExist, IsDiskExist, wOutData);
}

// 开始读取
for(int nDrive = 0; nDrive < 8; nDrive++)
{
      WORD dwBaseAddress;
      BYTE btMasterSlave;       // Master Or Slave
      bool bIsIDEExist;
      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;
      }

      btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

      // 进入Ring0
      bIsIDEExist  = false;
      bIsDiskExist = false;
      ZeroMemory(wOutData, sizeof(wOutData));

      ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
            bIsIDEExist, bIsDiskExist, wOutData);

      if(bIsIDEExist && bIsDiskExist)
      {
         DWORD dwDiskData[256];
         char  szSerialNumber[21];
         char  szModelNumber[41];

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

         // 取系列号
         ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
         strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

         // 取模型号
         ZeroMemory(szModelNumber, sizeof(szModelNumber));
         strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

         pSerList->Add(szSerialNumber);
         pModeList->Add(szModelNumber);
      }
}
SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
//---------------------------------------------------------------------------
// 为防止不负责任的转载者，在此注明原出处信息，请见谅。
// 资料收集整理：ccrun(老妖)，欢迎光临C++Builder研究: http://www.ccrun.com
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X_Ring0()
//
// 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)
{
BYTE  btIDTR1[6];
DWORD dwOldExceptionHook;
const int nHookExceptionNo = 5;

BYTE  btIsIDEExist = 0;
BYTE  btIsDiskExist = 0;
WORD  wOutDataBuf[256];

BYTE  btIsFirst = (BYTE)bIsFirst;

const BYTE btBit00 = 0x01;
// const BYTE btBit02 = 0x04;
const BYTE btBit06 = 0x40;
const BYTE btBit07 = 0x80;
// const BYTE btERR  = btBit00;
const BYTE btBusy = btBit07;
const BYTE btAtaCmd = 0xEC;
const BYTE btAtapiCmd = 0xA1;

__asm
{
      // 必须先执行这条语句
      JMP EnterRing0

      // 定义过程
      // 等待IDE设备直到其不为忙为止
      WaitWhileBusy proc

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

      LoopWhileBusy:

      DEC  EBX
      CMP  EBX, 0
      JZ Timeout
      in AL, DX
      TEST AL, btBusy
      JNZ  LoopWhileBusy
      JMP  DriveReady

      // 超时，直接退出
      Timeout:
      JMP  LeaveRing0
      DriveReady:
      RET
      ENDP // End of WaitWhileBusy Procedure

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

      MOV  DX, dwBaseAddress
      ADD  DX, 6
      MOV  AL, btMasterSlave

      out  DX, AL
      RET

      ENDP  // End of SelectDevice Procedure

      // 向IDE设备发送存取指令
      SendCmd proc

      MOV DX, dwBaseAddress
      ADD DX, 7
      MOV AL, BL // BL是主从盘标识，在过程外设置
      out DX, AL
      RET
      ENDP  // End of SendCmd Procedure

      // Ring0代码
      Ring0Proc:
      PUSHAD
      // 查询IDE设备是否存在
      MOV DX, dwBaseAddress
      ADD DX, 7
      in  AL,DX

      // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
      CMP AL,0xFF
      JZ  LeaveRing0
      CMP AL, 0x7F
      JZ  LeaveRing0

      // 设置IDE设备存在标志
      MOV btIsIDEExist, 1

      // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
      CALL WaitWhileBusy
      CALL SelectDevice

      // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
      CMP  btIsFirst, 1
      JZ LeaveRing0

      // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
      CALL WaitWhileBusy

      // AL的值等于cBit06时，不存在驱动器，直接返回
      TEST AL, btBit06
      JZ LeaveRing0

      // 设置驱动器存在标志
      MOV  btIsDiskExist, 1

      // 发送存取端口命令
      // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
      // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
      CALL WaitWhileBusy
      CALL SelectDevice // 设置主从盘标识
      MOV  BL, btAtaCmd    // 发送读取命令
      CALL SendCmd
      CALL WaitWhileBusy

      // 检查是否出错
      MOV  DX, dwBaseAddress
      ADD  DX, 7

      in AL, DX

      TEST AL, btBit00
      JZ RetrieveInfo // 没有错误时则读数据

      // 如果出错，则进一步尝试使用ATAPI设备命令
      CALL WaitWhileBusy
      CALL SelectDevice
      MOV  BL, btAtapiCmd
      CALL SendCmd
      CALL WaitWhileBusy

      // 检查是否还出错
      MOV  DX, dwBaseAddress
      ADD  DX, 7
      in AL, DX
      TEST AL, btBit00
      JZ RetrieveInfo // 没有错误时则读数据
      JMP  LeaveRing0    // 如果还是出错，直接返回

      // 读取数据
      RetrieveInfo:

      LEA  EDI, wOutDataBuf
      MOV  ECX, 256
      MOV  DX, dwBaseAddress
      CLD

      REP  INSW

      // 退出Ring0代码
      LeaveRing0:

      POPAD
      IRETD

      // 激活Ring0代码
      EnterRing0:

      // 修改中断门
      SIDT FWORD PTR btIDTR1
      MOV EAX, DWORD PTR btIDTR1 + 02h
      ADD EAX, nHookExceptionNo * 08h + 04h
      CLI

      // 保存原异常处理例程入口
      MOV ECX, DWORD PTR [EAX]
      MOV CX, WORD PTR [EAX-04h]
      MOV dwOldExceptionHook, ECX

      // 指定新入口
      LEA EBX, Ring0Proc
      MOV WORD PTR [EAX-04h],BX
      SHR EBX, 10h
      MOV WORD PTR[EAX+02h], BX

      // 激活Ring0代码
      INT nHookExceptionNo

      // 复原入口
      MOV ECX,dwOldExceptionHook
      MOV WORD PTR[EAX-04h], CX
      SHR ECX,10h
      MOV WORD PTR[EAX+02h], CX
      STI
}
if(!bIsFirst)
{
      bIsIDEExist  = (bool)btIsIDEExist;
      bIsDiskExist = (bool)btIsDiskExist;
      CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
}
}
//---------------------------------------------------------------------------
// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
{
ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
}

		自动登录	找回密码
密码			注册

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

浏览过的版块