vcl/opengl/win/WinDeviceInfo.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <opengl/win/WinDeviceInfo.hxx>
  11
  12 #include <opengl/win/blocklist_parser.hxx>
  13 #include <config_folders.h>
  14
  15 #if !defined WIN32_LEAN_AND_MEAN
  16 # define WIN32_LEAN_AND_MEAN
  17 #endif
  18 #include <windows.h>
  19 #include <objbase.h>
  20 #include <setupapi.h>
  21 #include <algorithm>
  22 #include <cstdint>
  23 #include <memory>
  24
  25 #include <osl/file.hxx>
  26 #include <rtl/bootstrap.hxx>
  27 #include <rtl/ustrbuf.hxx>
  28 #include <tools/stream.hxx>
  29 #include <o3tl/char16_t2wchar_t.hxx>
  30
  31 #include <desktop/crashreport.hxx>
  32
  33 OUString* WinOpenGLDeviceInfo::mpDeviceVendors[wgl::DeviceVendorMax];
  34 std::vector<wgl::DriverInfo> WinOpenGLDeviceInfo::maDriverInfo;
  35
  36 namespace {
  37
  38 /*
  39  * Compute the length of an array with constant length.  (Use of this method
  40  * with a non-array pointer will not compile.)
  41  *
  42  * Beware of the implicit trailing '\0' when using this with string constants.
  43 */
  44 template<typename T, size_t N>
  45 size_t ArrayLength(T (&)[N])
  46 {
  47     return N;
  48 }
  49
  50 #define GFX_DRIVER_VERSION(a,b,c,d) \
  51 ((uint64_t(a)<<48) | (uint64_t(b)<<32) | (uint64_t(c)<<16) | uint64_t(d))
  52
  53 bool GetKeyValue(const WCHAR* keyLocation, const WCHAR* keyName, OUString& destString, int type)
  54 {
  55     HKEY key;
  56     DWORD dwcbData;
  57     DWORD dValue;
  58     DWORD resultType;
  59     LONG result;
  60     bool retval = true;
  61
  62     result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, keyLocation, 0, KEY_QUERY_VALUE, &key);
  63     if (result != ERROR_SUCCESS)
  64     {
  65         return false;
  66     }
  67
  68     switch (type)
  69     {
  70         case REG_DWORD:
  71             {
  72                 // We only use this for vram size
  73                 dwcbData = sizeof(dValue);
  74                 result = RegQueryValueExW(key, keyName, nullptr, &resultType,
  75                         reinterpret_cast<LPBYTE>(&dValue), &dwcbData);
  76                 if (result == ERROR_SUCCESS && resultType == REG_DWORD)
  77                 {
  78                     dValue = dValue / 1024 / 1024;
  79                     destString += OUString::number(int32_t(dValue));
  80                 }
  81                 else
  82                 {
  83                     retval = false;
  84                 }
  85                 break;
  86             }
  87         case REG_MULTI_SZ:
  88             {
  89                 // A chain of null-separated strings; we convert the nulls to spaces
  90                 WCHAR wCharValue[1024];
  91                 dwcbData = sizeof(wCharValue);
  92
  93                 result = RegQueryValueExW(key, keyName, nullptr, &resultType,
  94                         reinterpret_cast<LPBYTE>(wCharValue), &dwcbData);
  95                 if (result == ERROR_SUCCESS && resultType == REG_MULTI_SZ)
  96                 {
  97                     // This bit here could probably be cleaner.
  98                     bool isValid = false;
  99
 100                     DWORD strLen = dwcbData/sizeof(wCharValue[0]);
 101                     for (DWORD i = 0; i < strLen; i++)
 102                     {
 103                         if (wCharValue[i] == '\0')
 104                         {
 105                             if (i < strLen - 1 && wCharValue[i + 1] == '\0')
 106                             {
 107                                 isValid = true;
 108                                 break;
 109                             }
 110                             else
 111                             {
 112                                 wCharValue[i] = ' ';
 113                             }
 114                         }
 115                     }
 116
 117                     // ensure wCharValue is null terminated
 118                     wCharValue[strLen-1] = '\0';
 119
 120                     if (isValid)
 121                         destString = OUString(o3tl::toU(wCharValue));
 122
 123                 }
 124                 else
 125                 {
 126                     retval = false;
 127                 }
 128
 129                 break;
 130             }
 131     }
 132     RegCloseKey(key);
 133
 134     return retval;
 135 }
 136
 137 // The device ID is a string like PCI\VEN_15AD&DEV_0405&SUBSYS_040515AD
 138 // this function is used to extract the id's out of it
 139 uint32_t ParseIDFromDeviceID(const OUString &key, const char *prefix, int length)
 140 {
 141     OUString id = key.toAsciiUpperCase();
 142     OUString aPrefix = OUString::fromUtf8(prefix);
 143     int32_t start = id.indexOf(aPrefix);
 144     if (start != -1)
 145     {
 146         id = id.copy(start + aPrefix.getLength(), length);
 147     }
 148     return id.toUInt32(16);
 149 }
 150
 151 // OS version in 16.16 major/minor form
 152 // based on http://msdn.microsoft.com/en-us/library/ms724834(VS.85).aspx
 153 enum {
 154     kWindowsUnknown    = 0,
 155     kWindowsXP         = 0x00050001,
 156     kWindowsServer2003 = 0x00050002,
 157     kWindowsVista      = 0x00060000,
 158     kWindows7          = 0x00060001,
 159     kWindows8          = 0x00060002,
 160     kWindows8_1        = 0x00060003,
 161     kWindows10         = 0x000A0000  // Major 10 Minor 0
 162 };
 163
 164
 165 wgl::OperatingSystem WindowsVersionToOperatingSystem(int32_t aWindowsVersion)
 166 {
 167     switch(aWindowsVersion)
 168     {
 169         case kWindowsXP:
 170             return wgl::DRIVER_OS_WINDOWS_XP;
 171         case kWindowsServer2003:
 172             return wgl::DRIVER_OS_WINDOWS_SERVER_2003;
 173         case kWindowsVista:
 174             return wgl::DRIVER_OS_WINDOWS_VISTA;
 175         case kWindows7:
 176             return wgl::DRIVER_OS_WINDOWS_7;
 177         case kWindows8:
 178             return wgl::DRIVER_OS_WINDOWS_8;
 179         case kWindows8_1:
 180             return wgl::DRIVER_OS_WINDOWS_8_1;
 181         case kWindows10:
 182             return wgl::DRIVER_OS_WINDOWS_10;
 183         case kWindowsUnknown:
 184         default:
 185             return wgl::DRIVER_OS_UNKNOWN;
 186     };
 187 }
 188
 189
 190 int32_t WindowsOSVersion()
 191 {
 192     static int32_t winVersion = kWindowsUnknown;
 193
 194     if (winVersion == kWindowsUnknown)
 195     {
 196         // GetVersion(Ex) and VersionHelpers (based on VerifyVersionInfo) API are
 197         // subject to manifest-based behavior since Windows 8.1, so give wrong results.
 198         // Another approach would be to use NetWkstaGetInfo, but that has some small
 199         // reported delays (some milliseconds), and might get slower in domains with
 200         // poor network connections.
 201         // So go with a solution described at https://msdn.microsoft.com/en-us/library/ms724429
 202         HINSTANCE hLibrary = LoadLibraryW(L"kernel32.dll");
 203         if (hLibrary != nullptr)
 204         {
 205             wchar_t szPath[MAX_PATH];
 206             DWORD dwCount = GetModuleFileNameW(hLibrary, szPath, SAL_N_ELEMENTS(szPath));
 207             FreeLibrary(hLibrary);
 208             if (dwCount != 0 && dwCount < SAL_N_ELEMENTS(szPath))
 209             {
 210                 dwCount = GetFileVersionInfoSizeW(szPath, nullptr);
 211                 if (dwCount != 0)
 212                 {
 213                     std::unique_ptr<char> ver(new char[dwCount]);
 214                     if (GetFileVersionInfoW(szPath, 0, dwCount, ver.get()) != FALSE)
 215                     {
 216                         void* pBlock = nullptr;
 217                         UINT dwBlockSz = 0;
 218                         if (VerQueryValueW(ver.get(), L"\\", &pBlock, &dwBlockSz) != FALSE && dwBlockSz >= sizeof(VS_FIXEDFILEINFO))
 219                         {
 220                             VS_FIXEDFILEINFO *vinfo = static_cast<VS_FIXEDFILEINFO *>(pBlock);
 221                             winVersion = int32_t(vinfo->dwProductVersionMS);
 222                         }
 223                     }
 224                 }
 225             }
 226         }
 227     }
 228
 229     return winVersion;
 230 }
 231
 232 // This allows us to pad driver version 'substrings' with 0s, this
 233 // effectively allows us to treat the version numbers as 'decimals'. This is
 234 // a little strange but this method seems to do the right thing for all
 235 // different vendor's driver strings. i.e. .98 will become 9800, which is
 236 // larger than .978 which would become 9780.
 237 void PadDriverDecimal(char *aString)
 238 {
 239     for (int i = 0; i < 4; i++)
 240     {
 241         if (!aString[i])
 242         {
 243             for (int c = i; c < 4; c++)
 244             {
 245                 aString[c] = '0';
 246             }
 247             break;
 248         }
 249     }
 250     aString[4] = 0;
 251 }
 252
 253 // All destination string storage needs to have at least 5 bytes available.
 254 bool SplitDriverVersion(const char *aSource, char *aAStr, char *aBStr, char *aCStr, char *aDStr)
 255 {
 256     // sscanf doesn't do what we want here to we parse this manually.
 257     int len = strlen(aSource);
 258     char *dest[4] = { aAStr, aBStr, aCStr, aDStr };
 259     unsigned destIdx = 0;
 260     unsigned destPos = 0;
 261
 262     for (int i = 0; i < len; i++)
 263     {
 264         if (destIdx >= ArrayLength(dest))
 265         {
 266             // Invalid format found. Ensure we don't access dest beyond bounds.
 267             return false;
 268         }
 269
 270         if (aSource[i] == '.')
 271         {
 272             dest[destIdx++][destPos] = 0;
 273             destPos = 0;
 274             continue;
 275         }
 276
 277         if (destPos > 3)
 278         {
 279             // Ignore more than 4 chars. Ensure we never access dest[destIdx]
 280             // beyond its bounds.
 281             continue;
 282         }
 283
 284         dest[destIdx][destPos++] = aSource[i];
 285     }
 286
 287     // Add last terminator.
 288     dest[destIdx][destPos] = 0;
 289
 290     if (destIdx != ArrayLength(dest) - 1)
 291     {
 292         return false;
 293     }
 294     return true;
 295 }
 296
 297 /* Other interesting places for info:
 298  *   IDXGIAdapter::GetDesc()
 299  *   IDirectDraw7::GetAvailableVidMem()
 300  *   e->GetAvailableTextureMem()
 301  * */
 302
 303 template<typename T> void appendIntegerWithPadding(OUString& rString, T value, sal_uInt32 nChars)
 304 {
 305     rString += "0x";
 306     OUString aValue = OUString::number(value, 16);
 307     sal_Int32 nLength = aValue.getLength();
 308     sal_uInt32 nPadLength = nChars - nLength;
 309     assert(nPadLength >= 0);
 310     OUStringBuffer aBuffer;
 311     for (sal_uInt32 i = 0; i < nPadLength; ++i)
 312     {
 313         aBuffer.append("0");
 314     }
 315     rString += aBuffer.makeStringAndClear() + aValue;
 316 }
 317
 318 #define DEVICE_KEY_PREFIX L"\\Registry\\Machine\\"
 319 }
 320
 321 namespace wgl {
 322
 323 bool ParseDriverVersion(const OUString& aVersion, uint64_t& rNumericVersion)
 324 {
 325     rNumericVersion = 0;
 326
 327 #if defined(_WIN32)
 328     int a, b, c, d;
 329     char aStr[8], bStr[8], cStr[8], dStr[8];
 330     /* honestly, why do I even bother */
 331     OString aOVersion = OUStringToOString(aVersion, RTL_TEXTENCODING_UTF8);
 332     if (!SplitDriverVersion(aOVersion.getStr(), aStr, bStr, cStr, dStr))
 333         return false;
 334
 335     PadDriverDecimal(bStr);
 336     PadDriverDecimal(cStr);
 337     PadDriverDecimal(dStr);
 338
 339     a = atoi(aStr);
 340     b = atoi(bStr);
 341     c = atoi(cStr);
 342     d = atoi(dStr);
 343
 344     if (a < 0 || a > 0xffff) return false;
 345     if (b < 0 || b > 0xffff) return false;
 346     if (c < 0 || c > 0xffff) return false;
 347     if (d < 0 || d > 0xffff) return false;
 348
 349     rNumericVersion = GFX_DRIVER_VERSION(a, b, c, d);
 350     return true;
 351 #else
 352     return false;
 353 #endif
 354 }
 355
 356 uint64_t DriverInfo::allDriverVersions = ~(uint64_t(0));
 357
 358 DriverInfo::DriverInfo()
 359     : meOperatingSystem(wgl::DRIVER_OS_UNKNOWN),
 360     mnOperatingSystemVersion(0),
 361     maAdapterVendor(WinOpenGLDeviceInfo::GetDeviceVendor(VendorAll)),
 362     mbWhitelisted(false),
 363     meComparisonOp(DRIVER_COMPARISON_IGNORED),
 364     mnDriverVersion(0),
 365     mnDriverVersionMax(0)
 366 {}
 367
 368 DriverInfo::DriverInfo(OperatingSystem os, const OUString& vendor,
 369         VersionComparisonOp op,
 370         uint64_t driverVersion,
 371         bool bWhitelisted,
 372         const char *suggestedVersion /* = nullptr */)
 373     : meOperatingSystem(os),
 374     mnOperatingSystemVersion(0),
 375     maAdapterVendor(vendor),
 376     mbWhitelisted(bWhitelisted),
 377     meComparisonOp(op),
 378     mnDriverVersion(driverVersion),
 379     mnDriverVersionMax(0)
 380 {
 381     if (suggestedVersion)
 382         maSuggestedVersion = OStringToOUString(OString(suggestedVersion), RTL_TEXTENCODING_UTF8);
 383 }
 384
 385 DriverInfo::~DriverInfo()
 386 {
 387 }
 388
 389 }
 390
 391 WinOpenGLDeviceInfo::WinOpenGLDeviceInfo():
 392     mbHasDualGPU(false),
 393     mbRDP(false)
 394 {
 395     GetData();
 396     FillBlacklist();
 397 }
 398
 399 WinOpenGLDeviceInfo::~WinOpenGLDeviceInfo()
 400 {
 401 }
 402
 403 namespace {
 404
 405 struct compareIgnoreAsciiCase
 406 {
 407     explicit compareIgnoreAsciiCase(const OUString& rString)
 408         : maString(rString)
 409     {
 410     }
 411
 412     bool operator()(const OUString& rCompare)
 413     {
 414         return maString.equalsIgnoreAsciiCase(rCompare);
 415     }
 416
 417 private:
 418     OUString maString;
 419 };
 420
 421 }
 422
 423 bool WinOpenGLDeviceInfo::FindBlocklistedDeviceInList(std::vector<wgl::DriverInfo>& aDeviceInfos,
 424                                                       OUString const & sDriverVersion, OUString const & sAdapterVendorID,
 425                                                       OUString const & sAdapterDeviceID, uint32_t nWindowsVersion)
 426 {
 427     uint64_t driverVersion;
 428     wgl::ParseDriverVersion(sDriverVersion, driverVersion);
 429
 430     wgl::OperatingSystem eOS = WindowsVersionToOperatingSystem(nWindowsVersion);
 431     bool match = false;
 432     for (std::vector<wgl::DriverInfo>::size_type i = 0; i < aDeviceInfos.size(); i++)
 433     {
 434         if (aDeviceInfos[i].meOperatingSystem != wgl::DRIVER_OS_ALL &&
 435                 aDeviceInfos[i].meOperatingSystem != eOS)
 436         {
 437             continue;
 438         }
 439
 440         if (aDeviceInfos[i].mnOperatingSystemVersion && aDeviceInfos[i].mnOperatingSystemVersion != nWindowsVersion)
 441         {
 442             continue;
 443         }
 444
 445         if (!aDeviceInfos[i].maAdapterVendor.equalsIgnoreAsciiCase(GetDeviceVendor(wgl::VendorAll)) &&
 446                 !aDeviceInfos[i].maAdapterVendor.equalsIgnoreAsciiCase(sAdapterVendorID))
 447         {
 448             continue;
 449         }
 450
 451         if (std::none_of(aDeviceInfos[i].maDevices.begin(), aDeviceInfos[i].maDevices.end(), compareIgnoreAsciiCase("all")) &&
 452             std::none_of(aDeviceInfos[i].maDevices.begin(), aDeviceInfos[i].maDevices.end(), compareIgnoreAsciiCase(sAdapterDeviceID)))
 453         {
 454             continue;
 455         }
 456
 457         switch (aDeviceInfos[i].meComparisonOp)
 458         {
 459             case wgl::DRIVER_LESS_THAN:
 460                 match = driverVersion < aDeviceInfos[i].mnDriverVersion;
 461                 break;
 462             case wgl::DRIVER_LESS_THAN_OR_EQUAL:
 463                 match = driverVersion <= aDeviceInfos[i].mnDriverVersion;
 464                 break;
 465             case wgl::DRIVER_GREATER_THAN:
 466                 match = driverVersion > aDeviceInfos[i].mnDriverVersion;
 467                 break;
 468             case wgl::DRIVER_GREATER_THAN_OR_EQUAL:
 469                 match = driverVersion >= aDeviceInfos[i].mnDriverVersion;
 470                 break;
 471             case wgl::DRIVER_EQUAL:
 472                 match = driverVersion == aDeviceInfos[i].mnDriverVersion;
 473                 break;
 474             case wgl::DRIVER_NOT_EQUAL:
 475                 match = driverVersion != aDeviceInfos[i].mnDriverVersion;
 476                 break;
 477             case wgl::DRIVER_BETWEEN_EXCLUSIVE:
 478                 match = driverVersion > aDeviceInfos[i].mnDriverVersion && driverVersion < aDeviceInfos[i].mnDriverVersionMax;
 479                 break;
 480             case wgl::DRIVER_BETWEEN_INCLUSIVE:
 481                 match = driverVersion >= aDeviceInfos[i].mnDriverVersion && driverVersion <= aDeviceInfos[i].mnDriverVersionMax;
 482                 break;
 483             case wgl::DRIVER_BETWEEN_INCLUSIVE_START:
 484                 match = driverVersion >= aDeviceInfos[i].mnDriverVersion && driverVersion < aDeviceInfos[i].mnDriverVersionMax;
 485                 break;
 486             case wgl::DRIVER_COMPARISON_IGNORED:
 487                 // We don't have a comparison op, so we match everything.
 488                 match = true;
 489                 break;
 490             default:
 491                 SAL_WARN("vcl.opengl", "Bogus op in GfxDriverInfo");
 492                 break;
 493         }
 494
 495         if (match || aDeviceInfos[i].mnDriverVersion == wgl::DriverInfo::allDriverVersions)
 496         {
 497             // white listed drivers
 498             if (aDeviceInfos[i].mbWhitelisted)
 499             {
 500                 SAL_WARN("vcl.opengl", "whitelisted driver");
 501                 return false;
 502             }
 503
 504             match = true;
 505             SAL_WARN("vcl.opengl", "use : " << aDeviceInfos[i].maSuggestedVersion);
 506             break;
 507         }
 508     }
 509
 510     SAL_INFO("vcl.opengl", (match ? "BLACKLISTED" : "not blacklisted"));
 511     return match;
 512 }
 513
 514 bool WinOpenGLDeviceInfo::FindBlocklistedDeviceInList()
 515 {
 516     return FindBlocklistedDeviceInList(maDriverInfo, maDriverVersion, maAdapterVendorID, maAdapterDeviceID, mnWindowsVersion);
 517 }
 518
 519 namespace {
 520
 521 OUString getCacheFolder()
 522 {
 523     OUString url("${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap") ":UserInstallation}/cache/");
 524     rtl::Bootstrap::expandMacros(url);
 525
 526     osl::Directory::create(url);
 527
 528     return url;
 529 }
 530
 531 void writeToLog(SvStream& rStrm, const char* pKey, const OUString & rVal)
 532 {
 533     rStrm.WriteCharPtr(pKey);
 534     rStrm.WriteCharPtr(": ");
 535     rStrm.WriteOString(OUStringToOString(rVal, RTL_TEXTENCODING_UTF8));
 536     rStrm.WriteChar('\n');
 537 }
 538
 539 }
 540
 541 bool WinOpenGLDeviceInfo::isDeviceBlocked()
 542 {
 543     CrashReporter::AddKeyValue("OpenGLVendor", maAdapterVendorID);
 544     CrashReporter::AddKeyValue("OpenGLDevice", maAdapterDeviceID);
 545     CrashReporter::AddKeyValue("OpenGLDriver", maDriverVersion);
 546
 547     SAL_INFO("vcl.opengl", maDriverVersion);
 548     SAL_INFO("vcl.opengl", maDriverDate);
 549     SAL_INFO("vcl.opengl", maDeviceID);
 550     SAL_INFO("vcl.opengl", maAdapterVendorID);
 551     SAL_INFO("vcl.opengl", maAdapterDeviceID);
 552     SAL_INFO("vcl.opengl", maAdapterSubsysID);
 553     SAL_INFO("vcl.opengl", maDeviceKey);
 554     SAL_INFO("vcl.opengl", maDeviceString);
 555
 556     OUString aCacheFolder = getCacheFolder();
 557
 558     OUString aCacheFile(aCacheFolder + "/opengl_device.log");
 559     SvFileStream aOpenGLLogFile(aCacheFile, StreamMode::WRITE);
 560
 561     writeToLog(aOpenGLLogFile, "DriverVersion", maDriverVersion);
 562     writeToLog(aOpenGLLogFile, "DriverDate", maDriverDate);
 563     writeToLog(aOpenGLLogFile, "DeviceID", maDeviceID);
 564     writeToLog(aOpenGLLogFile, "AdapterVendorID", maAdapterVendorID);
 565     writeToLog(aOpenGLLogFile, "AdapterDeviceID", maAdapterDeviceID);
 566     writeToLog(aOpenGLLogFile, "AdapterSubsysID", maAdapterSubsysID);
 567     writeToLog(aOpenGLLogFile, "DeviceKey", maDeviceKey);
 568     writeToLog(aOpenGLLogFile, "DeviceString", maDeviceString);
 569
 570     // Check if the device is blocked from the downloaded blocklist. If not, check
 571     // the static list after that. This order is used so that we can later escape
 572     // out of static blocks (i.e. if we were wrong or something was patched, we
 573     // can back out our static block without doing a release).
 574     if (mbRDP)
 575     {
 576         SAL_WARN("vcl.opengl", "all OpenGL blocked for RDP sessions");
 577         return true;
 578     }
 579
 580     return FindBlocklistedDeviceInList();
 581 }
 582
 583 void WinOpenGLDeviceInfo::GetData()
 584 {
 585     DISPLAY_DEVICEW displayDevice;
 586     displayDevice.cb = sizeof(displayDevice);
 587
 588     mnWindowsVersion = WindowsOSVersion();
 589     int deviceIndex = 0;
 590
 591     while (EnumDisplayDevicesW(nullptr, deviceIndex, &displayDevice, 0))
 592     {
 593         if (displayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
 594         {
 595             break;
 596         }
 597         deviceIndex++;
 598     }
 599
 600     // make sure the string is null terminated
 601     // (using the term "null" here to mean a zero UTF-16 unit)
 602     if (wcsnlen(displayDevice.DeviceKey, ArrayLength(displayDevice.DeviceKey))
 603             == ArrayLength(displayDevice.DeviceKey))
 604     {
 605         // we did not find a null
 606         SAL_WARN("vcl.opengl", "string not null terminated");
 607         return;
 608     }
 609
 610     /* DeviceKey is "reserved" according to MSDN so we'll be careful with it */
 611     /* check that DeviceKey begins with DEVICE_KEY_PREFIX */
 612     /* some systems have a DeviceKey starting with \REGISTRY\Machine\ so we need to compare case insensitively */
 613     if (_wcsnicmp(displayDevice.DeviceKey, DEVICE_KEY_PREFIX, ArrayLength(DEVICE_KEY_PREFIX)-1) != 0)
 614     {
 615         SAL_WARN("vcl.opengl", "incorrect DeviceKey");
 616         return;
 617     }
 618
 619     // chop off DEVICE_KEY_PREFIX
 620     maDeviceKey = o3tl::toU(displayDevice.DeviceKey) + ArrayLength(DEVICE_KEY_PREFIX)-1;
 621
 622     maDeviceID = o3tl::toU(displayDevice.DeviceID);
 623     maDeviceString = o3tl::toU(displayDevice.DeviceString);
 624
 625     if (maDeviceID.isEmpty() &&
 626         (maDeviceString == "RDPDD Chained DD" ||
 627          (maDeviceString == "RDPUDD Chained DD")))
 628     {
 629         // we need to block RDP as it does not provide OpenGL 2.1+
 630         mbRDP = true;
 631         SAL_WARN("vcl.opengl", "RDP => blocked");
 632         return;
 633     }
 634
 635     /* create a device information set composed of the current display device */
 636     HDEVINFO devinfo = SetupDiGetClassDevsW(nullptr, o3tl::toW(maDeviceID.getStr()), nullptr,
 637             DIGCF_PRESENT | DIGCF_PROFILE | DIGCF_ALLCLASSES);
 638
 639     if (devinfo != INVALID_HANDLE_VALUE)
 640     {
 641         HKEY key;
 642         LONG result;
 643         WCHAR value[255];
 644         DWORD dwcbData;
 645         SP_DEVINFO_DATA devinfoData;
 646         DWORD memberIndex = 0;
 647
 648         devinfoData.cbSize = sizeof(devinfoData);
 649         /* enumerate device information elements in the device information set */
 650         while (SetupDiEnumDeviceInfo(devinfo, memberIndex++, &devinfoData))
 651         {
 652             /* get a string that identifies the device's driver key */
 653             if (SetupDiGetDeviceRegistryPropertyW(devinfo,
 654                         &devinfoData,
 655                         SPDRP_DRIVER,
 656                         nullptr,
 657                         reinterpret_cast<PBYTE>(value),
 658                         sizeof(value),
 659                         nullptr))
 660             {
 661                 OUString  driverKey("System\\CurrentControlSet\\Control\\Class\\");
 662                 driverKey += o3tl::toU(value);
 663                 result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, o3tl::toW(driverKey.getStr()), 0, KEY_QUERY_VALUE, &key);
 664                 if (result == ERROR_SUCCESS)
 665                 {
 666                     /* we've found the driver we're looking for */
 667                     dwcbData = sizeof(value);
 668                     result = RegQueryValueExW(key, L"DriverVersion", nullptr, nullptr,
 669                             reinterpret_cast<LPBYTE>(value), &dwcbData);
 670                     if (result == ERROR_SUCCESS)
 671                     {
 672                         maDriverVersion = OUString(o3tl::toU(value));
 673                     }
 674                     else
 675                     {
 676                         // If the entry wasn't found, assume the worst (0.0.0.0).
 677                         maDriverVersion = OUString("0.0.0.0");
 678                     }
 679                     dwcbData = sizeof(value);
 680                     result = RegQueryValueExW(key, L"DriverDate", nullptr, nullptr,
 681                             reinterpret_cast<LPBYTE>(value), &dwcbData);
 682                     if (result == ERROR_SUCCESS)
 683                     {
 684                         maDriverDate = o3tl::toU(value);
 685                     }
 686                     else
 687                     {
 688                         // Again, assume the worst
 689                         maDriverDate = OUString("01-01-1970");
 690                     }
 691                     RegCloseKey(key);
 692                     break;
 693                 }
 694             }
 695         }
 696
 697         SetupDiDestroyDeviceInfoList(devinfo);
 698     }
 699     else
 700     {
 701         SAL_WARN("vcl.opengl", "invalid handle value");
 702     }
 703
 704     appendIntegerWithPadding(maAdapterVendorID, ParseIDFromDeviceID(maDeviceID, "VEN_", 4), 4);
 705     appendIntegerWithPadding(maAdapterDeviceID, ParseIDFromDeviceID(maDeviceID, "&DEV_", 4), 4);
 706     appendIntegerWithPadding(maAdapterSubsysID, ParseIDFromDeviceID(maDeviceID, "&SUBSYS_", 8), 8);
 707
 708     // We now check for second display adapter.
 709
 710     // Device interface class for display adapters.
 711     CLSID GUID_DISPLAY_DEVICE_ARRIVAL;
 712     HRESULT hresult = CLSIDFromString(L"{1CA05180-A699-450A-9A0C-DE4FBE3DDD89}",
 713             &GUID_DISPLAY_DEVICE_ARRIVAL);
 714     if (hresult == NOERROR)
 715     {
 716         devinfo = SetupDiGetClassDevsW(&GUID_DISPLAY_DEVICE_ARRIVAL,
 717                 nullptr, nullptr,
 718                 DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);
 719
 720         if (devinfo != INVALID_HANDLE_VALUE)
 721         {
 722             HKEY key;
 723             LONG result;
 724             WCHAR value[255];
 725             DWORD dwcbData;
 726             SP_DEVINFO_DATA devinfoData;
 727             DWORD memberIndex = 0;
 728             devinfoData.cbSize = sizeof(devinfoData);
 729
 730             OUString aAdapterDriver2;
 731             OUString aDeviceID2;
 732             OUString aDriverVersion2;
 733             OUString aDriverDate2;
 734             uint32_t adapterVendorID2;
 735             uint32_t adapterDeviceID2;
 736
 737             /* enumerate device information elements in the device information set */
 738             while (SetupDiEnumDeviceInfo(devinfo, memberIndex++, &devinfoData))
 739             {
 740                 /* get a string that identifies the device's driver key */
 741                 if (SetupDiGetDeviceRegistryPropertyW(devinfo,
 742                             &devinfoData,
 743                             SPDRP_DRIVER,
 744                             nullptr,
 745                             reinterpret_cast<PBYTE>(value),
 746                             sizeof(value),
 747                             nullptr))
 748                 {
 749                     OUString driverKey2("System\\CurrentControlSet\\Control\\Class\\");
 750                     driverKey2 += o3tl::toU(value);
 751                     result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, o3tl::toW(driverKey2.getStr()), 0, KEY_QUERY_VALUE, &key);
 752                     if (result == ERROR_SUCCESS)
 753                     {
 754                         dwcbData = sizeof(value);
 755                         result = RegQueryValueExW(key, L"MatchingDeviceId", nullptr,
 756                                 nullptr, reinterpret_cast<LPBYTE>(value), &dwcbData);
 757                         if (result != ERROR_SUCCESS)
 758                         {
 759                             continue;
 760                         }
 761                         aDeviceID2 = o3tl::toU(value);
 762                         OUString aAdapterVendorID2String;
 763                         OUString aAdapterDeviceID2String;
 764                         adapterVendorID2 = ParseIDFromDeviceID(aDeviceID2, "VEN_", 4);
 765                         appendIntegerWithPadding(aAdapterVendorID2String, adapterVendorID2, 4);
 766                         adapterDeviceID2 = ParseIDFromDeviceID(aDeviceID2, "&DEV_", 4);
 767                         appendIntegerWithPadding(aAdapterDeviceID2String, adapterDeviceID2, 4);
 768                         if (maAdapterVendorID == aAdapterVendorID2String &&
 769                                 maAdapterDeviceID == aAdapterDeviceID2String)
 770                         {
 771                             RegCloseKey(key);
 772                             continue;
 773                         }
 774
 775                         // If this device is missing driver information, it is unlikely to
 776                         // be a real display adapter.
 777                         if (!GetKeyValue(o3tl::toW(driverKey2.getStr()), L"InstalledDisplayDrivers",
 778                                         aAdapterDriver2, REG_MULTI_SZ))
 779                         {
 780                             RegCloseKey(key);
 781                             continue;
 782                         }
 783                         dwcbData = sizeof(value);
 784                         result = RegQueryValueExW(key, L"DriverVersion", nullptr, nullptr,
 785                                 reinterpret_cast<LPBYTE>(value), &dwcbData);
 786                         if (result != ERROR_SUCCESS)
 787                         {
 788                             RegCloseKey(key);
 789                             continue;
 790                         }
 791                         aDriverVersion2 = o3tl::toU(value);
 792                         dwcbData = sizeof(value);
 793                         result = RegQueryValueExW(key, L"DriverDate", nullptr, nullptr,
 794                                 reinterpret_cast<LPBYTE>(value), &dwcbData);
 795                         if (result != ERROR_SUCCESS)
 796                         {
 797                             RegCloseKey(key);
 798                             continue;
 799                         }
 800                         aDriverDate2 = o3tl::toU(value);
 801                         dwcbData = sizeof(value);
 802                         result = RegQueryValueExW(key, L"Device Description", nullptr,
 803                                 nullptr, reinterpret_cast<LPBYTE>(value), &dwcbData);
 804                         if (result != ERROR_SUCCESS)
 805                         {
 806                             dwcbData = sizeof(value);
 807                             result = RegQueryValueExW(key, L"DriverDesc", nullptr, nullptr,
 808                                     reinterpret_cast<LPBYTE>(value), &dwcbData);
 809                         }
 810                         RegCloseKey(key);
 811                         if (result == ERROR_SUCCESS)
 812                         {
 813                             mbHasDualGPU = true;
 814                             maDeviceString2 = o3tl::toU(value);
 815                             maDeviceID2 = aDeviceID2;
 816                             maDeviceKey2 = driverKey2;
 817                             maDriverVersion2 = aDriverVersion2;
 818                             maDriverDate2 = aDriverDate2;
 819                             appendIntegerWithPadding(maAdapterVendorID2, adapterVendorID2, 4);
 820                             appendIntegerWithPadding(maAdapterDeviceID2, adapterDeviceID2, 4);
 821                             appendIntegerWithPadding(maAdapterSubsysID2, ParseIDFromDeviceID(maDeviceID2, "&SUBSYS_", 8), 8);
 822                             break;
 823                         }
 824                     }
 825                 }
 826             }
 827
 828             SetupDiDestroyDeviceInfoList(devinfo);
 829         }
 830     }
 831 }
 832
 833 // Macro for assigning a device vendor id to a string.
 834 #define DECLARE_VENDOR_ID(name, deviceId) \
 835     case name: \
 836         *mpDeviceVendors[id] = deviceId; \
 837 break;
 838
 839 OUString WinOpenGLDeviceInfo::GetDeviceVendor(wgl::DeviceVendor id)
 840 {
 841     assert(id >= 0 && id < wgl::DeviceVendorMax);
 842
 843     if (mpDeviceVendors[id])
 844         return *mpDeviceVendors[id];
 845
 846     mpDeviceVendors[id] = new OUString();
 847
 848     switch (id)
 849     {
 850         DECLARE_VENDOR_ID(wgl::VendorAll, "");
 851         DECLARE_VENDOR_ID(wgl::VendorIntel, "0x8086");
 852         DECLARE_VENDOR_ID(wgl::VendorNVIDIA, "0x10de");
 853         DECLARE_VENDOR_ID(wgl::VendorAMD, "0x1022");
 854         DECLARE_VENDOR_ID(wgl::VendorATI, "0x1002");
 855         DECLARE_VENDOR_ID(wgl::VendorMicrosoft, "0x1414");
 856         // Suppress a warning.
 857         DECLARE_VENDOR_ID(wgl::DeviceVendorMax, "");
 858     }
 859
 860     return *mpDeviceVendors[id];
 861 }
 862
 863 namespace {
 864
 865
 866 OUString getBlacklistFile()
 867 {
 868     OUString url("$BRAND_BASE_DIR/" LIBO_SHARE_FOLDER);
 869     rtl::Bootstrap::expandMacros(url);
 870
 871     return url + "/opengl/opengl_blacklist_windows.xml";
 872 }
 873
 874
 875 }
 876
 877 void WinOpenGLDeviceInfo::FillBlacklist()
 878 {
 879     OUString aURL = getBlacklistFile();
 880     WinBlocklistParser aParser(aURL, maDriverInfo);
 881     try {
 882         aParser.parse();
 883     }
 884     catch (...)
 885     {
 886         SAL_WARN("vcl.opengl", "error parsing blacklist");
 887         maDriverInfo.clear();
 888     }
 889 }
 890
 891
 892 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */