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

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

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

; ^0 w- i! I$ d9 i& |
#include "StdAfx.h"3 b' ~& p# c% o0 m2 z+ l9 f) B8 v m
#include ".\puiddisk.h"
: g }/ k* N$ z* w8 D
#define _WIN32_DCOM
; W! z# A2 ?4 A2 B( P& }5 b
#include <iostream>
3 N k! ^1 j9 \3 R) N1 \- B
using namespace std;
% s" H, Q# s: k. O. u: ?7 v9 f
#include <comdef.h>2 C+ d1 D9 {6 m: l% Z
#include <Wbemidl.h>- U0 o2 h, d* M2 k5 o4 o
, D8 O( Y6 z) I' E- d
# pragma comment(lib, "wbemuuid.lib")
% |2 y- R' ~4 j% o+ n& Y& G- C
CpuIDDisk::CpuIDDisk(void)9 j5 |# Q' j$ m6 ?6 Q" m; h
{
5 A, u9 Z. T- {* Q% j. t) D( b
GetInfomation();! t A3 Z3 S3 |) {1 t
}
( r9 Y" l" J' z
. @% A& D4 |/ O. c' ~% ?5 C
CpuIDDisk::~CpuIDDisk(void)& t6 V' q# U: d' `* b
{" v9 b n8 E& Q Z
}4 o# {$ k6 X8 Q( ?. |5 L4 C2 Y1 n
int CpuIDDisk::GetInfomation(void)
6 K' f$ i7 d/ E6 X
{) [& b* v$ ?! T$ Z- f
HRESULT hres;2 f7 Z ~- k7 r' Z; g: M2 D
//步骤1：不是必须的，COM只须也只能初始化一次$ r' G& w+ |! \3 k+ R
hres = CoInitializeEx(0, COINIT_MULTITHREADED );1 s! s4 J2 D9 t
if (FAILED(hres))
/ ~/ F4 w! _) I) v T! S
{
/ k+ F% m9 ~3 i
return 1; //初始化COM异常：注意，COM只须也只能初始化一次5 i6 j3 y& u m6 i
}! v' d: d U+ x: M
//步骤2：不是必须的，COM只须也只能设置一次0 l% f) n; @) C5 X. y% w# Z
//Set general COM security levels
, U5 r/ d) P7 k7 ?
hres = CoInitializeSecurity(8 u: A3 c2 u; Q( n
NULL, # J9 q$ n9 ?/ P! t+ t, M9 T
-1, // COM authentication
4 s0 h! H9 T3 o5 h
NULL, // Authentication services
9 {3 ]. J* D: |+ _- N
NULL, // Reserved
& \7 H/ [# t% K( h0 b
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication
8 h F7 o; q& }/ ~4 `9 j; e! O5 O6 l
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation + t! p! U6 u5 ]- Y5 x, A
NULL, // Authentication info
+ y: m [6 ?/ G. H( K( A( z
EOAC_NONE, // Additional capabilities 5 ^( L: x$ X4 e' w$ T/ k& J1 S H) n
NULL // Reserved5 N. `( x6 v. j3 `! m
);' f5 u2 W; t( {- k7 f+ A: C; I4 U
4 k# u2 L/ k* m* d) d7 Y
if (FAILED(hres))$ @ k# n5 H% C( V
{, h% F! E$ H( j+ X- Y; k
CoUninitialize();6 @0 Z0 W5 ~* I7 x
return 1; // Program has failed.6 N; L) T5 ^. j5 X& g; \
}
& C" ?7 @" N; c+ S$ Y6 l
) e! {2 W0 y( i( c! q
//以上不是必须的，若已有“::COMInit();”，则要跳过
$ o- p3 U- t. b$ _7 l2 q
//步骤3： Obtain the initial locator to WMI
' [2 Y- l7 ?' B3 Z) d
IWbemLocator *pLoc = NULL;, i7 H# J) e( i; V
hres = CoCreateInstance(( v3 O9 Q& H6 X( A6 p
CLSID_WbemLocator, # B! `5 A [7 B& H" Y; i, _
0, , O% C/ X' b- \ h! N
CLSCTX_INPROC_SERVER, ! F6 b% I9 x) n- ~9 A, W
IID_IWbemLocator, (LPVOID *) &pLoc);
O" }2 L; ? L0 h9 B3 R/ c# U
' J5 \# c% ?2 l0 w0 A( n. H+ b
if (FAILED(hres))2 E- V2 j# V) U) v
{" Y; J4 H% ^2 _ O- d
CoUninitialize();
1 _9 ?/ Y/ C( [4 T C$ v3 \
return 1;//Failed to create IWbemLocator object
9 X" u, M6 b- Q2 `+ n
}
; v, D7 J+ I" ]2 @' S3 P% K
7 b' L. p$ G4 i8 s7 W; u, u
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method M% E! v0 C; Z2 [( g
IWbemServices *pSvc = NULL;
( _# H$ X* f3 z! l3 a5 m% h( H; f
hres = pLoc->ConnectServer(
6 p) I g/ B/ ? N r2 O5 E
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace1 a3 b/ n2 x* r- w
NULL, // User name. NULL = current user1 w5 C& e# t6 Y9 |) k; K% e
NULL, // User password. NULL = current+ V- `; w( P9 R# a- u( G* T! d$ V
0, // Locale. NULL indicates current
; ]# H" l5 d0 S O8 D8 A
NULL, // Security flags.
- H) f, F C% b( k
0, // Authority (e.g. Kerberos)$ U4 i; T* g9 y0 ?; k- d7 e! N
0, // Context object
/ o0 o6 G3 c9 S7 x2 ]2 M0 E% R# A# q
&pSvc // pointer to IWbemServices proxy
. q* A+ j2 P. l9 G: L, U9 n
);, y; J( E& {* \
2 D. q5 i G9 u2 ~2 C
if (FAILED(hres))# n- ]+ @) p% t; @ x
{5 Q. L j5 u1 {$ B. O! Y
pLoc->Release();
+ h: J) F+ z W Y
CoUninitialize();6 T- x! Q; G% Z. K
return 1; // Program has failed.
1 Y4 s ^$ E+ O9 \
}
3 B f- V% w) ^: M& j
// 步骤5： Set security levels on the proxy
$ _! i+ p6 i; l" ?: u2 p) a
hres = CoSetProxyBlanket(: }" P/ Z: t; p% K
pSvc, // Indicates the proxy to set) H2 ~- J7 R E2 P; Q* I1 I7 i
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
" p% U7 c2 j3 R* l6 ^1 `
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx$ `$ A/ O2 `: P& H" u
NULL, // Server principal name - @& N5 A+ ]8 s, a
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
5 K2 j) _! r) e4 n- Z
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
/ Q/ I) n, ^+ ~/ R$ G, h9 D/ m! X
NULL, // client identity
" V* A* f) o8 E: @/ ?
EOAC_NONE // proxy capabilities . v1 l/ r1 E7 Z j! d% _- R( J3 O
);3 L" d( h5 K4 ]/ x+ p" M
( @! J U* g- X0 F- u% V
if (FAILED(hres))* A$ v" B* S1 p _# i% e
{) Q& m+ y+ N# M+ P: S& t' R; H
pSvc->Release();
6 U* A. u e6 Z
pLoc->Release();
6 ^4 B5 Q# k B- n3 y$ C9 z
CoUninitialize();
2 D# l3 g# g. r
return 1;
& {) _: H* t+ l* u
}
k( B- J7 p4 w6 P9 s
; P& F2 |2 w! C$ e) I
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----
6 I) A+ @1 c O3 M' }3 T. g0 U
IEnumWbemClassObject* pEnumerator = NULL;8 K. S5 x0 o3 y* }% @) [
//计算CPUID
2 n. O9 j5 T' n) q$ B, H3 N
hres = pSvc->ExecQuery(, q# v7 W/ g; z8 v- B' y9 s
bstr_t("WQL"), # m! j% U6 ]# Y: k- u) i3 W/ z3 [
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem- Z7 J& }$ B( y* g
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, : ]: ?, _/ Z, [7 k
NULL,
b |" ~% k0 G* T
&pEnumerator);1 ~3 w$ F7 @) O
; _. }/ v4 b- B' v/ y
if (FAILED(hres))
+ n& M( N. D2 X' A$ H1 _( X' i5 L
{1 ~7 m) g% V. \$ V% S4 E$ f
pSvc->Release();3 j6 x6 I9 x$ D3 ~3 }% x6 P. u
pLoc->Release();' v, g1 _1 N$ J) G+ R1 J: F
CoUninitialize();
4 u, ^% P7 ~+ [4 g) T, U) v
return 1;
f9 n1 E# Z, E
}
' E& x8 ?: T/ i2 F1 E5 L
// 步骤7：Get the data from the query
1 Z6 {. k. k3 `; E
IWbemClassObject *pclsObj;
& Q0 D" d. B$ e) P3 b: o. y) ?& s
ULONG uReturn = 0;& ~5 l) c, K3 o; f+ B$ H' n* r4 U
while (pEnumerator)0 e u# |* q: C: t
{7 o, }; m$ g2 c" {* C% F$ R. s$ H G: ?
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, # o# M( J( W4 A4 f7 e. f
&pclsObj, &uReturn);
) D: ]' |* Z3 v' J: P E1 ]7 h
! t/ s( u& O8 D: J/ S G% t
if(0 == uReturn) f4 n3 V& I* k* P
{
' Z- D5 Q9 k8 x Y& y1 ~7 M8 n/ W# D
break;
( J6 W! K. ^3 `* k) S
}7 y& L- `5 `# A
VARIANT vtProp;
: A" Z0 b2 ]/ w* q
VariantInit(&vtProp);) k. H: I, y5 _* ?( ^+ z
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);
, |, W9 R% q" T/ S1 p$ M- ~: @4 j2 P- U
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量8 a9 H4 A# I B u$ M5 d [- b( O" Y
}
9 Y9 S+ ?9 V) D! Q8 i
% `; N* L+ j) Q) `6 |, g
//计算硬盘系列号
$ r0 L. J S4 H B8 l) ?4 N
hres = pSvc->ExecQuery(8 I( U7 J# Y9 E# `& t" P& u- Y- F
bstr_t("WQL"), # U9 U4 `' B0 e" g
bstr_t("SELECT * FROM Win32_DiskDrive"),8 t& S8 a$ F6 G* U% l
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
; x2 b# X* z8 i5 B5 M9 F. H
NULL,
* b9 _9 L% e0 j" k( i! Y
&pEnumerator);! a. G: x7 ~0 U
6 J& `2 o+ |' p p
if (FAILED(hres))
& N% q9 _7 k! q6 k' [
{
' F$ P& U. O7 I- ^
pSvc->Release();
" X+ m/ W: [ P" {
pLoc->Release();- O9 J" o+ J* B. z2 ^( F7 m
CoUninitialize();7 L) d" g+ y# l7 M5 D3 b: `
return 1;
/ O+ J c1 }5 b
}
$ y+ @: L; j7 ?5 F
while (pEnumerator)$ P0 w/ G! }- @" H4 k1 M& f
{
7 F; F3 ]& s; d. n, D6 {$ N
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, . @) e. }% X( @8 E
&pclsObj, &uReturn);
1 y9 F# C7 r, V. ], `
6 b* l% [) I! l2 h
if(0 == uReturn)8 j- q! u+ _' a* ]% M- D9 T
{* Z' ?/ k4 M7 u, |3 b' n. U+ a- w9 _) s
break;
* d Y" n* T, g
}
, h) S( y0 o; i6 r6 W
8 Y& N; {& N6 q" h9 \3 F$ V, |
VARIANT vtProp;
( C, ~8 q2 X2 X8 Z
VariantInit(&vtProp);
0 U" H& c) ~0 ^$ F
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);
" _ P+ g! v4 x+ Y9 T+ n: Z
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
) U$ k/ ~! m$ |3 V' R
}
6 n3 k O. C' V% c! [
; b# f* D$ Z$ G2 p8 z& l2 Y# U
pSvc->Release();' e) X/ C& Q/ S% {/ I7 `6 E
pLoc->Release();
7 {- K; J' M7 p% p. _" ~2 ?) v& ?
pEnumerator->Release();2 s3 a, M0 M, c2 v6 M7 L3 a5 m
pclsObj->Release();
% Z/ L9 P# ^& h0 r1 H5 S! Q
CoUninitialize();$ K. ~, D7 w7 k; B. E/ k) q
$ A& o+ X7 F% R* f( \) a
return 0;
0 n4 k: B) V8 ~
}/ \- N, K6 W/ v

复制代码

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

浏览过的版块