hardwareinfo.cpp

墨香最新私服

// HardwareInfo.cpp: implementation of the CHardwareInfo class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "LogReporter.h"
#include "HardwareInfo.h"
#include "./info/GetDxVer.h"


#include < nb30.h >
#include < wsipx.h >
#include < wsnwlink.h >
#include < winsock2.h >



#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#include "Winsock2.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CHardwareInfo::CHardwareInfo()
{


}

CHardwareInfo::~CHardwareInfo()
{

}
CString &	CHardwareInfo::GetLocalIP()
{
	m_strLocalIP = "";
	WSADATA wsaData;
	if (WSAStartup(0x0002,&wsaData) == SOCKET_ERROR)
	{
		WSACleanup();
		return m_strLocalIP;
	}

	char szHostName[256];
	char ipAddr[256];
	HOSTENT *pHostInfo;
	IN_ADDR inAddr;

	gethostname(szHostName, 256);
	pHostInfo = gethostbyname(szHostName);

	for(int i = 0 ; pHostInfo->h_addr_list[i] != NULL ; i++)
	{
	   memcpy(&inAddr, pHostInfo->h_addr_list[i], sizeof(IN_ADDR));
	   strcpy(ipAddr, inet_ntoa(inAddr));
	   m_strLocalIP = ipAddr;
	}
	WSACleanup();
	return m_strLocalIP;
}

BOOL CHardwareInfo::GetMacAddressFromSock(LPBYTE lpMacAddress)
{
    int          iAdapters ;
    int          iOpt  = sizeof(iAdapters) ;
    int          iSize = sizeof(SOCKADDR_IPX) ;
    BOOL         bRet  = FALSE ;
    SOCKET       sock ;
    SOCKADDR_IPX adrIPX ;
    WSADATA      wsaData ;
	
    if(WSAStartup(WINSOCK_11,&wsaData)==0)
    {
        if((sock=socket(AF_IPX,SOCK_DGRAM,NSPROTO_IPX)) !=INVALID_SOCKET)
        {
            memset(&adrIPX,0x00,sizeof(SOCKADDR_IPX)) ;
            adrIPX.sa_family = AF_IPX ;
			
            if(bind(sock,(SOCKADDR*)&adrIPX,iSize)!=SOCKET_ERROR)
            {
                if(getsockopt(sock,NSPROTO_IPX,IPX_MAX_ADAPTER_NUM, (char*)&iAdapters,&iOpt)!=SOCKET_ERROR)
                {
                    while(iAdapters)
                    {
                        IPX_ADDRESS_DATA ipxAdrData ;
                        memset( &ipxAdrData,0x00, sizeof(IPX_ADDRESS_DATA)) ;
                        ipxAdrData.adapternum = --iAdapters ;
                        iOpt = sizeof(IPX_ADDRESS_DATA) ;
                        if(getsockopt(sock,NSPROTO_IPX,IPX_ADDRESS, (char*)&ipxAdrData,&iOpt)!=SOCKET_ERROR)
                        {
                            if(ipxAdrData.status==TRUE && ipxAdrData.wan==FALSE)
                            {
                                memcpy(lpMacAddress, &ipxAdrData.nodenum, MAX_MAC_ADDRESS_IN_BYTE) ;
                                bRet = TRUE ;
                                break ;
                            }
                        }
                    }
                }
            }
            closesocket(sock) ;
        }
        WSACleanup() ;
    }
    return(bRet) ;
}

