CWE-ou-minkata/Sources/Plasma/NucleusLib/pnUtils/Private/Win32/pnUtW32Misc.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
/*****************************************************************************
*
*	$/Plasma20/Sources/Plasma/NucleusLib/pnUtils/Private/Win32/pnUtW32Misc.cpp
*	
***/

#include "../../Pch.h"
#pragma	hdrstop

/*****************************************************************************
*
*	Private
*
***/
static MEMORYSTATUSEX s_memstatus;

/*****************************************************************************
*
*	Exports
*
***/

//============================================================================
const wchar	* AppGetCommandLine	() {
	return GetCommandLineW();
}

//============================================================================
void MachineGetName	(wchar *computerName, unsigned int length) {
	DWORD len =	length;
	GetComputerNameW(computerName, &len);
}

/*****************************************************************************
*
*	System status
*
***/

//============================================================================
void MemoryGetStatus (MemoryStatus * status) {
	MEMORYSTATUSEX mem;
	mem.dwLength = sizeof(mem);
	GlobalMemoryStatusEx(&mem);

	const qword	BYTES_PER_MB = 1024	* 1024;
	status->totalPhysMB			= unsigned(mem.ullTotalPhys		/ BYTES_PER_MB);
	status->availPhysMB			= unsigned(mem.ullAvailPhys		/ BYTES_PER_MB);
	status->totalPageFileMB		= unsigned(mem.ullTotalPageFile	/ BYTES_PER_MB);
	status->availPageFileMB		= unsigned(mem.ullAvailPageFile	/ BYTES_PER_MB);
	status->totalVirtualMB		= unsigned(mem.ullTotalVirtual	/ BYTES_PER_MB);   
	status->availVirtualMB		= unsigned(mem.ullAvailVirtual	/ BYTES_PER_MB);
	status->memoryLoad			= mem.dwMemoryLoad;
}

//============================================================================
void DiskGetStatus (ARRAY(DiskStatus) *	disks) {
	for	(;;) {
		DWORD length = GetLogicalDriveStrings(0, NULL);
		if (!length	|| length >	2048)
			break;

		wchar *	buffer = ALLOCA(wchar, length +	1);
		if (!GetLogicalDriveStringsW(length, buffer))
			break;

		for	(; *buffer;	buffer += StrLen(buffer) + 1) {
			UINT driveType = GetDriveTypeW(buffer);
			if (driveType != DRIVE_FIXED)
				continue;

			ULARGE_INTEGER freeBytes;
			ULARGE_INTEGER totalBytes;
			if (!GetDiskFreeSpaceExW(buffer, &freeBytes, &totalBytes, NULL))
				continue;

			DiskStatus status;
			StrCopy(status.name, buffer, arrsize(status.name));

			const qword	BYTES_PER_MB = 1024	* 1024;
			status.totalSpaceMB	= unsigned(totalBytes.QuadPart / BYTES_PER_MB);
			status.freeSpaceMB	= unsigned(freeBytes.QuadPart  / BYTES_PER_MB);

			disks->Add(status);
		}
		break;
	}
}

//============================================================================
// Loosely taken from MS's cpuid code sample
void CpuGetInfo (
	word *	cpuCaps,
	dword *	cpuVendor,
	word *	cpuSignature
) {
	dword signature	= 0;
	dword extended	= 0;
	dword flags[2]	= {	0, 0 };
	cpuVendor[0]	= 0;

	_asm {
		// Detect if cpuid instruction is supported	by attempting
		// to change the ID	bit	of EFLAGS
		pushfd
		pop	eax				// get EFLAGS
		mov	ecx, eax		// store copy of original EFLAGS
		xor	eax, 0x200000	// flip	ID bit 
		push eax
		popfd				// replace EFLAGS
		pushfd				// get EFLAGS
		pop	eax
		xor	eax, ecx
		je DONE

		// Get processor id	(GenuineIntel, AuthenticAMD, etc)
		xor	eax, eax
		cpuid
		mov	edi, cpuVendor
		mov	[edi + 0], ebx
		mov	[edi + 4], edx
		mov	[edi + 8], ecx

		// Check if	capability flags are supported
		cmp	eax, 1
		jl DONE

		// Get processor capability flags and signature
		mov	eax, 1
		cpuid
		mov	signature, eax
		mov	[flags + 0], edx
		mov	[flags + 4], ecx

		// Check for extended capabilities
		mov	eax, 0x80000000
		cpuid
		cmp	eax, 0x80000001
		jl DONE

		// Get extended	capabilities
		mov	eax, 0x80000001
		cpuid
		mov	extended, edx

DONE:
	}

	// Decode capability flags
	const static struct	CpuCap {
		word	cpuFlag;
		byte	field;
		byte	bit;
	} s_caps[] = {
		// feature		field	bit
		// -------		-----	---
		{ kCpuCapCmov,	0,		15	},
		{ kCpuCapEst,	1,		7	},
		{ kCpuCapHtt,	0,		28	},
		{ kCpuCapMmx,	0,		23	},
		{ kCpuCapPsn,	0,		18	},
		{ kCpuCapSse,	0,		25	},
		{ kCpuCapSse2,	0,		26	},
		{ kCpuCapSse3,	1,		0	},
		{ kCpuCapTsc,	0,		4	},
	};
	for	(unsigned i	= 0; i < arrsize(s_caps); ++i) {
		const CpuCap & cap = s_caps[i];
		if (flags[cap.field] & (1 << cap.bit))
			*cpuCaps |=	cap.cpuFlag;
	}

	// Copy	signature
	*cpuSignature =	word(signature & 0xfff);

	// If this is an AMD CPU, check	for	3DNow support
	const char * vendorAmd = "AuthenticAMD";
	if (!MemCmp(vendorAmd, cpuVendor, 12)) {
		if (extended & (1 << 31))
			*cpuCaps |=	kCpuCap3dNow;
	}
}