在Win平台得到磁盘、CPU、用户信息

2019独角兽企业重金招聘Python工程师标准>>>

// SN.h: interface for the CSN class.

#if !defined(AFX_SN_H__54CD147E_A7EE_4C0E_A9DA_2AA865F5C62D__INCLUDED_)

#define AFX_SN_H__54CD147E_A7EE_4C0E_A9DA_2AA865F5C62D__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

//Get HardDisk ID

#define FILE_DEVICE_SCSI 0x0000001b

#define IOCTL_SCSI_MINIPORT_IDENTIFY ( ( FILE_DEVICE_SCSI << 16 ) + 0x0501 )

#define IOCTL_SCSI_MINIPORT 0x0004D008 // see NTDDSCSI.H for definition

#define IDENTIFY_BUFFER_SIZE 512

#define SENDIDLENGTH ( sizeof( SENDCMDOUTPARAMS ) + IDENTIFY_BUFFER_SIZE )

#define IDE_ATAPI_IDENTIFY 0xA1 // Returns ID sector for ATAPI.

#define IDE_ATA_IDENTIFY 0xEC // Returns ID sector for ATA.

#define DFP_RECEIVE_DRIVE_DATA 0x0007c088

class CSN

{

//struct

public:

typedef struct _DRIVERSTATUS

{

BYTE bDriverError; // Error code from driver, or 0 if no error.

BYTE bIDEStatus; // Contents of IDE Error register.

// Only valid when bDriverError is SMART_IDE_ERROR.

BYTE bReserved[2]; // Reserved for future expansion.

DWORD dwReserved[2]; // Reserved for future expansion.

} DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS;

typedef struct _SENDCMDOUTPARAMS

{

DWORD cBufferSize; // Size of bBuffer in bytes

DRIVERSTATUS DriverStatus; // Driver status structure.

BYTE bBuffer[1]; // Buffer of arbitrary length in which to store the data read from the // drive.

} SENDCMDOUTPARAMS, *PSENDCMDOUTPARAMS, *LPSENDCMDOUTPARAMS;

typedef struct _IDEREGS

{

BYTE bFeaturesReg; // Used for specifying SMART "commands".

BYTE bSectorCountReg; // IDE sector count register

BYTE bSectorNumberReg; // IDE sector number register

BYTE bCylLowReg; // IDE low order cylinder value

BYTE bCylHighReg; // IDE high order cylinder value

BYTE bDriveHeadReg; // IDE drive/head register

BYTE bCommandReg; // Actual IDE command.

BYTE bReserved; // reserved for future use. Must be zero.

} IDEREGS, *PIDEREGS, *LPIDEREGS;

typedef struct _SENDCMDINPARAMS

{

DWORD cBufferSize; // Buffer size in bytes

IDEREGS irDriveRegs; // Structure with drive register values.

BYTE bDriveNumber; // Physical drive number to send

// command to (0,1,2,3).

BYTE bReserved[3]; // Reserved for future expansion.

DWORD dwReserved[4]; // For future use.

BYTE bBuffer[1]; // Input buffer.

} SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS;

typedef struct _GETVERSIONOUTPARAMS

{

BYTE bVersion; // Binary driver version.

BYTE bRevision; // Binary driver revision.

BYTE bReserved; // Not used.

BYTE bIDEDeviceMap; // Bit map of IDE devices.

DWORD fCapabilities; // Bit mask of driver capabilities.

DWORD dwReserved[4]; // For future use.

} GETVERSIONOUTPARAMS, *PGETVERSIONOUTPARAMS, *LPGETVERSIONOUTPARAMS;

typedef struct _SRB_IO_CONTROL

{

ULONG HeaderLength;

UCHAR Signature[8];

ULONG Timeout;

ULONG ControlCode;

ULONG ReturnCode;

ULONG Length;

} SRB_IO_CONTROL, *PSRB_IO_CONTROL;

typedef struct _IDSECTOR

{

USHORT wGenConfig;

USHORT wNumCyls;

USHORT wReserved;

USHORT wNumHeads;

USHORT wBytesPerTrack;

USHORT wBytesPerSector;

USHORT wSectorsPerTrack;

USHORT wVendorUnique[3];

CHAR sSerialNumber[20];

USHORT wBufferType;

USHORT wBufferSize;

USHORT wECCSize;

CHAR sFirmwareRev[8];

CHAR sModelNumber[40];

USHORT wMoreVendorUnique;

USHORT wDoubleWordIO;

USHORT wCapabilities;

USHORT wReserved1;

USHORT wPIOTiming;

USHORT wDMATiming;

USHORT wBS;

USHORT wNumCurrentCyls;

USHORT wNumCurrentHeads;

USHORT wNumCurrentSectorsPerTrack;

ULONG ulCurrentSectorCapacity;

USHORT wMultSectorStuff;

ULONG ulTotalAddressableSectors;

USHORT wSingleWordDMA;

USHORT wMultiWordDMA;

BYTE bReserved[128];

} IDSECTOR, *PIDSECTOR;

public:

static CString GetDiskInformation();

CSN();

virtual ~CSN();

static CString GetComputerCPUID(); //CPU ID 8char 16[1-9,A-F]

static CString GetLoginUserName();

protected:

static BOOL WinNTHDSerialNumAsPhysicalRead( BYTE* dwSerial, UINT* puSerialLen, UINT uMaxSerialLen );

static BOOL DoIdentify( HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP, PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum, PDWORD lpcbBytesReturned );

static BOOL WinNTHDSerialNumAsScsiRead( BYTE* dwSerial, UINT* puSerialLen, UINT uMaxSerialLen );

};