BOOL CHardwareInfo::GetMacAddressFromNetBIOS(LPBYTE lpMacAddress)
{
    NCB ncb;
    LANA_ENUM le;
    
    struct tagADAPTER
    {
        ADAPTER_STATUS adapt;
        NAME_BUFFER    NameBuff[256] ;
    } adapter;
	
	memset(&le,0,sizeof(LANA_ENUM)) ;             


    memset(&ncb,0,sizeof(NCB)) ;
    ncb.ncb_command = NCBENUM ;
    ncb.ncb_buffer = (UCHAR*)&le ;
    ncb.ncb_length = sizeof(LANA_ENUM) ;
	
    if(Netbios(&ncb)==NRC_GOODRET)
    {
        memset(&ncb,0x00,sizeof(NCB)) ;
        ncb.ncb_command = NCBRESET ;
		//          ncb.ncb_callname[0] = 20 ;                   
        ncb.ncb_lana_num = le.lana[0] ;              
		
        if(Netbios(&ncb)==NRC_GOODRET)
        {
            memset(&ncb,0x00,sizeof(NCB)) ;
            memset(&ncb.ncb_callname,' ',NCBNAMSZ) ;
            ncb.ncb_callname[0] = '*' ;
			//ncb.ncb_callname[NCBNAMSZ-1] = NULL ;    
            ncb.ncb_command = NCBASTAT ;
            ncb.ncb_lana_num = le.lana[0] ;          
            ncb.ncb_buffer = (UCHAR*)&adapter ;
            ncb.ncb_length = sizeof(tagADAPTER) ;
			
            if(Netbios(&ncb)==NRC_GOODRET)
            {
                memcpy(lpMacAddress,&adapter.adapt.adapter_address, MAX_MAC_ADDRESS_IN_BYTE) ;
                return(TRUE) ;
            }
        }
    }
    return(FALSE) ;
}

