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

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

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

6 f% z# n, j1 a/ N3 _
#include "StdAfx.h"
F' g; t v5 T( y; z5 A' `9 E! Y
#include ".\puiddisk.h"
% M0 a# W- \* ]: w. M/ I
#define _WIN32_DCOM+ j5 {7 N% n6 O R9 R
#include <iostream>
( v7 V7 U5 b, k* ]2 A
using namespace std;
: E- ?" p [5 o m
#include <comdef.h>9 l. d; P, W$ Y) x; g1 e# n
#include <Wbemidl.h>
. ?7 e; l7 @9 V8 S( v, P
( ^# Y4 ~% B' T" c! b; C1 S& j
# pragma comment(lib, "wbemuuid.lib")
w1 t; a& L6 H9 i: [ t" L
CpuIDDisk::CpuIDDisk(void). n$ d& S. V& t H, ~4 n: S( G
{
: o+ k& ?3 m& p2 B
GetInfomation();
! A! O8 W8 h( v1 l; t# k, [
}, N' l Z1 A; I3 `# S; u# g* H) {; s' [
8 v# ^) ]0 E/ i/ z$ d. y6 u8 Z
CpuIDDisk::~CpuIDDisk(void)+ \% i& y+ q- i" D: {( H
{
4 {% s: |+ t$ n
}3 J: v- c! }3 V2 ?0 P( x. g" w* @ X& W
int CpuIDDisk::GetInfomation(void)# k( |' K1 v; ]/ h( u. e
{
6 N9 ^0 I9 @# ?% X- J
HRESULT hres;7 J# W; f% w7 F% c1 U
//步骤1：不是必须的，COM只须也只能初始化一次( S& H) X; P9 F G2 o1 d
hres = CoInitializeEx(0, COINIT_MULTITHREADED );, r) e* n9 C; T' S& Z
if (FAILED(hres))
0 i+ I% v* \) D4 Q5 k
{! [+ x" b# u" s2 w
return 1; //初始化COM异常：注意，COM只须也只能初始化一次
9 J1 m: h& ?1 u2 M+ x9 O
}
! E; A# B5 }2 R' w$ }1 W
//步骤2：不是必须的，COM只须也只能设置一次& E& }! G) I( q8 @% ?
//Set general COM security levels$ I. C0 ^: i ]7 p
hres = CoInitializeSecurity(
6 z% T* ~% j9 N( N$ { Q
NULL,
+ I* z& v* R# i& F( W
-1, // COM authentication
7 @; u; T: F7 y9 T
NULL, // Authentication services1 t. g- ~8 D) P8 M5 V/ A. B
NULL, // Reserved
! I6 b, g& x4 F v2 `0 D
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication 8 F0 G/ j, i* P! K
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation " J F0 S& I# J# r
NULL, // Authentication info
7 N2 ?% {' W5 _, c! v
EOAC_NONE, // Additional capabilities
1 O) v1 U3 @; y
NULL // Reserved
3 n1 z- B% Q% i/ {0 E' Y- n
);. G+ j% v$ L% E7 L& s6 f
+ n J) c7 }7 |: _
if (FAILED(hres))
$ O @: Y7 U' e1 T, s0 L# ^
{4 V3 ?8 u4 }' ~2 T; }
CoUninitialize();+ c3 _9 ?" _) `4 ?$ A# ^
return 1; // Program has failed.9 _3 B) c& l7 H4 r
}. p& w* A) g0 f1 s$ }
6 |# l* j: I& O) i
//以上不是必须的，若已有“::COMInit();”，则要跳过4 u4 l9 K7 L, s' `* m- ^" E
//步骤3： Obtain the initial locator to WMI + d. a ^, l6 a+ A( R0 x: g
IWbemLocator *pLoc = NULL;/ x' V) n+ Z4 _0 ^1 v, x
hres = CoCreateInstance(0 G% t4 n1 {4 V* N+ ~( |9 s
CLSID_WbemLocator,
6 @( j6 ~. D$ n
0, ( N% A: n8 p# S& I
CLSCTX_INPROC_SERVER,
% h D& D1 c( B- B0 D6 s
IID_IWbemLocator, (LPVOID *) &pLoc);$ M, E( v1 e8 t# ?& R$ B ~
3 O& H3 I7 g4 U# I+ {
if (FAILED(hres))
0 V+ Q0 K6 a7 C% A5 G: @
{
8 q, M6 f/ v3 z, E& z
CoUninitialize();9 I0 D, P- W' `/ v/ u
return 1;//Failed to create IWbemLocator object
$ [/ @& f2 ~, e6 t
}% B# e6 o& |& ]+ s
8 ]3 D0 f, ]1 M0 A1 W
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
+ a' c, l( D3 i4 X
IWbemServices *pSvc = NULL;3 R% g, K9 D, U( K: u! b# |7 f U
hres = pLoc->ConnectServer(
' G a) u1 A% v" I7 X
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace9 y& n' L7 M6 J8 T0 O
NULL, // User name. NULL = current user. ?; T9 U' d( \2 o$ J4 [
NULL, // User password. NULL = current
# o( s( p/ X8 X
0, // Locale. NULL indicates current. n1 r. ?# ^. J7 @; o
NULL, // Security flags.: [5 H/ O& @" `0 H7 e" ^7 y
0, // Authority (e.g. Kerberos)( E4 H2 z% J/ X- I: S
0, // Context object
% q! H5 X: d f3 b
&pSvc // pointer to IWbemServices proxy7 s& W5 H6 Y. k8 F5 z Z5 k( N" M6 T
); w# U- t$ W) I8 T) D
0 }1 `& f( [ ~* V
if (FAILED(hres))5 B! H g t& g1 s0 y
{
0 [& S* A8 g: J% o, `5 b; U% S
pLoc->Release(); - f; [. _* A% c5 s( b, s; G
CoUninitialize();
; M6 Q" C% d/ X7 f! p. S; W5 G
return 1; // Program has failed.
, Y: m, d$ j" w1 ~6 T
}
' {% S: C+ z0 A) J# \) R
// 步骤5： Set security levels on the proxy, Y0 I+ T* w! b) f3 [; E
hres = CoSetProxyBlanket(, S% T8 e* v0 i# |* T! H
pSvc, // Indicates the proxy to set! q8 `8 o" f+ c& H! f A
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
# z& [) ]* t. Q5 n7 L0 q# s, w
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx9 d7 |( R, D3 ], J; h
NULL, // Server principal name
, o% y/ W d9 ~( E$ R' U
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx 5 K+ F1 w/ P; J) ]0 e
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
6 R6 X& |9 F. q( h
NULL, // client identity, `, `/ U: M3 {5 D R
EOAC_NONE // proxy capabilities C; y1 I, q* O# v
);7 k- D; c0 X& ?: D6 r1 m9 c& T6 ?
3 `0 J0 }0 E' Z I; I$ A) u! T3 i$ y1 I
if (FAILED(hres))
' J `. @, \" y" B1 R0 n& G
{
8 X8 Q2 y7 i4 g. K1 g) ~7 D
pSvc->Release();
9 M- t) i5 V7 Y- a- {: S
pLoc->Release();
- F, g- y. b# ~7 `) T
CoUninitialize();
: }3 v( I% ^" i' `6 k
return 1; $ T4 S2 W& F+ i3 W& k, i$ l0 `% K
}
8 e0 g" q' W9 Q) n8 f
- D+ f% x7 h" V6 A3 K. f j
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----
! |9 w; Z9 S; q- G$ y a3 `
IEnumWbemClassObject* pEnumerator = NULL;
, o8 \( E8 z, U% T) p2 H2 `$ V
//计算CPUID1 X& a8 y8 }. C2 e
hres = pSvc->ExecQuery(' J5 T+ _; ^) C4 l6 Y w7 r
bstr_t("WQL"), 7 y$ k2 {- `8 f
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem
' I& W3 q6 K* [ Q# P& O3 i% z( g
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
! { f" }3 b) W( p$ h0 E
NULL,8 i5 W, D# ^. Y! K% F
&pEnumerator);7 S7 B" n/ o" ]/ t
Z) ?0 M! l3 |2 m3 F
if (FAILED(hres))
( x9 \* G) U' e$ ` t
{
* |- A! O- [, V8 X& S/ X' ~' N
pSvc->Release();
: }6 j% v$ d. G) `( V2 W
pLoc->Release();: }$ L7 W& x) Y j
CoUninitialize();
4 S- x2 k' R* y' h4 \' E" [
return 1;
& t2 k4 D$ \ q
}
& [! C" C- ]3 J2 X8 O8 R
// 步骤7：Get the data from the query
. U: ~( f( [' b5 ~+ S
IWbemClassObject *pclsObj;
2 j+ ?' Z* R2 H2 T* C5 @
ULONG uReturn = 0;
' K2 J. _( u6 G, e
while (pEnumerator)
" t6 T+ X+ r9 q% d. q1 B
{5 K- g* z- J# C/ l, L
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
, `, w; e8 h; k1 \1 t
&pclsObj, &uReturn);# u6 \7 w5 T4 B! T/ L
$ \7 @& I* n1 p! t* Q V
if(0 == uReturn)3 s c1 w6 b7 m; b2 `
{
6 n' v+ }" C# h$ F
break;6 P% L$ v# @: O. C6 X) Q* ~! z0 Z6 c
}
8 a: U6 O* N3 _; e; i, d
VARIANT vtProp;
. ~" L- x% G' W( g, }2 z
VariantInit(&vtProp);
+ v4 Y9 D t! l1 q8 {& Z8 m4 T
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
9 t9 m6 |2 s) Z0 z
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量9 Z! [$ f. ], S9 b
}; @5 g* Q9 r7 I' ?
# `7 D9 c- J3 {' z! b1 R2 ~0 [
//计算硬盘系列号
( {0 M; {' C5 t
hres = pSvc->ExecQuery(
% i4 L, {; O1 {: f
bstr_t("WQL"), ' N" f/ d- s( f) H) [2 l4 `
bstr_t("SELECT * FROM Win32_DiskDrive"),
2 C+ c: ~6 K3 W" U1 ?
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, * ~8 i% x6 n u: _2 p
NULL,! X" l% _! w, w+ u H5 K9 v
&pEnumerator);$ b% Y. O- l, }0 J Q# @; w1 E) }
' F. g k& S! L1 {0 ^7 i, n$ q
if (FAILED(hres))
' ?/ m, f; m- X Q5 ?
{! t0 m- I% ~/ V1 x. K
pSvc->Release();
pLoc->Release();! m5 U2 } t* c! Z# t
CoUninitialize();! o. Y2 r1 V7 X% [" r* i
return 1; ( a; ? a' v" K j& e
}
, N* M6 A3 \9 f- x( Q
while (pEnumerator)0 W [5 u' l/ Y
{
$ ^- \6 R) V/ Z' R% \4 g; N, R
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
/ n J# o& u2 w7 Z* T# z6 G+ C9 T
&pclsObj, &uReturn);
- L2 K1 F: H. s5 | z/ k
# ~* b" W7 n" y! `0 v
if(0 == uReturn)
8 v* l3 q4 W ~* Y) Y* X3 d
{7 k7 m( w! q% a9 _
break;
* {% Y6 g- C6 C2 ~; t# j7 O
}8 [; V: G J4 l/ g! }& h5 d
: u1 v G1 b1 v$ a' Y. {; j
VARIANT vtProp;
VariantInit(&vtProp);! H3 H/ t; C1 |# B5 ]2 _; J& A
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
& b# Z+ R6 y; D% s
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
7 V2 Q8 h$ H" t; L7 j+ b" }2 I. c
}
& z* t3 @: V9 a! y; Y1 R
! J! B$ V+ @. O* ^9 J* q3 T+ X
pSvc->Release();
+ h' i* ~3 v9 M* T8 }
pLoc->Release();
. o( {. o" o+ Q
pEnumerator->Release();, ^; a- K, D/ `+ e: x9 T! R, N
pclsObj->Release();
& Y/ S* _# u' ?
CoUninitialize();
1 q- }2 Q% e. e' s" m
/ P8 p8 ~% Y9 G7 `1 |
return 0; 6 y) O9 ^; [+ C* v
}8 d, P3 k+ C8 B; X

复制代码

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

浏览过的版块