#endif // !defined(AFX_SN_H__54CD147E_A7EE_4C0E_A9DA_2AA865F5C62D__INCLUDED_)

// SN.cpp: implementation of the CSN class.

#include "stdafx.h"

#include "SN.h"

//#include <windows.h> // Not USE

//#pragma comment(lib, "Kernel32.lib") // not use

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

// Construction/Destruction

CSN::CSN()

{

}

CSN::~CSN()

{

}

//************************************

// Method: GetLoginUserName

// FullName: CSN::GetLoginUserName

// Access: public

// Returns: CString

// Qualifier: Get User Login Name

// 很多人使用Administertor 超级管理员姓名相同

//************************************

CString CSN::GetLoginUserName()

{

CString name=_T("");

DWORD len=256;

#ifdef _UNICODE

TCHAR pUserName[256];

GetUserName(pUserName,&len);

pUserName[len]='0';

name = pUserName;

delete[] pUserName;

#else

char pUserName[20];

GetUserName(pUserName,&len);

pUserName[len]='0';

name = pUserName;

#endif

return name;

}

//************************************

// Method: GetComputerCPUID

// FullName: CSN::GetComputerCPUID

// Access: public

// Returns: CString

// Qualifier: Get CUP ID is 8Char [0-9,A-F]

// Unicode and ANSI is OK

// 很多机器CPU相同

//************************************

CString CSN::GetComputerCPUID()

{

CString cpuID="";

int len=0;

BYTE sCpu[4096];

UINT uCpuLen = 0;

int bException = 0;

BYTE szCpu[16] = { 0 };

UINT uCpuID = 0U;

//汇编语言

_asm

{

mov eax, 0

cpuid

mov dword ptr szCpu[0], ebx

mov dword ptr szCpu[4], edx

mov dword ptr szCpu[8], ecx

mov eax, 1

cpuid

mov uCpuID, edx

}

if( !bException )

{

char scpu[516];

sprintf(scpu,"%02X",uCpuID);

CopyMemory( sCpu ,scpu, strlen(scpu));

uCpuLen = strlen(scpu);

uCpuID = strlen( ( char* )szCpu );

CopyMemory( sCpu + uCpuLen, szCpu, uCpuID );

uCpuLen += uCpuID;

cpuID=scpu;

cpuID.TrimLeft();

cpuID.TrimRight();

#ifdef _UNICODE

delete[] scpu;

#else

#endif

return cpuID;

}

return _T("");

}

CString CSN::GetDiskInformation()

