tf2/tf2_src/vstdlib/osversion.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//

#include "vstdlib/osversion.h"
#include "winlite.h"
#include "strtools.h"
#include "tier0/dbg.h"

#ifdef OSX
#include <CoreServices/CoreServices.h>
#endif

//-----------------------------------------------------------------------------
// Purpose: return the OS type for this machine
//-----------------------------------------------------------------------------
EOSType GetOSType()
{
	static EOSType eOSVersion = k_eOSUnknown;

#if defined( _WIN32 ) && !defined( _X360 )
	if ( eOSVersion == k_eOSUnknown || eOSVersion == k_eWinUnknown )
	{
		eOSVersion = k_eWinUnknown;
		OSVERSIONINFOEX osvi;
		Q_memset( &osvi, 0x00, sizeof(osvi) );
		osvi.dwOSVersionInfoSize = sizeof(osvi);
		
		if ( GetVersionEx( (OSVERSIONINFO *) &osvi ) )
		{
			switch ( osvi.dwPlatformId )
			{
			case VER_PLATFORM_WIN32_NT:
				if ( osvi.dwMajorVersion <= 4 )
				{
					eOSVersion = k_eWinNT;
				}
				else if ( osvi.dwMajorVersion == 5 )
				{
					switch(  osvi.dwMinorVersion ) 
					{
					case 0:
						eOSVersion = k_eWin2000;
						break;
					case 1:
						eOSVersion = k_eWinXP;
						break;
					case 2:
						eOSVersion = k_eWin2003;
						break;
					}
				}
				else if ( osvi.dwMajorVersion >= 6 )
				{
					if ( osvi.wProductType == VER_NT_WORKSTATION )
					{
						switch ( osvi.dwMinorVersion )
						{
						case 0:
							eOSVersion = k_eWinVista;
							break;
						case 1:
							eOSVersion = k_eWindows7;
							break;
						}
					}
					else /* ( osvi.wProductType != VER_NT_WORKSTATION ) */
					{
						switch ( osvi.dwMinorVersion )
						{
						case 0:
							eOSVersion = k_eWin2008;	// Windows 2008, not R2
							break;
						case 1:
							eOSVersion = k_eWin2008;	// Windows 2008 R2
							break;
						}
					}
				}
				break;
			case VER_PLATFORM_WIN32_WINDOWS:
				switch ( osvi.dwMinorVersion )
				{
				case 0:
					eOSVersion = k_eWin95;
					break;
				case 10:
					eOSVersion = k_eWin98;
					break;
				case 90:
					eOSVersion = k_eWinME;
					break;
				}
				break;
			case VER_PLATFORM_WIN32s:
				eOSVersion = k_eWin311;
				break;
			}
		}
	}
#elif defined(OSX)
	if ( eOSVersion == k_eOSUnknown )
	{
		SInt32 MajorVer = 0;
		SInt32 MinorVer = 0;
		SInt32 PatchVer = 0;
		OSErr err = noErr;
		err = Gestalt( gestaltSystemVersionMajor, &MajorVer );
		if ( err != noErr )
			return k_eOSUnknown;
		err = Gestalt( gestaltSystemVersionMinor, &MinorVer );
		if ( err != noErr )
			return k_eOSUnknown;
		err = Gestalt( gestaltSystemVersionBugFix, &PatchVer );
		if ( err != noErr )
			return k_eOSUnknown;
		
		switch ( MajorVer )
		{
			case 10:
			{
				switch( MinorVer )
				{
					case 4:
						eOSVersion = k_eMacOS104;
						break;
					case 5:
						eOSVersion = k_eMacOS105;						
						switch ( PatchVer )
						{
							case 8:
								eOSVersion = k_eMacOS1058;								
							default:
								break;
						}
						break;
					case 6:
						eOSVersion = k_eMacOS106;
						switch ( PatchVer )
						{
							case 1:
							case 2:
								break;
							case 3:
							default:
								// note the default here - 10.6.4 (5,6...) >= 10.6.3, so we want to 
								// identify as 10.6.3 for sysreqs purposes
								eOSVersion = k_eMacOS1063;
								break;
						}
						break;
					case 7:
						eOSVersion = k_eMacOS107;							
						break;
					default:
						break;
				}
			}
			default:
				break;
		}
	}
#elif defined(LINUX)
	if ( eOSVersion == k_eOSUnknown )
	{
		
		FILE *fpKernelVer = fopen( "/proc/version", "r" );
		
		if ( !fpKernelVer )
			return k_eLinuxUnknown;
		
		char rgchVersionLine[1024];
		char *pchRet = fgets( rgchVersionLine, sizeof(rgchVersionLine), fpKernelVer );
		fclose( fpKernelVer );
		
		eOSVersion = k_eLinuxUnknown;
		
		// move past "Linux version "
		const char *pchVersion = rgchVersionLine + Q_strlen( "Linux version " );
		if ( pchRet && *pchVersion == '2' && *(pchVersion+1) == '.' )
		{
			pchVersion += 2; // move past "2."
			if ( *pchVersion == '2' && *(pchVersion+1) == '.' )
				eOSVersion = k_eLinux22;
			else if ( *pchVersion == '4' && *(pchVersion+1) == '.' )
				eOSVersion = k_eLinux24;
			else if ( *pchVersion == '6' && *(pchVersion+1) == '.' )
				eOSVersion = k_eLinux26;
		}
	}
#endif
	return eOSVersion;
}

