2020-02-12 03:23:54 -06:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
|
|
/*
|
|
|
|
* This file is part of the LibreOffice project.
|
|
|
|
*
|
|
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef INCLUDED_VCL_DRIVERBLOCKLIST_HXX
|
|
|
|
#define INCLUDED_VCL_DRIVERBLOCKLIST_HXX
|
|
|
|
|
|
|
|
#include <vcl/dllapi.h>
|
|
|
|
#include <xmlreader/xmlreader.hxx>
|
2020-09-07 15:21:36 -05:00
|
|
|
|
|
|
|
#include <string_view>
|
2020-02-12 03:23:54 -06:00
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
namespace DriverBlocklist
|
|
|
|
{
|
2020-09-21 09:44:32 -05:00
|
|
|
// Details of how to treat a version number.
|
|
|
|
enum class VersionType
|
|
|
|
{
|
|
|
|
OpenGL, // a.b.c.d, 1.98 > 1.978
|
|
|
|
Vulkan // a.b.c , 1.98 < 1.978
|
|
|
|
};
|
|
|
|
|
|
|
|
VCL_DLLPUBLIC bool IsDeviceBlocked(const OUString& blocklistURL, VersionType versionType,
|
2020-12-11 10:44:34 -06:00
|
|
|
std::u16string_view driverVersion, std::u16string_view vendorId,
|
2020-09-21 09:44:32 -05:00
|
|
|
const OUString& deviceId);
|
2020-02-12 03:23:54 -06:00
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
VCL_DLLPUBLIC int32_t GetWindowsVersion();
|
|
|
|
#endif
|
|
|
|
|
2020-02-18 08:55:46 -06:00
|
|
|
enum DeviceVendor
|
|
|
|
{
|
|
|
|
VendorAll,
|
|
|
|
VendorIntel,
|
|
|
|
VendorNVIDIA,
|
|
|
|
VendorAMD,
|
|
|
|
VendorMicrosoft,
|
|
|
|
};
|
|
|
|
const int DeviceVendorMax = VendorMicrosoft + 1;
|
|
|
|
|
|
|
|
/// Returns vendor for the given vendor ID, or VendorAll if not known.
|
|
|
|
VCL_DLLPUBLIC DeviceVendor GetVendorFromId(uint32_t id);
|
|
|
|
|
2020-09-07 15:21:36 -05:00
|
|
|
VCL_DLLPUBLIC std::string_view GetVendorNameFromId(uint32_t id);
|
2020-04-09 08:47:34 -05:00
|
|
|
|
2020-02-12 03:23:54 -06:00
|
|
|
// The rest should be private (only for the unittest).
|
|
|
|
|
|
|
|
struct InvalidFileException
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
|
|
|
enum OperatingSystem
|
|
|
|
{
|
|
|
|
DRIVER_OS_UNKNOWN = 0,
|
2020-09-28 02:59:42 -05:00
|
|
|
DRIVER_OS_WINDOWS_FIRST,
|
|
|
|
DRIVER_OS_WINDOWS_7 = DRIVER_OS_WINDOWS_FIRST,
|
2020-02-12 03:23:54 -06:00
|
|
|
DRIVER_OS_WINDOWS_8,
|
|
|
|
DRIVER_OS_WINDOWS_8_1,
|
|
|
|
DRIVER_OS_WINDOWS_10,
|
2020-09-28 02:59:42 -05:00
|
|
|
DRIVER_OS_WINDOWS_LAST = DRIVER_OS_WINDOWS_10,
|
|
|
|
DRIVER_OS_WINDOWS_ALL,
|
2020-02-12 03:23:54 -06:00
|
|
|
DRIVER_OS_LINUX,
|
2020-09-28 02:59:42 -05:00
|
|
|
DRIVER_OS_OSX_FIRST,
|
|
|
|
DRIVER_OS_OSX_10_5 = DRIVER_OS_OSX_FIRST,
|
2020-02-12 03:23:54 -06:00
|
|
|
DRIVER_OS_OSX_10_6,
|
|
|
|
DRIVER_OS_OSX_10_7,
|
|
|
|
DRIVER_OS_OSX_10_8,
|
2020-09-28 02:59:42 -05:00
|
|
|
DRIVER_OS_OSX_LAST = DRIVER_OS_OSX_10_8,
|
|
|
|
DRIVER_OS_OSX_ALL,
|
2020-02-12 03:23:54 -06:00
|
|
|
DRIVER_OS_ANDROID,
|
|
|
|
DRIVER_OS_ALL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum VersionComparisonOp
|
|
|
|
{
|
|
|
|
DRIVER_LESS_THAN, // driver < version
|
|
|
|
DRIVER_LESS_THAN_OR_EQUAL, // driver <= version
|
|
|
|
DRIVER_GREATER_THAN, // driver > version
|
|
|
|
DRIVER_GREATER_THAN_OR_EQUAL, // driver >= version
|
|
|
|
DRIVER_EQUAL, // driver == version
|
|
|
|
DRIVER_NOT_EQUAL, // driver != version
|
|
|
|
DRIVER_BETWEEN_EXCLUSIVE, // driver > version && driver < versionMax
|
|
|
|
DRIVER_BETWEEN_INCLUSIVE, // driver >= version && driver <= versionMax
|
|
|
|
DRIVER_BETWEEN_INCLUSIVE_START, // driver >= version && driver < versionMax
|
|
|
|
DRIVER_COMPARISON_IGNORED
|
|
|
|
};
|
|
|
|
|
|
|
|
struct DriverInfo
|
|
|
|
{
|
|
|
|
DriverInfo(OperatingSystem os, const OUString& vendor, VersionComparisonOp op,
|
2020-07-05 20:39:12 -05:00
|
|
|
uint64_t driverVersion, bool bAllowListed = false,
|
2020-02-12 03:23:54 -06:00
|
|
|
const char* suggestedVersion = nullptr);
|
|
|
|
|
|
|
|
DriverInfo();
|
|
|
|
|
|
|
|
OperatingSystem meOperatingSystem;
|
|
|
|
OUString maAdapterVendor;
|
|
|
|
std::vector<OUString> maDevices;
|
|
|
|
|
2020-07-05 20:39:12 -05:00
|
|
|
bool mbAllowlisted;
|
2020-02-12 03:23:54 -06:00
|
|
|
|
|
|
|
VersionComparisonOp meComparisonOp;
|
|
|
|
|
|
|
|
/* versions are assumed to be A.B.C.D packed as 0xAAAABBBBCCCCDDDD */
|
|
|
|
uint64_t mnDriverVersion;
|
|
|
|
uint64_t mnDriverVersionMax;
|
|
|
|
|
|
|
|
OUString maSuggestedVersion;
|
|
|
|
OUString maMsg;
|
|
|
|
};
|
|
|
|
|
|
|
|
class VCL_DLLPUBLIC Parser
|
|
|
|
{
|
|
|
|
public:
|
2020-09-21 09:44:32 -05:00
|
|
|
Parser(const OUString& rURL, std::vector<DriverInfo>& rDriverList, VersionType versionType);
|
2020-02-12 03:23:54 -06:00
|
|
|
bool parse();
|
|
|
|
|
|
|
|
private:
|
|
|
|
void handleEntry(DriverInfo& rDriver, xmlreader::XmlReader& rReader);
|
|
|
|
void handleList(xmlreader::XmlReader& rReader);
|
|
|
|
void handleContent(xmlreader::XmlReader& rReader);
|
|
|
|
static void handleDevices(DriverInfo& rDriver, xmlreader::XmlReader& rReader);
|
2020-12-11 10:44:34 -06:00
|
|
|
uint64_t getVersion(std::string_view rString);
|
2020-02-12 03:23:54 -06:00
|
|
|
|
|
|
|
enum class BlockType
|
|
|
|
{
|
2020-07-05 20:39:12 -05:00
|
|
|
ALLOWLIST,
|
2020-07-05 20:01:51 -05:00
|
|
|
DENYLIST,
|
2020-02-12 03:23:54 -06:00
|
|
|
UNKNOWN
|
|
|
|
};
|
|
|
|
|
|
|
|
BlockType meBlockType;
|
|
|
|
std::vector<DriverInfo>& mrDriverList;
|
|
|
|
OUString maURL;
|
2020-09-21 09:44:32 -05:00
|
|
|
const VersionType mVersionType;
|
2020-02-12 03:23:54 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
OUString VCL_DLLPUBLIC GetVendorId(DeviceVendor id);
|
|
|
|
|
2020-12-11 10:44:34 -06:00
|
|
|
bool VCL_DLLPUBLIC FindBlocklistedDeviceInList(std::vector<DriverInfo>& aDeviceInfos,
|
|
|
|
VersionType versionType,
|
|
|
|
std::u16string_view sDriverVersion,
|
|
|
|
std::u16string_view sAdapterVendorID,
|
|
|
|
OUString const& sAdapterDeviceID,
|
|
|
|
OperatingSystem system,
|
|
|
|
const OUString& blocklistURL = OUString());
|
2020-02-12 03:23:54 -06:00
|
|
|
|
|
|
|
#define GFX_DRIVER_VERSION(a, b, c, d) \
|
|
|
|
((uint64_t(a) << 48) | (uint64_t(b) << 32) | (uint64_t(c) << 16) | uint64_t(d))
|
|
|
|
|
2020-09-21 09:44:32 -05:00
|
|
|
inline uint64_t OpenGLVersion(uint32_t a, uint32_t b, uint32_t c, uint32_t d)
|
2020-02-12 03:23:54 -06:00
|
|
|
{
|
|
|
|
// We make sure every driver number is padded by 0s, this will allow us the
|
|
|
|
// easiest 'compare as if decimals' approach. See ParseDriverVersion for a
|
|
|
|
// more extensive explanation of this approach.
|
|
|
|
while (b > 0 && b < 1000)
|
|
|
|
{
|
|
|
|
b *= 10;
|
|
|
|
}
|
|
|
|
while (c > 0 && c < 1000)
|
|
|
|
{
|
|
|
|
c *= 10;
|
|
|
|
}
|
|
|
|
while (d > 0 && d < 1000)
|
|
|
|
{
|
|
|
|
d *= 10;
|
|
|
|
}
|
|
|
|
return GFX_DRIVER_VERSION(a, b, c, d);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|