{

// #define MAX_VOLUMENAME 4096

// #define MAX_FILESYSTEMNAME 1024

CString szDiskInformation=_T("");

// TCHAR szVolumeName[MAX_VOLUMENAME];

// DWORD dwVolumeSerialNumber= 0;

// DWORD dwMaximumComponentLength=0;

// DWORD dwFileSystemFlags=0;

// TCHAR szFileSystemName[MAX_FILESYSTEMNAME];

// TCHAR *pDriveName;

// if (GetVolumeInformationA(pDriveName,szVolumeName,

// MAX_VOLUMENAME,

// &dwVolumeSerialNumber,

// &dwMaximumComponentLength,

// &dwFileSystemFlags,

// szFileSystemName,

// MAX_FILESYSTEMNAME))

// {

// AfxMessageBox(szVolumeName);

// printf("VolumeName:%s\n",szVolumeName);

// printf("VolumeSerialNumber:%ld\n",dwVolumeSerialNumber);

// printf("MaximumComponentLength:%ld\n",dwMaximumComponentLength);

// printf("FileSystemFlags:%ld\n",dwFileSystemFlags);

// printf("FileSystemName:%s\n",szFileSystemName);

// }

// ULARGE_INTEGER nFreeBytesAvailable;

// ULARGE_INTEGER nTotalNumberOfBytes;

// ULARGE_INTEGER nTotalNumberOfFreeBytes;

// if (GetDiskFreeSpaceEx(pDriveName,

// &nFreeBytesAvailable,

// &nTotalNumberOfBytes,

// &nTotalNumberOfFreeBytes))

// {

// DWORD dw = 0;

// dw= (DWORD)(nFreeBytesAvailable.QuadPart/(1024*1024));

// printf("FreeBytesAvailable:%.2fGB\n",(DOUBLE)(dw)/1024);

// dw= (DWORD)(nTotalNumberOfBytes.QuadPart/(1024*1024));

// printf("TotalNumberOfBytes:%.2fGB\n",(DOUBLE)(dw)/1024);

// dw= (DWORD)(nTotalNumberOfFreeBytes.QuadPart/(1024*1024));

// printf("TotalNumberOfFreeBytes:%.2fGB\n",(DOUBLE)(dw)/1024);

// }

CString mDiskID="";

int len=0;

BYTE sDisk[4096]; // 在程序执行完毕后，此处存储取得的系统特征码

UINT uDiskLen = 0; // 在程序执行完毕后，此处存储取得的系统特征码的长度

// BYTE sCpu[4096]; // 在程序执行完毕后，此处存储取得的系统特征码

UINT uCpuLen = 0; // 在程序执行完毕后，此处存储取得的系统特征码的长度

OSVERSIONINFO ovi = { 0 };

ovi.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );

GetVersionEx( &ovi );

// Only Windows 2000, Windows XP, Windows Server 2003...

if( ovi.dwPlatformId != VER_PLATFORM_WIN32_NT )

return _T("");

if(WinNTHDSerialNumAsPhysicalRead( sDisk, &uDiskLen, 1024 ) )

{

//printf("IDE硬盘\n");

//return mDiskID;

sDisk[uDiskLen]=0;

}

else if(WinNTHDSerialNumAsScsiRead( sDisk, &uDiskLen, 1024 ))

{

//printf("SCSI硬盘\n");

//return mDiskID;

sDisk[uDiskLen]=0;

}

//磁盘序号

char i='a';

char mcode[1024];

CopyMemory(mcode ,sDisk,uDiskLen);

//自定义序号

len=uDiskLen+uCpuLen;

mcode[len]=0;

mDiskID=mcode;

mDiskID.TrimLeft();

mDiskID.TrimRight();

int strLen=0;

strLen=mDiskID.GetLength();

mDiskID =mDiskID.Mid(0,strLen);

szDiskInformation = mDiskID ;

return szDiskInformation;

}

//获得HardID 辅助函数

BOOL CSN::WinNTHDSerialNumAsPhysicalRead( BYTE* dwSerial, UINT* puSerialLen, UINT uMaxSerialLen )