//-----------------------------------------------------------------------------
// Purpose: get platform-specific OS details (distro, on linux)
// returns a pointer to the input buffer on success (for convenience), 
// NULL on failure.
//-----------------------------------------------------------------------------
const char *GetOSDetailString( char *pchOutBuf, int cchOutBuf )
{
#if defined WIN32 
	(void)( pchOutBuf );
	(void)( cchOutBuf );
	// no interesting details
	return NULL;
#else
#if defined LINUX
	// we're about to go poking around to see if we can figure out distribution
	// looking @ any /etc file is fragile (people can change 'em), 
	// but since this is just hardware survey data, we're not super concerned.  
	// a bunch of OS-specific issue files
	const char *pszIssueFile[] =
	{
		"/etc/redhat-release",
		"/etc/fedora-release",
		"/etc/slackware-release",
		"/etc/debian_release",
		"/etc/mandrake-release",
		"/etc/yellowdog-release",
		"/etc/gentoo-release",
		"/etc/lsb-release",
		"/etc/SUSE-release",
	};
	if ( !pchOutBuf )
		return NULL;

	for (int i = 0; i < Q_ARRAYSIZE( pszIssueFile ); i++ )
	{
		FILE *fdInfo = fopen( pszIssueFile[i], "r" );
		if ( !fdInfo  )
			continue;
		
		// prepend the buffer with the name of the file we found for easier grouping
		snprintf( pchOutBuf, cchOutBuf, "%s\n", pszIssueFile[i] );
		int cchIssueFile = strlen( pszIssueFile[i] ) + 1;
		ssize_t cubRead = fread( (void*) (pchOutBuf + cchIssueFile) , sizeof(char), cchOutBuf - cchIssueFile, fdInfo );
		fclose( fdInfo );

		if ( cubRead < 0 )
			return NULL;

		// null terminate
		pchOutBuf[ MIN( cubRead, cchOutBuf-1 ) ] = '\0';
		return pchOutBuf;
	}
#endif
	// if all else fails, just send back uname -a
	if ( !pchOutBuf )
		return NULL;
	FILE *fpUname = popen( "uname -mrsv", "r" );
	if ( !fpUname )
		return NULL;
	size_t cchRead = fread( pchOutBuf, sizeof(char), cchOutBuf, fpUname );
	pclose( fpUname );

	pchOutBuf[ MIN( cchRead, (size_t)cchOutBuf-1 ) ] = '\0';
	return pchOutBuf;
#endif
}


//-----------------------------------------------------------------------------
// Purpose: get a friendly name for an OS type
//-----------------------------------------------------------------------------
const char *GetNameFromOSType( EOSType eOSType )
{
	switch ( eOSType )
	{
	case k_eWinUnknown:
		return "Windows";
	case k_eWin311:
		return "Windows 3.11";
	case k_eWin95:
		return "Windows 95";
	case k_eWin98:
		return "Windows 98";
	case k_eWinME:
		return "Windows ME";
	case k_eWinNT:
		return "Windows NT";
	case k_eWin2000:
		return "Windows 2000";
	case k_eWinXP:
		return "Windows XP";
	case k_eWin2003:
		return "Windows 2003";
	case k_eWinVista:
		return "Windows Vista";
	case k_eWindows7:
		return "Windows 7";
	case k_eWin2008:
		return "Windows 2008";
#ifdef POSIX
	case k_eMacOSUnknown:
		return "Mac OS";
	case k_eMacOS104:
		return "MacOS 10.4";
	case k_eMacOS105:
		return "MacOS 10.5";
	case k_eMacOS1058:
		return "MacOS 10.5.8";
	case k_eMacOS106:
		return "MacOS 10.6";
	case k_eMacOS1063:
		return "MacOS 10.6.3";
	case k_eMacOS107:
		return "MacOS 10.7";
	case k_eLinuxUnknown:
		return "Linux";
	case k_eLinux22:
		return "Linux 2.2";
	case k_eLinux24:
		return "Linux 2.4";
	case k_eLinux26:
		return "Linux 2.6";
#endif
	default:
	case k_eOSUnknown:
		return "Unknown";
	}
}