CString &	CHardwareInfo::GetInfoToString()
{
	CString tmpInfo;
	m_strTotalInfo = "";


	m_strTotalInfo += GetCPUInfo();
	m_strTotalInfo += "\n";

	if(!GetOSInfo(tmpInfo))
		return m_strTotalInfo;
	m_strTotalInfo += tmpInfo;
	m_strTotalInfo += "\n";

	tmpInfo.Format("Memory : %u M", GetTotalMemorySize());
	m_strTotalInfo += tmpInfo;
	m_strTotalInfo += "\n";

	ULONG size = 0;
	if(!GetHardDiskFreeSize(size))
		return m_strTotalInfo;
	tmpInfo.Format("HardDiskFreeSize : %u M", size);
	m_strTotalInfo += tmpInfo;
	m_strTotalInfo += "\n";

	if(!GetSoundCardInfo(tmpInfo))
		return m_strTotalInfo;
	m_strTotalInfo += tmpInfo;
	m_strTotalInfo += "\n";
	

	char tmpBuf1[256];
	char tmpBuf2[256];
	int ret = GetDXVerInfo(tmpBuf1);
	m_strTotalInfo += tmpBuf1;
	m_strTotalInfo += "\n";
	
	
	DWORD dwGraphicVidMemoryToKilo = SpecVidMem(tmpBuf1, tmpBuf2);
	tmpInfo.Format("Video Memory : %s KB | AGP Memory : %s KB", tmpBuf1, tmpBuf2);
	m_strTotalInfo += tmpInfo;
	m_strTotalInfo += "\n";
	
	GRAPHICINFO tmpGInfo;
	if(!GetGraphicsCardInfo(&tmpGInfo))
		return m_strTotalInfo;

	tmpInfo.Format("Chip : %s | Ver : %s | DisplayMode : %s ", tmpGInfo.szChipName, tmpGInfo.szVersion, tmpGInfo.szDisplayMode);
	m_strTotalInfo += tmpInfo;
	m_strTotalInfo += "\n";

	if(IsCompressedTextureFormatSupport())
	{
		m_strTotalInfo += "拘绵咆胶媚 瘤盔";
		m_strTotalInfo += "\n";
	}
	else
	{
		m_strTotalInfo += "拘绵咆胶媚 瘤盔 救窃";
		m_strTotalInfo += "\n";
	}

	return m_strTotalInfo;
}
CString & CHardwareInfo::GetCPUInfo()
{
	m_strCPUInfo = m_CPUInfo.GetExtendedProcessorName();

	if ( m_CPUInfo.DoesCPUSupportFeature(SSE_FEATURE) )
	{
		m_strCPUInfo += "| Support SSE";
	}
	else
	{
		m_strCPUInfo += "| Not Support SSE";
	}

	if (m_strCPUInfo.Find("Hr", 0) == 0)
	{ 
		// cpu 加档 眉农甫 窍瘤给窍看阑锭
		LONG result;
		HKEY hKey;
		DWORD data;
		DWORD dataSize;

		// Get the processor speed info.
		result = ::RegOpenKeyEx (HKEY_LOCAL_MACHINE,
			"Hardware\\Description\\System\\CentralProcessor\\0", 0, KEY_QUERY_VALUE, &hKey);

		// Check if the function has succeeded.
		if (result == ERROR_SUCCESS) 
		{
			result = ::RegQueryValueEx (hKey, _T("~MHz"), NULL, NULL,
				(LPBYTE)&data, &dataSize);
			
			CString strCpuSpeed;
			strCpuSpeed.Format ("%d MHz", data);
			m_strCPUInfo += strCpuSpeed;
		}
	}
	else
	{
		DWORD dwSpeedMhz = m_CPUInfo.GetCPUSpeedMhz();
		CString strCpuSpeed;
		strCpuSpeed.Format ("%d MHz", dwSpeedMhz);
		m_strCPUInfo += strCpuSpeed;
	}
	
	return m_strCPUInfo;
}
BOOL CHardwareInfo::GetOSInfo(CString & strOSInfoOut)
{
	char szBuf[255] = {0,};
	char szCatBuf[64] = {0,};

	OSVERSIONINFOEX osvi;
	BOOL bOsVersionInfoEx;

	// Try calling GetVersionEx using the OSVERSIONINFOEX structure.
	// If that fails, try using the OSVERSIONINFO structure.

	ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

	if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
	{
		// If OSVERSIONINFOEX doesn't work, try OSVERSIONINFO.
		osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
		if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) ) 
			return FALSE;
	}

	switch (osvi.dwPlatformId)
	{
		// Tests for Windows NT product family.
		case VER_PLATFORM_WIN32_NT:

		// Test for the product.
		if ( osvi.dwMajorVersion <= 4 )
			sprintf(szBuf, "%s", "Microsoft Windows NT ");

		if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
			sprintf(szBuf, "%s", "Microsoft Windows 2000 ");

		if( bOsVersionInfoEx )  // Use information from GetVersionEx.
		{ 
			// Test for the workstation type.
			if ( osvi.wProductType == VER_NT_WORKSTATION )
			{
			   if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
				  strcat(szBuf, "Microsoft Windows XP ");

			   if( osvi.wSuiteMask & VER_SUITE_PERSONAL )
				  strcat(szBuf, "Home Edition " );
			   else
				  strcat(szBuf, "Professional " );
			}

			// Test for the server type.
			else if ( osvi.wProductType == VER_NT_SERVER )
			{
			   if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
				  strcat(szBuf,"Microsoft Windows .NET ");

			   if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
				  strcat(szBuf, "DataCenter Server " );
			   else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
				  if( osvi.dwMajorVersion == 4 )
					 strcat(szBuf, "Advanced Server " );
				  else
					 strcat(szBuf, "Enterprise Server " );
			   else if ( osvi.wSuiteMask == VER_SUITE_BLADE )
				  strcat(szBuf, "Web Server " );
			   else
				  strcat(szBuf, "Server " );
			}
		}
		else   // Use the registry on early versions of Windows NT.
		{
			HKEY hKey;
			char szProductType[BUFSIZE];
			DWORD dwBufLen=BUFSIZE;
			LONG lRet;

			lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
			   "SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
			   0, KEY_QUERY_VALUE, &hKey );
			if( lRet != ERROR_SUCCESS )
				return FALSE;

			lRet = RegQueryValueEx( hKey, "ProductType", NULL, NULL,
			   (LPBYTE) szProductType, &dwBufLen);
			if( (lRet != ERROR_SUCCESS) || (dwBufLen > BUFSIZE) )
				return FALSE;

			RegCloseKey( hKey );

			if ( lstrcmpi( "WINNT", szProductType) == 0 )
			   strcat(szBuf, "Professional " );
			if ( lstrcmpi( "LANMANNT", szProductType) == 0 )
			   strcat(szBuf, "Server " );
			if ( lstrcmpi( "SERVERNT", szProductType) == 0 )
			   strcat(szBuf, "Advanced Server " );
		}

		// Display version, service pack (if any), and build number.

		if ( osvi.dwMajorVersion <= 4 )
		{
			sprintf (szCatBuf, "\r\nversion %d.%d %s (Build %d)",
			   osvi.dwMajorVersion,
			   osvi.dwMinorVersion,
			   osvi.szCSDVersion,
			   osvi.dwBuildNumber & 0xFFFF);
		}
		else
		{ 
			sprintf (szCatBuf, "\r\n%s (Build %d)",
			   osvi.szCSDVersion,
			   osvi.dwBuildNumber & 0xFFFF);
		}
		break;

		// Test for the Windows 95 product family.
		case VER_PLATFORM_WIN32_WINDOWS:

		if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
		{
			 strcpy(szBuf, "Microsoft Windows 95 ");
			 if ( osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B' )
				strcat(szBuf, "OSR2 " );
		} 

		if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
		{
			 strcpy(szBuf, "Microsoft Windows 98 ");
			 if ( osvi.szCSDVersion[1] == 'A' )
				strcat(szBuf, "SE " );
		} 

		if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
		{
			 strcpy (szBuf, "Microsoft Windows Millennium Edition ");
		} 
		break;
	}

	if ( strcmp(szCatBuf, "\0") != 0 )
	{ // 眠啊荤亲捞 乐促.
		strcat (szBuf, szCatBuf);
	}
	
	strOSInfoOut = m_strOSInfo = szBuf;
	return TRUE;
}