{

#define DFP_GET_VERSION 0x00074080

BOOL bInfoLoaded = FALSE;

CString szDriveNum=_T("");

CString szDriverFile=_T("\\\\.\\PhysicalDrive");

for( UINT uDrive = 0; uDrive < 8; ++ uDrive )

{

HANDLE hPhysicalDriveIOCTL = 0;

// Try to get a handle to PhysicalDrive IOCTL, report failure

// and exit if can't.

szDriveNum.Format(_T("%d"),uDrive);

#ifdef _UNICODE

szDriverFile += szDriveNum;

int nSize = szDriverFile.GetLength();

TCHAR* szDriveName = new TCHAR[nSize+1];

szDriveName = szDriverFile.GetBuffer(nSize);

szDriverFile.ReleaseBuffer();

#else

char szDriveName [256];

sprintf( szDriveName, "\\\\.\\PhysicalDrive%d", uDrive );

#endif

//AfxMessageBox((LPCTSTR)szDriveName);

// Windows NT, Windows 2000, must have admin rights

hPhysicalDriveIOCTL = CreateFile((LPCTSTR) szDriveName,

GENERIC_READ | GENERIC_WRITE,

FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,

OPEN_EXISTING, 0, NULL);

if( hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE )

{

GETVERSIONOUTPARAMS VersionParams = { 0 };

DWORD cbBytesReturned = 0;

// Get the version, etc of PhysicalDrive IOCTL

if( DeviceIoControl( hPhysicalDriveIOCTL, DFP_GET_VERSION,

NULL,

&VersionParams,

sizeof( GETVERSIONOUTPARAMS ),

&cbBytesReturned, NULL ) )

{

// If there is a IDE device at number "i" issue commands

// to the device

if( VersionParams.bIDEDeviceMap != 0 )

{

BYTE bIDCmd = 0; // IDE or ATAPI IDENTIFY cmd

SENDCMDINPARAMS scip = { 0 };

// 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

bIDCmd = ( VersionParams.bIDEDeviceMap >> uDrive & 0x10 ) ? IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;

BYTE IdOutCmd[sizeof( SENDCMDOUTPARAMS ) + IDENTIFY_BUFFER_SIZE - 1] = { 0 };

if( DoIdentify( hPhysicalDriveIOCTL,

&scip,

( PSENDCMDOUTPARAMS )&IdOutCmd,

( BYTE )bIDCmd,

( BYTE )uDrive,

&cbBytesReturned ) )

{

if( * puSerialLen + 20U <= uMaxSerialLen )

{

CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )( ( ( PSENDCMDOUTPARAMS )IdOutCmd )->bBuffer ) ) + 10, 20 ); // 序列号

// Cut off the trailing blanks

UINT i;

for( i = 20; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i ) {}

* puSerialLen += i;

CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )( ( ( PSENDCMDOUTPARAMS )IdOutCmd )->bBuffer ) ) + 27, 40 ); // 型号

// Cut off the trailing blanks

for( i = 40; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i ) {}

* puSerialLen += i;

bInfoLoaded = TRUE;

}

else

{

::CloseHandle( hPhysicalDriveIOCTL );

return bInfoLoaded;

}

CloseHandle( hPhysicalDriveIOCTL );

}

return bInfoLoaded;

}

//获得HardID 辅助函数

BOOL CSN::WinNTHDSerialNumAsScsiRead( BYTE* dwSerial, UINT* puSerialLen, UINT uMaxSerialLen )

{

BOOL bInfoLoaded = FALSE;

for( int iController = 0; iController < 2; ++ iController )

{

HANDLE hScsiDriveIOCTL = 0;

char szDriveName[256];

// Try to get a handle to PhysicalDrive IOCTL, report failure

// and exit if can't.

sprintf( szDriveName, "\\\\.\\Scsi%d:", iController );

// Windows NT, Windows 2000, any rights should do

hScsiDriveIOCTL = CreateFile((LPCTSTR)szDriveName,

GENERIC_READ | GENERIC_WRITE,

FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,

OPEN_EXISTING, 0, NULL);

// if (hScsiDriveIOCTL == INVALID_HANDLE_VALUE)

// printf ("Unable to open SCSI controller %d, error code: 0x%lX\n",

// controller, GetLastError ());

if( hScsiDriveIOCTL != INVALID_HANDLE_VALUE )

{

int iDrive = 0;

for( iDrive = 0; iDrive < 2; ++ iDrive )

{

char szBuffer[sizeof( SRB_IO_CONTROL ) + SENDIDLENGTH] = { 0 };

SRB_IO_CONTROL* p = ( SRB_IO_CONTROL* )szBuffer;

SENDCMDINPARAMS* pin = ( SENDCMDINPARAMS* )( szBuffer + sizeof( SRB_IO_CONTROL ) );

DWORD dwResult;

p->HeaderLength = sizeof( SRB_IO_CONTROL );

p->Timeout = 10000;

p->Length = SENDIDLENGTH;

p->ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;

strncpy( ( char* )p->Signature, "SCSIDISK", 8 );

pin->irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY;

pin->bDriveNumber = iDrive;

if( DeviceIoControl( hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT,

szBuffer,

sizeof( SRB_IO_CONTROL ) + sizeof( SENDCMDINPARAMS ) - 1,

szBuffer,

sizeof( SRB_IO_CONTROL ) + SENDIDLENGTH,

&dwResult, NULL ) )

{

SENDCMDOUTPARAMS* pOut = ( SENDCMDOUTPARAMS* )( szBuffer + sizeof( SRB_IO_CONTROL ) );

IDSECTOR* pId = ( IDSECTOR* )( pOut->bBuffer );

if( pId->sModelNumber[0] )

{

if( * puSerialLen + 20U <= uMaxSerialLen )

{

// 序列号

CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )pId ) + 10, 20 );

// Cut off the trailing blanks

UINT i;

for( i = 20; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i )

{}

* puSerialLen += i;

// 型号

CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )pId ) + 27, 40 );

// Cut off the trailing blanks

for( i = 40; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i )

{}

* puSerialLen += i;

bInfoLoaded = TRUE;

}

