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

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

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

5 z5 }0 D4 C. z5 B5 F
#include "StdAfx.h"( \9 G" T' y( n, _0 `/ R$ M
#include ".\puiddisk.h"
& K: }; A5 M" |4 C
#define _WIN32_DCOM
& [ S7 M9 }7 K8 Y9 y
#include <iostream>: R+ R2 e5 B9 H3 Y5 J3 R4 J
using namespace std;
+ t6 N. m& k9 C4 p
#include <comdef.h>
0 v+ Y! J8 L8 M0 C
#include <Wbemidl.h>
, r/ l& x) O% H% m! ?, v g8 }
0 [" r+ v9 e% ]( H; i, _
# pragma comment(lib, "wbemuuid.lib")
4 E D8 I8 D, e3 n! d! Y
CpuIDDisk::CpuIDDisk(void)
. c6 b9 q+ T( ~+ K+ _
{
/ g3 a. y) b% I' o
GetInfomation();& I2 r( e. i, t/ v2 j5 v" V
}$ ~; k) q- o9 D" U
4 i0 T5 S, j) t# G9 z6 X
CpuIDDisk::~CpuIDDisk(void)
6 @& y, K6 O7 o6 m$ D7 k& k" s
{
" i/ u( r9 M4 g" |- h& b. O% }
}
0 Z) M0 z, X% y+ B+ n: t3 s% X
int CpuIDDisk::GetInfomation(void)
! w2 q! L* Q( t
{1 T9 i: q% [ I2 K6 ~- q% i4 y
HRESULT hres;
1 M5 M$ ~% t9 m9 t7 b& f
//步骤1：不是必须的，COM只须也只能初始化一次# g; M' l; R3 a* |2 ]; V( L
hres = CoInitializeEx(0, COINIT_MULTITHREADED );- z" @' N; e4 f, ~$ G) y5 H7 {
if (FAILED(hres))" K8 q8 b- j( \1 l
{
# o. V6 J5 P m% W7 c, g. j! A! Z
return 1; //初始化COM异常：注意，COM只须也只能初始化一次7 P* \ I5 [; |! p, n! T: u
}9 Z$ }2 [1 I% w5 X1 O
//步骤2：不是必须的，COM只须也只能设置一次8 q/ X0 {1 |0 a) m5 S
//Set general COM security levels+ J' c% S9 m4 q4 }: `2 H& ]
hres = CoInitializeSecurity(
. m( V* }* J! [* n: i* D
NULL,
$ b: u) ?/ m9 W/ P1 G
-1, // COM authentication6 k! x. F e: g) i' B
NULL, // Authentication services
; u& z2 [4 |' I& N8 R0 g9 J
NULL, // Reserved
2 {+ z2 _9 [/ O9 D2 E3 A9 V
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication ( B' b1 N: v7 x3 c8 K* Y
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation . s4 T: W( C* i; ?
NULL, // Authentication info
& q* K, V* \% z; R
EOAC_NONE, // Additional capabilities
2 U, K# q! s8 A% ~) y
NULL // Reserved
( ]$ x! d: s9 u) D, ~
);
; g. o2 i8 _$ y4 d8 f
+ h# \, {6 z" L. k5 Z$ R6 T
if (FAILED(hres))
2 m7 D/ T. ]3 m$ U
{* s- }" _" Y, r2 ?3 P
CoUninitialize();& _% F, Z2 T: \8 O: u& P9 @
return 1; // Program has failed.
% {, j1 N9 t' K; b6 S
}
& @: }5 o) b1 n) p
: V: K$ e7 ^( S. x5 Z$ {+ u u
//以上不是必须的，若已有“::COMInit();”，则要跳过, @" x& q; {! P/ r% [
//步骤3： Obtain the initial locator to WMI
- _' r @4 \5 m0 b/ S& H* a
IWbemLocator *pLoc = NULL;6 i/ l" t5 N. R2 P
hres = CoCreateInstance(
- n: q$ V) k2 E4 u! [
CLSID_WbemLocator, I6 T$ ~& `- D0 w9 s/ z6 k
0,
8 E1 @; ^. l( H R c8 `3 X! ~; m
CLSCTX_INPROC_SERVER, 7 x# x( @8 Q) m) F( O; f
IID_IWbemLocator, (LPVOID *) &pLoc);1 A; l* S0 L e$ I+ `; o2 u
# c1 C8 t5 Y- {- B* O0 L; }
if (FAILED(hres))
! u9 \( ~2 X( ] f
{
- E& \& J- U* A
CoUninitialize(); f+ t% F7 W# t( b$ S
return 1;//Failed to create IWbemLocator object1 Q/ }1 |* M% K! I
}3 C& Y- Y0 V6 u! ~
8 a, x [- C! L" P- Z9 ^2 O3 S
//步骤4：Connect to WMI through the IWbemLocator::ConnectServer method
* s9 n# R4 S+ r$ M; m& ], n
IWbemServices *pSvc = NULL;
; c' ?" B5 J3 \0 a' m
hres = pLoc->ConnectServer(! c* n1 O) B( D8 c; F
_bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
' l& F- T, `. U( A
NULL, // User name. NULL = current user
, `! s% D8 A# d. i0 r8 v
NULL, // User password. NULL = current# ^; s2 E# q7 ~& @& O3 h
0, // Locale. NULL indicates current7 L: P I$ J% T6 U1 d: V6 C
NULL, // Security flags. @& u! D* j2 _2 A7 Z# ^. `
0, // Authority (e.g. Kerberos)8 R( ^3 _4 ~% d/ z1 v# b' n0 G6 w
0, // Context object 8 B0 R' C7 u- T8 h5 Q) d" p' W
&pSvc // pointer to IWbemServices proxy$ a8 X( G4 r: Q2 F+ E
);/ u# ]8 r$ \4 ]
( w+ [7 E6 c8 `! S ?8 {0 @
if (FAILED(hres))
( l" }* k# F) q; E( P
{5 D6 B `6 W) @
pLoc->Release(); 5 P. D4 q7 m& {5 V+ h
CoUninitialize();; |+ S8 e4 k5 p& z
return 1; // Program has failed.4 U# v% ?5 n# G
}2 X7 R& Y- d/ [" z
// 步骤5： Set security levels on the proxy
5 P# S B' F* b: ^' T9 {2 Y
hres = CoSetProxyBlanket(: X* h& ]# P$ K) `% K! P- Z
pSvc, // Indicates the proxy to set
' I/ f. A+ r' X6 `& T4 m/ l' `& D
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
8 J& ^) [, {7 E5 W( T8 z1 w' D
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
0 g8 Q6 x3 F9 o/ E; F
NULL, // Server principal name
9 V2 p- d$ i1 \1 k
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
6 `# w3 Y2 }/ w% ]/ e
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
! K' T& u& w! v8 [5 J$ r
NULL, // client identity
7 \; J: M/ D" H7 ^9 U% A+ t
EOAC_NONE // proxy capabilities 2 d% r, z0 Z3 J6 h5 h# f
);3 [& \' L* z) t/ L& W; f y5 H `
2 }3 J, I) f% o9 n6 v
if (FAILED(hres))
# o/ a$ B# n; j1 B# }2 }0 `
{( V. H" u1 n, q' ]; U
pSvc->Release();: h) z0 }. t9 c1 N& M
pLoc->Release();
5 Q/ x" v5 @6 Z; D5 d0 ]
CoUninitialize();& `& a8 g* |4 V A6 |
return 1;
0 Y- ~: [2 {& r) b% R% g6 M
}: e% i' f8 x5 N0 V. I/ w: ~* a
0 i X2 [! f. w9 C+ b
// 步骤6：Use the IWbemServices pointer to make requests of WMI ----
. P: O4 V( D ^9 z9 A
IEnumWbemClassObject* pEnumerator = NULL;0 y1 |' s& ?: y! W2 T0 w8 b0 ]
//计算CPUID: w9 s) ?8 h) @
hres = pSvc->ExecQuery(
" ^0 N1 S3 K5 z0 B6 y9 r( |
bstr_t("WQL"), * u9 ~, Z; n2 T+ ?' g5 Y6 O, {3 J
bstr_t("SELECT * FROM Win32_Processor"),//Win32_OperatingSystem, p1 K! L) n# W: E
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
A4 f. H/ T. U8 d( l' x
NULL,
; E4 a2 o E/ c; [' M0 U6 \
&pEnumerator);0 v5 m4 p. l) m( [4 F
+ d; L9 k- M! ^3 g# _ ^: k2 K1 H
if (FAILED(hres))3 o5 h+ `5 G& p6 |
{
* \( r9 p4 H8 g' Q7 }5 a
pSvc->Release();* K; L8 L; q1 j4 {- `# Z
pLoc->Release();
& D4 @. M* y4 H7 n
CoUninitialize();
8 b& E$ B) q2 `* F' q
return 1;6 S6 J( m5 u4 Q& `. y8 Z- ?
}
$ P& P4 K' L Y! q" d! Z0 A
// 步骤7：Get the data from the query 5 G1 T# ~2 `& N$ P0 u
IWbemClassObject *pclsObj;
# f( V) i7 C+ F8 v7 w* n! r1 A8 x
ULONG uReturn = 0;
* F- O" n: m. t
while (pEnumerator)9 n! b; s+ {0 a) t4 d
{
7 `" D; d3 P: m* ^$ _. M0 F) b
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, ( _% B) C" R. V& K4 S* f0 O
&pclsObj, &uReturn);+ Q- X! J! b; p% a
; n$ W7 D" P, H1 t( D
if(0 == uReturn)8 q- b0 x) h" Q- I9 @) [5 x4 g
{
0 r. p( U, o' Q( z! u+ Y" K1 X4 O
break;
, k/ W& }( n# l0 e+ }
}$ A& r" {& y: }. _3 ?1 g9 y
VARIANT vtProp;
# f$ ^5 s# M( w3 Y: W" x
VariantInit(&vtProp);1 V$ H% |5 v u! o0 L
hr = pclsObj->Get(L"ProcessorId", 0, &vtProp, 0, 0);' P9 n2 x/ S/ h
strProcessID=_com_util::ConvertBSTRToString(vtProp.bstrVal);//strProcessID：类级变量
7 }. ^: K" V; }: k ^1 s, ^# i1 \
}
7 K8 _& T) s1 w+ W% z
5 q6 D L1 |% _. N% [2 E
//计算硬盘系列号
% g, t# T. x5 h2 I
hres = pSvc->ExecQuery(3 C3 d/ [. n% n, k) K# F
bstr_t("WQL"),
9 Z/ C" Z6 N0 z1 x$ c6 o7 y' A
bstr_t("SELECT * FROM Win32_DiskDrive"),6 F" V/ Z& o) k: X0 ]; t E& G
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, $ F" o: l/ l6 {1 R% L3 I2 M
NULL,
" }, _+ {: k! _7 W( @
&pEnumerator);; v1 @: |! ~. @. K+ m, F& u
( ]) \6 c) N8 j( w* h( _
if (FAILED(hres))7 _6 v' F0 a$ K; z# {
{
1 U* R& }% D1 ~# U+ v
pSvc->Release();
! `" _' S# r6 ^9 C5 s2 L
pLoc->Release();( g v; r+ K& w6 P7 w; q$ Z E
CoUninitialize();* x( t! h" ?6 R5 S) \4 K/ H
return 1;
- s7 r3 V! S; ], {
}
1 y6 t2 a$ |4 w4 q* H5 j
while (pEnumerator)
# G* t, j' V- R6 I6 C( S
{: g0 `0 Z9 |9 t* w( {) v3 n5 O c
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
( Y% v% n6 x+ t7 d" P: \; Q
&pclsObj, &uReturn);
3 Q* x# H+ R- X4 }. _( T+ c# v2 |
- S9 S) r I4 G# ~+ C2 j4 p
if(0 == uReturn)8 x. p' `0 ~# ?8 Q) D, L4 k0 m
{( ~3 t1 \3 X' [- B# e7 M$ [# {* Y9 A
break;5 n+ w5 d9 p/ h ?- |6 H$ `
}# d" Q5 i& ]6 O: |) ]" K8 c
) D7 [; t# v# ]/ J& ?- v. m, t
VARIANT vtProp;5 @# d" a5 ]" d* v
VariantInit(&vtProp);
' ]6 D, s, W4 s6 I
hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0);8 b0 k2 i% d2 V
strDisk=_com_util::ConvertBSTRToString(vtProp.bstrVal);
" \. P9 G' `3 u4 g+ |/ S) H
}
. G7 v$ I/ o7 \+ x7 h" ~/ E
( q4 u8 M7 X1 X- P
pSvc->Release();( I! \/ T) t i1 ?! _
pLoc->Release();) P1 ]0 d/ Y* c& {/ e
pEnumerator->Release();
3 `7 v* K" g7 a8 T% }
pclsObj->Release();5 Z+ \6 Z( J/ \
CoUninitialize();
: b) s) f: g6 V" x% s
! L2 `! A/ S$ Q1 G: L5 r
return 0; 3 n$ m5 L, c" u% a- Q" c4 p
}8 r& T p# k) Z, J1 x: Y, G) k

复制代码

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

浏览过的版块