mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2024-11-28 00:06:09 +03:00
239 lines
8.7 KiB
C++
239 lines
8.7 KiB
C++
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef BASE_WIN_WINDOWS_VERSION_H_
|
|
#define BASE_WIN_WINDOWS_VERSION_H_
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <string>
|
|
|
|
#include "base/base_export.h"
|
|
#include "base/gtest_prod_util.h"
|
|
#include "base/version.h"
|
|
|
|
using HANDLE = void*;
|
|
struct _OSVERSIONINFOEXW;
|
|
struct _SYSTEM_INFO;
|
|
|
|
namespace base {
|
|
namespace test {
|
|
class ScopedOSInfoOverride;
|
|
} // namespace test
|
|
} // namespace base
|
|
|
|
namespace base {
|
|
namespace win {
|
|
|
|
// The running version of Windows. This is declared outside OSInfo for
|
|
// syntactic sugar reasons; see the declaration of GetVersion() below.
|
|
// NOTE: Keep these in order so callers can do things like
|
|
// "if (base::win::GetVersion() >= base::win::Version::VISTA) ...".
|
|
enum class Version {
|
|
PRE_XP = 0, // Not supported.
|
|
XP = 1,
|
|
SERVER_2003 = 2, // Also includes XP Pro x64 and Server 2003 R2.
|
|
VISTA = 3, // Also includes Windows Server 2008.
|
|
WIN7 = 4, // Also includes Windows Server 2008 R2.
|
|
WIN8 = 5, // Also includes Windows Server 2012.
|
|
WIN8_1 = 6, // Also includes Windows Server 2012 R2.
|
|
WIN10 = 7, // Threshold 1: Version 1507, Build 10240.
|
|
WIN10_TH2 = 8, // Threshold 2: Version 1511, Build 10586.
|
|
WIN10_RS1 = 9, // Redstone 1: Version 1607, Build 14393.
|
|
// Also includes Windows Server 2016
|
|
WIN10_RS2 = 10, // Redstone 2: Version 1703, Build 15063.
|
|
WIN10_RS3 = 11, // Redstone 3: Version 1709, Build 16299.
|
|
WIN10_RS4 = 12, // Redstone 4: Version 1803, Build 17134.
|
|
WIN10_RS5 = 13, // Redstone 5: Version 1809, Build 17763.
|
|
// Also includes Windows Server 2019
|
|
WIN10_19H1 = 14, // 19H1: Version 1903, Build 18362.
|
|
WIN10_19H2 = 15, // 19H2: Version 1909, Build 18363.
|
|
WIN10_20H1 = 16, // 20H1: Build 19041.
|
|
WIN10_20H2 = 17, // 20H2: Build 19042.
|
|
WIN10_21H1 = 18, // 21H1: Build 19043.
|
|
WIN10_21H2 = 19, // Win10 21H2: Build 19044.
|
|
SERVER_2022 = 20, // Server 2022: Build 20348.
|
|
WIN11 = 21, // Win11 21H2: Build 22000.
|
|
WIN_LAST, // Indicates error condition.
|
|
};
|
|
|
|
// A rough bucketing of the available types of versions of Windows. This is used
|
|
// to distinguish enterprise enabled versions from home versions and potentially
|
|
// server versions. Keep these values in the same order, since they are used as
|
|
// is for metrics histogram ids.
|
|
enum VersionType {
|
|
SUITE_HOME = 0,
|
|
SUITE_PROFESSIONAL,
|
|
SUITE_SERVER,
|
|
SUITE_ENTERPRISE,
|
|
SUITE_EDUCATION,
|
|
SUITE_EDUCATION_PRO,
|
|
SUITE_LAST,
|
|
};
|
|
|
|
// A singleton that can be used to query various pieces of information about the
|
|
// OS and process state. Note that this doesn't use the base Singleton class, so
|
|
// it can be used without an AtExitManager.
|
|
class BASE_EXPORT OSInfo {
|
|
public:
|
|
struct VersionNumber {
|
|
uint32_t major;
|
|
uint32_t minor;
|
|
uint32_t build;
|
|
uint32_t patch;
|
|
};
|
|
|
|
struct ServicePack {
|
|
int major;
|
|
int minor;
|
|
};
|
|
|
|
// The processor architecture this copy of Windows natively uses. For
|
|
// example, given an x64-capable processor, we have three possibilities:
|
|
// 32-bit Chrome running on 32-bit Windows: X86_ARCHITECTURE
|
|
// 32-bit Chrome running on 64-bit Windows via WOW64: X64_ARCHITECTURE
|
|
// 64-bit Chrome running on 64-bit Windows: X64_ARCHITECTURE
|
|
enum WindowsArchitecture {
|
|
X86_ARCHITECTURE,
|
|
X64_ARCHITECTURE,
|
|
IA64_ARCHITECTURE,
|
|
ARM64_ARCHITECTURE,
|
|
OTHER_ARCHITECTURE,
|
|
};
|
|
|
|
static OSInfo* GetInstance();
|
|
|
|
OSInfo(const OSInfo&) = delete;
|
|
OSInfo& operator=(const OSInfo&) = delete;
|
|
|
|
// Separate from the rest of OSInfo so it can be used during early process
|
|
// initialization.
|
|
static WindowsArchitecture GetArchitecture();
|
|
|
|
// Returns the OS Version as returned from a call to GetVersionEx().
|
|
const Version& version() const { return version_; }
|
|
|
|
// Returns detailed version info containing major, minor, build and patch.
|
|
const VersionNumber& version_number() const { return version_number_; }
|
|
|
|
// The Kernel32* set of functions return the OS version as determined by a
|
|
// call to VerQueryValue() on kernel32.dll. This avoids any running App Compat
|
|
// shims from manipulating the version reported.
|
|
Version Kernel32Version() const;
|
|
VersionNumber Kernel32VersionNumber() const;
|
|
base::Version Kernel32BaseVersion() const;
|
|
|
|
// These helper functions return information about common scenarios of
|
|
// interest in regards to WOW emulation.
|
|
bool IsWowDisabled() const; // Chrome bitness matches OS bitness.
|
|
bool IsWowX86OnAMD64() const; // Chrome x86 on an AMD64 host machine.
|
|
bool IsWowX86OnARM64() const; // Chrome x86 on an ARM64 host machine.
|
|
bool IsWowAMD64OnARM64()
|
|
const; // Chrome AMD64 build on an ARM64 host machine.
|
|
bool IsWowX86OnOther() const; // Chrome x86 on some other x64 host machine.
|
|
|
|
// Functions to determine Version Type (e.g. Enterprise/Home) and Service Pack
|
|
// value. See above for definitions of these values.
|
|
const VersionType& version_type() const { return version_type_; }
|
|
const ServicePack& service_pack() const { return service_pack_; }
|
|
const std::string& service_pack_str() const { return service_pack_str_; }
|
|
|
|
// Returns the number of processors on the system.
|
|
const int& processors() const { return processors_; }
|
|
|
|
// Returns the allocation granularity. See
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/ns-sysinfoapi-system_info.
|
|
const size_t& allocation_granularity() const {
|
|
return allocation_granularity_;
|
|
}
|
|
|
|
// Processor name as read from registry.
|
|
std::string processor_model_name();
|
|
|
|
// Returns the "ReleaseId" (Windows 10 release number) from the registry.
|
|
const std::string& release_id() const { return release_id_; }
|
|
|
|
private:
|
|
friend class base::test::ScopedOSInfoOverride;
|
|
FRIEND_TEST_ALL_PREFIXES(OSInfo, MajorMinorBuildToVersion);
|
|
|
|
// This enum contains a variety of 32-bit process types that could be
|
|
// running with consideration towards WOW64.
|
|
enum class WowProcessMachine {
|
|
kDisabled, // Chrome bitness matches OS bitness.
|
|
kX86, // 32-bit (x86) Chrome.
|
|
kARM32, // 32-bit (arm32) Chrome.
|
|
kOther, // all other 32-bit Chrome.
|
|
kUnknown,
|
|
};
|
|
|
|
// This enum contains a variety of 64-bit host machine architectures that
|
|
// could be running with consideration towards WOW64.
|
|
enum class WowNativeMachine {
|
|
kARM64, // 32-bit Chrome running on ARM64 Windows.
|
|
kAMD64, // 32-bit Chrome running on AMD64 Windows.
|
|
kOther, // 32-bit Chrome running on all other 64-bit Windows.
|
|
kUnknown,
|
|
};
|
|
|
|
// This is separate from GetInstance() so that ScopedOSInfoOverride
|
|
// can override it in tests.
|
|
static OSInfo** GetInstanceStorage();
|
|
|
|
OSInfo(const _OSVERSIONINFOEXW& version_info,
|
|
const _SYSTEM_INFO& system_info,
|
|
int os_type);
|
|
~OSInfo();
|
|
|
|
// Returns a Version value for a given OS version tuple.
|
|
static Version MajorMinorBuildToVersion(uint32_t major,
|
|
uint32_t minor,
|
|
uint32_t build);
|
|
|
|
// Returns the architecture of the process machine within the WOW emulator.
|
|
WowProcessMachine GetWowProcessMachineArchitecture(const int process_machine);
|
|
|
|
// Returns the architecture of the native (host) machine using the WOW
|
|
// emulator.
|
|
WowNativeMachine GetWowNativeMachineArchitecture(const int native_machine);
|
|
|
|
void InitializeWowStatusValuesFromLegacyApi(HANDLE process_handle);
|
|
|
|
void InitializeWowStatusValuesForProcess(HANDLE process_handle);
|
|
|
|
Version version_;
|
|
VersionNumber version_number_;
|
|
VersionType version_type_;
|
|
ServicePack service_pack_;
|
|
|
|
// Represents the version of the OS associated to a release of
|
|
// Windows 10. Each version may have different releases (such as patch
|
|
// updates). This is the identifier of the release.
|
|
// Example:
|
|
// Windows 10 Version 1809 (OS build 17763) has multiple releases
|
|
// (i.e. build 17763.1, build 17763.195, build 17763.379, ...).
|
|
// See https://docs.microsoft.com/en-us/windows/windows-10/release-information
|
|
// for more information.
|
|
std::string release_id_;
|
|
|
|
// A string, such as "Service Pack 3", that indicates the latest Service Pack
|
|
// installed on the system. If no Service Pack has been installed, the string
|
|
// is empty.
|
|
std::string service_pack_str_;
|
|
int processors_;
|
|
size_t allocation_granularity_;
|
|
WowProcessMachine wow_process_machine_;
|
|
WowNativeMachine wow_native_machine_;
|
|
std::string processor_model_name_;
|
|
};
|
|
|
|
// Because this is by far the most commonly-requested value from the above
|
|
// singleton, we add a global-scope accessor here as syntactic sugar.
|
|
BASE_EXPORT Version GetVersion();
|
|
|
|
} // namespace win
|
|
} // namespace base
|
|
|
|
#endif // BASE_WIN_WINDOWS_VERSION_H_
|