else

{

::CloseHandle( hScsiDriveIOCTL );

return bInfoLoaded;

}

::CloseHandle( hScsiDriveIOCTL );

}

return bInfoLoaded;

}

//获得HardID 辅助函数

BOOL CSN::DoIdentify( HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,

PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum,

PDWORD lpcbBytesReturned )

{

// 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;

// calc the drive number.

pSCIP->irDriveRegs.bDriveHeadReg = 0xA0 | ( ( bDriveNum & 1 ) << 4 );

// The command can either be IDE identify or ATAPI identify.

pSCIP->irDriveRegs.bCommandReg = bIDCmd;

pSCIP->bDriveNumber = bDriveNum;

pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;

return DeviceIoControl( hPhysicalDriveIOCTL, DFP_RECEIVE_DRIVE_DATA,

( LPVOID ) pSCIP,

sizeof( SENDCMDINPARAMS ) - 1,

( LPVOID ) pSCOP,

sizeof( SENDCMDOUTPARAMS ) + IDENTIFY_BUFFER_SIZE - 1,

lpcbBytesReturned, NULL );

}

http://www.oschina.net/code/snippet_100389_10035

转载于:https://my.oschina.net/u/558276/blog/63773

在Win平台得到磁盘、CPU、用户信息相关推荐

java获取微信用户源码_Java微信公众平台开发(十)--微信用户信息的获取
前面的文章有讲到微信的一系列开发文章,包括token获取.菜单创建等,在这一篇将讲述在微信公众平台开发中如何获取微信用户的信息,在上一篇我们有说道微信用户和微信公众账号之间的联系可以通过Openid关 ...
间谍程序Exodus移植到iOS平台上恐窃取用户信息
资安业者Lookout指出,过去在Android平台上肆虐的间谍程序Exodus已被移植到iOS平台上,且利用苹果专为大型企业设计的Apple Developer Enterprise Program ...
MySQL优化系列3-Linux查看CPU、内存、磁盘、网络信息
备注:测试数据库版本为MySQL 8.0 文章目录一.查看CPU信息 1.1 查看物理CPU个数 1.2 查看每个物理CPU中core的个数(即核数) 1.3 查看逻辑CPU的个数 1.4 查看CP ...
vc++6.0获取磁盘基本信息_分享一个实用脚本--一键获取linux内存、cpu、磁盘IO等信息...
概述今天主要分享一个shell脚本,用来获取linux系统CPU.内存.磁盘IO等信息. 脚本 #!/bin/bash # 获取要监控的本地服务器IP地址 IP=`ifconfig | grep i ...
Shell - 监控某个进程的内存占用情况、主机CPU、磁盘空间等信息以及守护进程
文章目录脚本启动的两种方式方式一注册到系统Cron 方式二运行结果 linux内存.cpu.磁盘IO 脚本 #!/bin/sh ############################## ...
获取Linux内存、cpu、磁盘IO等信息
#!/bin/bash # 获取要监控的本地服务器IP地址 IP=`ifconfig | grep inet | grep -vE 'inet6|127.0.0.1' | awk '{print $2 ...
一键获取linux内存、cpu、磁盘IO等信息脚本编写，及其原理详解
一.脚本今天主要分享一个shell脚本,用来获取linux系统CPU.内存.磁盘IO等信息. #!/bin/bash # 获取要监控的本地服务器IP地址 IP=`ifconfig | grep in ...
linux cpu 内存爆满 mysql停止_如何用脚本统计linux系统CPU、内存、磁盘IO等信息？...
概述今天主要分享一个shell脚本,用来获取linux系统CPU.内存.磁盘IO等信息. 脚本 #!/bin/bash# 获取要监控的本地服务器IP地址IP=`ifconfig | grep ine ...
.net 实现微信公众平台的用户信息获取
public string getSubUserFkId() { log.Info("开始去微信服务器获取关注用户信息!");//大家可以把 ...

在Win平台得到磁盘、CPU、用户信息

在Win平台得到磁盘、CPU、用户信息相关推荐

最新文章

热门文章