// friendly name to OS type, MUST be same size as EOSType enum
struct OSTypeNameTuple
{
	EOSType m_OSType;
	const char *m_pchOSName;

};

const OSTypeNameTuple k_rgOSTypeToName[] = 
{
	{ k_eOSUnknown, "unknown" },
	{ k_eMacOSUnknown, "macos" },
	{ k_eMacOS104, "macos104" },
	{ k_eMacOS105, "macos105" },
	{ k_eMacOS1058, "macos1058" },
	{ k_eMacOS106, "macos106" },
	{ k_eMacOS1063, "macos1063" },
	{ k_eMacOS107, "macos107" },
	{ k_eLinuxUnknown, "linux" },
	{ k_eLinux22, "linux22" },
	{ k_eLinux24, "linux24" },
	{ k_eLinux26, "linux26" },
	{ k_eWinUnknown, "windows" },
	{ k_eWin311, "win311" },
	{ k_eWin95, "win95" },
	{ k_eWin98, "win98" },
	{ k_eWinME, "winME" },
	{ k_eWinNT, "winNT" },
	{ k_eWin2000, "win200" },
	{ k_eWinXP, "winXP" },
	{ k_eWin2003, "win2003" },
	{ k_eWinVista, "winVista" },
	{ k_eWindows7, "win7" },
	{ k_eWin2008, "win2008" },
};

//-----------------------------------------------------------------------------
// Purpose: convert a friendly OS name to a eostype
//-----------------------------------------------------------------------------
EOSType GetOSTypeFromString_Deprecated( const char *pchName )
{
	EOSType eOSType;
#ifdef WIN32
	eOSType = k_eWinUnknown;
#else
	eOSType = k_eOSUnknown;
#endif

	// if this fires, make sure all OS types are in the map
	Assert( Q_ARRAYSIZE( k_rgOSTypeToName ) == k_eOSTypeMax ); 
	if ( !pchName || Q_strlen( pchName ) == 0 )
		return eOSType;

	for ( int iOS = 0; iOS < Q_ARRAYSIZE( k_rgOSTypeToName ) ; iOS++ )
	{
		if ( !Q_stricmp( k_rgOSTypeToName[iOS].m_pchOSName, pchName ) ) 
			return k_rgOSTypeToName[iOS].m_OSType;
	}
	return eOSType;
}

bool OSTypesAreCompatible( EOSType eOSTypeDetected, EOSType eOSTypeRequired )
{
	// check windows (on the positive side of the number line)
	if ( eOSTypeRequired >= k_eWinUnknown )
		return ( eOSTypeDetected >= eOSTypeRequired );

	if ( eOSTypeRequired == k_eOSUnknown )
		return true;

	// osx
	if ( eOSTypeRequired >= k_eMacOSUnknown && eOSTypeRequired < k_eOSUnknown )
		return ( eOSTypeDetected >= eOSTypeRequired && eOSTypeDetected < k_eOSUnknown );

	// and linux
	if ( eOSTypeRequired >= k_eLinuxUnknown && eOSTypeRequired < k_eMacOSUnknown )
		return ( eOSTypeDetected >= eOSTypeRequired && eOSTypeDetected < k_eMacOSUnknown );

	return false;
}

// these strings "windows", "macos", "linux" are part of the
// interface, which is why they're hard-coded here, rather than using
// the strings in k_rgOSTypeToName
const char *GetPlatformName( bool *pbIs64Bit )
{
	if ( pbIs64Bit )
		*pbIs64Bit = Is64BitOS();
	
	EOSType eType = GetOSType(); 
	if ( OSTypesAreCompatible( eType, k_eWinUnknown ) )
		return "windows";
	if ( OSTypesAreCompatible( eType, k_eMacOSUnknown ) )
		return "macos";
	if ( OSTypesAreCompatible( eType, k_eLinuxUnknown ) )
		return "linux";
	return "unknown";
}