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

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

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

5 ]0 Y4 F3 Z9 K( t' [
#include "StdAfx.h"
" J9 G+ l6 R, _ e
#include ".\puiddisk.h"
4 W# Q0 v* W. k1 E E& b+ S' b
#define _WIN32_DCOM
; I# g% P; S6 Y* B% J
#include <iostream>4 D9 g! s4 H* r: p# i2 T
using namespace std;
8 {" q5 T. j/ q0 Z. l6 J$ J
#include <comdef.h>
' n, K) Z! R* K0 i2 | e! s; {
#include <Wbemidl.h>' t1 q' i4 r, U& u
- ~+ L6 f% N2 z2 y7 ]; p4 P* b2 T
# pragma comment(lib, "wbemuuid.lib")3 X7 p( u$ r* O6 Z& P
CpuIDDisk::CpuIDDisk(void)+ @, ^9 s6 [; `7 N
{/ g- g) ^: O. p# H" h
GetInfomation();
( c( ]9 J8 X* Q6 J: M+ G* j* \
}
" U* {0 ^% Y% J( g: B$ Y6 ~) O) G
+ A/ d) t" m# Y
CpuIDDisk::~CpuIDDisk(void)
- b, Q. u. W7 F& u/ s; E
{$ F" G d/ S0 z, O. m, @0 r! t
}. H1 h' j6 m. M7 v. D
int CpuIDDisk::GetInfomation(void)7 H8 t& X6 A1 b5 f' C- y
{
$ e# x: F6 Q" Q& C4 w* O- n' E
HRESULT hres;- k* A2 X' _8 r& l9 C) R
//步骤1：不是必须的，COM只须也只能初始化一次
% P7 G* j; k$ A+ v2 ^, C" I8 w
hres = CoInitializeEx(0, COINIT_MULTITHREADED );# ?) ]) e3 T8 P* y
if (FAILED(hres))
3 S7 P4 e/ Y2 R2 x% M( n- M
{
1 j! f+ k2 \& f- w5 f
return 1; //初始化COM异常：注意，COM只须也只能初始化一次, t( F# B7 p5 X7 S3 o. i
}3 R5 i$ P7 x( P/ d
//步骤2：不是必须的，COM只须也只能设置一次+ [9 T0 e5 F- C2 o u4 l4 ?
//Set general COM security levels
' c2 V+ a, ^5 a! w5 _$ c
hres = CoInitializeSecurity(2 q0 f: K: j4 ?4 Z1 _. b
NULL, # z; M, _ w+ E7 ~! R' z
-1, // COM authentication: a, L: p: h1 D! s6 g L2 Q& t0 G! L
NULL, // Authentication services
3 @( C+ A3 b9 n3 I& E5 T
NULL, // Reserved* D/ S# n; [+ L. o8 U$ [1 Z& I2 X' y, _
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication ( ] W) }# d @0 a! ~
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation * L1 j) ]( L+ H. p% O
NULL, // Authentication info
) }3 x! J9 @# d( o8 x I0 ^, H
EOAC_NONE, // Additional capabilities ; U& k& B+ A. U7 s1 y; [- I6 c
NULL // Reserved* F, S% j) R6 ^1 u
);% `% }6 h2 p1 m# ^, |# ~1 b, ~" f
$ j6 {, [" n4 |# r
if (FAILED(hres))! k% O6 \0 U3 ?2 u' Q3 a
{+ q% L! ?: V* p( h! H$ y: |$ i' J
CoUninitialize();
+ T3 a) Q8 ?: v6 K) K& t1 `9 j
return 1; // Program has failed.
+ Q0 Q, [& C7 r( b
}) y7 i9 ]0 z* S, M" ?: n
) C3 H5 t- X. S
//以上不是必须的，若已有“::COMInit();”，则要跳过+ l8 R8 J+ ~! l, V9 K" E
//步骤3： Obtain the initial locator to WMI : p) ~3 f0 K! i+ Y" y; X
IWbemLocator *pLoc = NULL;
- n7 D& m7 S5 _* Z3 g
hres = CoCreateInstance(
6 u% ^4 L9 R" F1 W. q
CLSID_WbemLocator, 1 v- y+ y' n$ A7 h
0, 5 d! P6 G) e# V) _1 \& A' {# A- f! g
CLSCTX_INPROC_SERVER, , [. J. i% d8 w4 E3 M) |
IID_IWbemLocator, (LPVOID *) &pLoc);1 h& t" i% U' }3 L" d, L
6 s4 w& ]% A4 S' |' `& a
if (FAILED(hres))# I2 n4 g# R" d1 d* y
{8 D( |+ D/ B( I: f* x
CoUninitialize();- s A3 S g1 s+ G! E
return 1;//Failed to create IWbemLocator object
B' G7 f: b5 \& m: `3 w$ M
}' P1 j. c* F2 y: b
' b/ Y/ K$ Y7 _# F
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
6 q( J( b2 m, a2 z" Z& d6 `* r/ Q# U
IWbemServices *pSvc = NULL;+ D2 r% L( T! Q9 R! {! d
hres = pLoc->ConnectServer(9 S5 e- N; h2 _. v3 _2 M
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace) u1 o- F9 I' n# V& ^) P
NULL, // User name. NULL = current user f$ E0 x* i! w+ ]' L' T
NULL, // User password. NULL = current/ H n: \9 r3 u7 ^/ y8 c0 Z
0, // Locale. NULL indicates current
9 J( Q+ j5 s; r# ]
NULL, // Security flags.$ h* a6 s7 f: _# i
0, // Authority (e.g. Kerberos)% |2 z+ f% {1 U0 V
0, // Context object * s0 R R- m/ \3 r5 H
&pSvc // pointer to IWbemServices proxy
, f. F% f% z- u- h! X) @
);# T8 N) t/ U* T9 C/ Q# L
4 @* H4 J" z3 p# a
if (FAILED(hres))+ ~9 k) y; c/ n8 N8 d* |# M
{
' S$ [8 j4 h# G& j$ ^" a
pLoc->Release(); 0 O! h6 h' \$ l# R3 z, ~: c
CoUninitialize();
" {: F, o+ E- @ R
return 1; // Program has failed.# {4 u: p* b8 e5 m1 ]/ Z
}7 L4 ?7 s( N' d( ?/ l. q4 i
// 步骤5： Set security levels on the proxy# j9 _1 E/ X) [" b
hres = CoSetProxyBlanket(
$ s) V L9 f5 ?
pSvc, // Indicates the proxy to set
% _$ E* O6 c2 k2 x/ G) m
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
z' Q4 E$ v0 w& C
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
2 Y1 O2 E( t/ x% Y. E
NULL, // Server principal name 1 a; \9 B9 \) z* {5 C+ d
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
+ v) b( m2 ]/ w
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx. V' H2 O J+ s! e
NULL, // client identity
2 l/ G0 R3 M8 R! n
EOAC_NONE // proxy capabilities ) l( k" [8 I" q! K" g+ q% j1 U
);
! v3 X. S' j6 N& ^2 q7 ]3 I5 t- v
6 g7 W0 k8 {. `1 P
if (FAILED(hres))
2 Q; L2 i6 f" Y2 s" J3 C
{+ Q3 v! |7 G: j5 O$ ]' _0 G( ~
pSvc->Release();0 W+ f E5 [3 k* N5 r2 A& j. f0 X; H
pLoc->Release(); , Y( u! \% [! y5 h$ ?
CoUninitialize(); l$ _; j l8 |* r+ V
return 1; , f1 j+ Y/ Q# K& a; h+ c
}" b' t, i8 d0 M A; J0 E
/ M( ], o/ W8 ]/ F T3 }; x& ?, R" I
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----
( m- N# E' u; S7 [& v+ ?+ Y, y
IEnumWbemClassObject* pEnumerator = NULL;& R2 R! V6 Z2 X8 _
//计算CPUID5 B# T. z' L- ~. @! N$ f; q$ P
hres = pSvc->ExecQuery(& x: o5 R! H% U; z' M0 E1 }
bstr_t("WQL"), ( z1 y6 f8 Q6 }# H
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem2 t( ^, T6 W1 _# _- T8 @1 ^
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
* l( d: o) Q' i1 t3 ~
NULL,
! z1 @2 c3 k; \8 W/ I5 a! r
&pEnumerator);' h B @! ~7 z' O
( m( m: C: K. U/ I5 |* ^% B' \
if (FAILED(hres))4 A" x( {" s7 _* b* V- Z
{; \" Q8 q+ V, o8 P, ^
pSvc->Release(); D3 q6 W9 k# v: q
pLoc->Release();
4 U7 z8 v: [! R* H
CoUninitialize();6 k; M% |; R5 p& x$ s
return 1;9 B8 ?& J$ ~$ V
}
8 @3 L8 D4 h0 U
// 步骤7：Get the data from the query
( ^2 y" U3 _- ]" h4 X( Y, r) {7 R
IWbemClassObject *pclsObj;) l j/ B9 |/ @
ULONG uReturn = 0;
' u% `9 |8 D7 w
while (pEnumerator). \3 Z! ]3 W$ z. K5 ]: H" S1 m
{
" @% f( h3 ^4 J0 z1 b5 n1 T
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
6 ^8 k: k1 P9 F8 p
&pclsObj, &uReturn);1 A ~; I7 W9 R, \# k) V+ W& S
; k6 } B& @& s/ o6 f6 a! I3 P
if(0 == uReturn)) K U( e( ^$ [, A
{
6 D7 o6 u4 z1 u/ X3 B
break;
( S) M7 F, ~3 V7 `
}
% s& c8 c3 ?' c
VARIANT vtProp;6 }) D5 ]1 ]1 Z2 p( d: t% n
VariantInit(&vtProp);, `7 e3 `) ^: e' D; m
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
7 G2 l' m# @# ~: [5 D5 V$ G4 W
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
& s& b) U2 y# Z" e( |' u
}! P7 O; k1 _3 R6 G- F; ^* R
! l7 U5 w$ A% G
//计算硬盘系列号* \+ k2 k+ h0 b0 \. a. t9 d; \
hres = pSvc->ExecQuery(# n: L& B2 g, G. _0 V; I
bstr_t("WQL"), 2 R& }% p# w, O$ v* Q- v
bstr_t("SELECT * FROM Win32_DiskDrive"),* Y+ ~, @2 {5 D5 x' J7 `6 G
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, . ~2 @ D' Y" p1 ?0 ]
NULL,% `& r6 S$ ?0 S0 Q5 Y
&pEnumerator);
1 C. T( y9 \! @1 h- c6 u; v- @# `
# l# S: x, H& x7 D+ D; V
if (FAILED(hres))
+ w9 g: c/ }- l2 W8 z+ @" a
{
7 y. h+ G" S, B/ u0 i
pSvc->Release();
, p* \. v: K% v+ a: W- i! O
pLoc->Release();' e* Q3 l" h/ @. o
CoUninitialize();
3 O' c! t4 U0 F4 x
return 1; 0 I" t0 F. r6 x4 b/ P$ O
}! ]" }0 P7 Z4 J+ n$ K! b6 H
while (pEnumerator)$ C5 r2 k x: W& q r! Z2 f7 r5 [
{
, I6 }& B+ M- L' ^5 \- @/ ]
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
( z0 Z, z2 I Z# S" A
&pclsObj, &uReturn);/ L+ ?5 B1 l# X, t: l. g3 j
7 {# b# O" s+ j
if(0 == uReturn)
( c9 R: [' N5 O6 K C/ X! ]
{ J8 K' N3 \# w ^: l6 u* \) ]
break;
) @' n& V! z/ e D6 Z
}3 [, V& y3 b, i6 x1 j
8 M: W* B9 F: i- m
VARIANT vtProp;& d s* l4 z& S7 Q2 \9 r( o9 K
VariantInit(&vtProp);
' E0 m4 h" Q# d3 A2 j, K4 o' O
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
2 K K7 o5 h" d D8 c
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
* c' `# I! i) G7 _) |
}( y" e! h" r. I, W+ n
0 ~: z& ~) v% e- A$ D
pSvc->Release();9 j- k- i* e9 E' A7 g
pLoc->Release();
/ G# L4 |; @: d& w" u% E: w. D" n
pEnumerator->Release();1 i; w8 {' K! q" t& L4 t
pclsObj->Release();, f9 S; {( g" ^+ a$ X; c9 f
CoUninitialize();
- W* x- j) b* K7 S
~' y Y |- w
return 0; - ?* C1 _6 v0 z) g
}
6 h# g# A- ]6 ]# p( y$ W% V6 S2 G) O

复制代码

天云上人 · 发表于 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和硬盘系列号的源代码

浏览过的版块