You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

427 lines
10 KiB

//========= 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";
}