DWORD CHardwareInfo::GetTotalMemorySize()
{
	MEMORYSTATUS	state;

	memset(&state, 0, sizeof(state));
	state.dwLength = sizeof (state);
	GlobalMemoryStatus(&state);

	DWORD	dwTotalMemory;
	dwTotalMemory = DWORD(state.dwTotalPhys / MEGA)+1;

	return dwTotalMemory;
}

BOOL CHardwareInfo::GetHardDiskFreeSize(ULONG & FreeDiskSizeOut)
{
	FreeDiskSizeOut = 0;
	char  szBuf[255];
	GetCurrentDirectory(255, szBuf); 

    ULARGE_INTEGER FreeBytesAvailableToCaller;	// receives the number of bytes on // disk available to the caller
    ULARGE_INTEGER TotalNumberOfBytes;			// receives the number of bytes on disk
    ULARGE_INTEGER TotalNumberOfFreeBytes;		// receives the free bytes on disk

	int iRet;
	iRet = GetDiskFreeSpaceEx(szBuf,					// current directory information	
		&FreeBytesAvailableToCaller, 
		&TotalNumberOfBytes,
		&TotalNumberOfFreeBytes);
	if (0 == iRet)
	{
		return FALSE;
	}

	ULONG	ulFreeMegaBytes = ULONG(TotalNumberOfFreeBytes.QuadPart / MEGA);	// 1048576 == 1024^2
	//_ultoa(ulFreeMegaBytes, szBuf, 10);

	FreeDiskSizeOut = ulFreeMegaBytes;
	return TRUE;
}

BOOL CHardwareInfo::GetSoundCardInfo(CString & strSoundCardInfoOut)
{
	
	HRESULT				hr;
	char				szBuf[255] = {'\0', };


	LPDIRECTSOUND	lpDS = NULL;

    if( FAILED( hr = DirectSoundCreate(0, &lpDS, NULL ) ) )
	{
		strSoundCardInfoOut = "No Driver";
        return FALSE;
	}
    if( FAILED( hr = DirectSoundEnumerate( (LPDSENUMCALLBACK)DSoundEnumCallback,
                                                  (VOID*)szBuf ) ) )
	{
		strSoundCardInfoOut = "No Driver";
		MessageBox(NULL,"Error : DirectSoundCaptureEnumerate!!", "宫氢柯扼牢", MB_OK);
        return FALSE;
	}

    if(lpDS)
	{
		lpDS->Release();
		lpDS = NULL;
	}

	strSoundCardInfoOut = szBuf;

	return TRUE;
}

DWORD CHardwareInfo::GetDXVerInfo(char * pszDxVer)
{
	HRESULT hr;
    DWORD	dwDXVersion;
	char	strResult[128];
	
	hr = GetDXVersion(&dwDXVersion, pszDxVer, 10);
    if( SUCCEEDED(hr) )
    {
        if( dwDXVersion > 0 )
            _sntprintf( strResult, 128, TEXT("DirectX %s installed"), pszDxVer );
        else
            _tcsncpy( strResult, TEXT("DirectX not installed"), 128 );
        strResult[127] = 0;
    }
    else
    {
        _sntprintf( strResult, 128, TEXT("Unknown version of DirectX installed"), hr );
        strResult[127] = 0;
    }

	strcpy(pszDxVer, strResult);