1 files changed, 180 insertions, 0 deletions
diff --git a/vcl/inc/driverblocklist.hxx b/vcl/inc/driverblocklist.hxx
new file mode 100644
index 000000000..542677aa3
--- /dev/null
+++ b/vcl/inc/driverblocklist.hxx
@@ -0,0 +1,180 @@
+/* -*- 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>
+
+#include <string_view>
+#include <vector>
+
+namespace DriverBlocklist
+{
+// 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,
+                                   std::u16string_view driverVersion, std::u16string_view vendorId,
+                                   const OUString& deviceId);
+
+#ifdef _WIN32
+VCL_DLLPUBLIC int32_t GetWindowsVersion();
+#endif
+
+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);
+
+VCL_DLLPUBLIC std::string_view GetVendorNameFromId(uint32_t id);
+
+// The rest should be private (only for the unittest).
+
+struct InvalidFileException
+{
+};
+
+enum OperatingSystem
+{
+    DRIVER_OS_UNKNOWN = 0,
+    DRIVER_OS_WINDOWS_FIRST,
+    DRIVER_OS_WINDOWS_7 = DRIVER_OS_WINDOWS_FIRST,
+    DRIVER_OS_WINDOWS_8,
+    DRIVER_OS_WINDOWS_8_1,
+    DRIVER_OS_WINDOWS_10,
+    DRIVER_OS_WINDOWS_LAST = DRIVER_OS_WINDOWS_10,
+    DRIVER_OS_WINDOWS_ALL,
+    DRIVER_OS_LINUX,
+    DRIVER_OS_OSX_FIRST,
+    DRIVER_OS_OSX_10_5 = DRIVER_OS_OSX_FIRST,
+    DRIVER_OS_OSX_10_6,
+    DRIVER_OS_OSX_10_7,
+    DRIVER_OS_OSX_10_8,
+    DRIVER_OS_OSX_LAST = DRIVER_OS_OSX_10_8,
+    DRIVER_OS_OSX_ALL,
+    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,
+               uint64_t driverVersion, bool bAllowListed = false,
+               const char* suggestedVersion = nullptr);
+
+    DriverInfo();
+
+    OperatingSystem meOperatingSystem;
+    OUString maAdapterVendor;
+    std::vector<OUString> maDevices;
+
+    bool mbAllowlisted;
+
+    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:
+    Parser(const OUString& rURL, std::vector<DriverInfo>& rDriverList, VersionType versionType);
+    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);
+    uint64_t getVersion(std::string_view rString);
+
+    enum class BlockType
+    {
+        ALLOWLIST,
+        DENYLIST,
+        UNKNOWN
+    };
+
+    BlockType meBlockType;
+    std::vector<DriverInfo>& mrDriverList;
+    OUString maURL;
+    const VersionType mVersionType;
+};
+
+OUString VCL_DLLPUBLIC GetVendorId(DeviceVendor id);
+
+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());
+
+#define GFX_DRIVER_VERSION(a, b, c, d)                                                             \
+    ((uint64_t(a) << 48) | (uint64_t(b) << 32) | (uint64_t(c) << 16) | uint64_t(d))
+
+inline uint64_t OpenGLVersion(uint32_t a, uint32_t b, uint32_t c, uint32_t d)
+{
+    // 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: */