vcl/opengl/win/blocklist_parser.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/blocklist_parser.hxx>
  11
  12 WinBlocklistParser::WinBlocklistParser(const OUString& rURL,
  13         std::vector<wgl::DriverInfo>& rDriverList)
  14     : meBlockType(BlockType::UNKNOWN)
  15     , mrDriverList(rDriverList)
  16     , maURL(rURL)
  17 {
  18 }
  19
  20 void WinBlocklistParser::parse()
  21 {
  22     xmlreader::XmlReader aReader(maURL);
  23     handleContent(aReader);
  24 }
  25
  26 namespace {
  27
  28 wgl::OperatingSystem getOperatingSystem(const OString& rString)
  29 {
  30     if (rString == "all")
  31     {
  32         return wgl::DRIVER_OS_ALL;
  33     }
  34     else if (rString == "xp")
  35     {
  36         return wgl::DRIVER_OS_WINDOWS_XP;
  37     }
  38     else if (rString == "server2003")
  39     {
  40         return wgl::DRIVER_OS_WINDOWS_SERVER_2003;
  41     }
  42     else if (rString == "vista")
  43     {
  44         return wgl::DRIVER_OS_WINDOWS_VISTA;
  45     }
  46     else if (rString == "7")
  47     {
  48         return wgl::DRIVER_OS_WINDOWS_7;
  49     }
  50     else if (rString == "8")
  51     {
  52         return wgl::DRIVER_OS_WINDOWS_8;
  53     }
  54     else if (rString == "8_1")
  55     {
  56         return wgl::DRIVER_OS_WINDOWS_8_1;
  57     }
  58     else if (rString == "10")
  59     {
  60         return wgl::DRIVER_OS_WINDOWS_10;
  61     }
  62
  63     return wgl::DRIVER_OS_UNKNOWN;
  64 }
  65
  66 wgl::VersionComparisonOp getComparison(const OString& rString)
  67 {
  68     if (rString == "less")
  69     {
  70         return wgl::DRIVER_LESS_THAN;
  71     }
  72     else if (rString == "less_equal")
  73     {
  74         return wgl::DRIVER_LESS_THAN_OR_EQUAL;
  75     }
  76     else if (rString == "greater")
  77     {
  78         return wgl::DRIVER_GREATER_THAN;
  79     }
  80     else if (rString == "greater_equal")
  81     {
  82         return wgl::DRIVER_GREATER_THAN_OR_EQUAL;
  83     }
  84     else if (rString == "equal")
  85     {
  86         return wgl::DRIVER_EQUAL;
  87     }
  88     else if (rString == "not_equal")
  89     {
  90         return wgl::DRIVER_NOT_EQUAL;
  91     }
  92     else if (rString == "between_exclusive")
  93     {
  94         return wgl::DRIVER_BETWEEN_EXCLUSIVE;
  95     }
  96     else if (rString == "between_inclusive")
  97     {
  98         return wgl::DRIVER_BETWEEN_INCLUSIVE;
  99     }
 100     else if (rString == "between_inclusive_start")
 101     {
 102         return wgl::DRIVER_BETWEEN_INCLUSIVE_START;
 103     }
 104
 105     throw InvalidFileException();
 106 }
 107
 108 OUString getVendor(const OString& rString)
 109 {
 110     if (rString == "all")
 111     {
 112         return "";
 113     }
 114     else if (rString == "intel")
 115     {
 116         return "0x8086";
 117     }
 118     else if (rString == "nvidia")
 119     {
 120         return "0x10de";
 121     }
 122     else if (rString == "amd")
 123     {
 124         return "0x1022";
 125     }
 126     else if (rString == "ati")
 127     {
 128         return "0x1002";
 129     }
 130     else if (rString == "microsoft")
 131     {
 132         return "0x1414";
 133     }
 134     else
 135     {
 136         // Allow having simply the hex number as such there, too. After all, it's hex numbers that
 137         // are output to opengl_device.log.
 138         return OStringToOUString(rString, RTL_TEXTENCODING_UTF8);
 139     }
 140 }
 141
 142 uint64_t getVersion(const OString& rString)
 143 {
 144     OUString aString = OStringToOUString(rString, RTL_TEXTENCODING_UTF8);
 145     uint64_t nVersion;
 146     bool bResult = wgl::ParseDriverVersion(aString, nVersion);
 147
 148     if (!bResult)
 149     {
 150         throw InvalidFileException();
 151     }
 152
 153     return nVersion;
 154 }
 155
 156 void handleDevices(wgl::DriverInfo& rDriver, xmlreader::XmlReader& rReader)
 157 {
 158     int nLevel = 1;
 159     bool bInMsg = false;
 160
 161     while(true)
 162     {
 163         xmlreader::Span name;
 164         int nsId;
 165
 166         xmlreader::XmlReader::Result res = rReader.nextItem(
 167                 xmlreader::XmlReader::Text::Normalized, &name, &nsId);
 168
 169         if (res == xmlreader::XmlReader::Result::Begin)
 170         {
 171             ++nLevel;
 172             if (nLevel > 2)
 173                 throw InvalidFileException();
 174
 175             if (name.equals("msg"))
 176             {
 177                 bInMsg = true;
 178             }
 179             else if (name.equals("device"))
 180             {
 181                 int nsIdDeveice;
 182                 while (rReader.nextAttribute(&nsIdDeveice, &name))
 183                 {
 184                     if (name.equals("id"))
 185                     {
 186                         name = rReader.getAttributeValue(false);
 187                         OString aDeviceId(name.begin, name.length);
 188                         rDriver.maDevices.push_back(OStringToOUString(aDeviceId, RTL_TEXTENCODING_UTF8));
 189                     }
 190                 }
 191             }
 192             else
 193                 throw InvalidFileException();
 194         }
 195         else if (res == xmlreader::XmlReader::Result::End)
 196         {
 197             --nLevel;
 198             bInMsg = false;
 199             if (!nLevel)
 200                 break;
 201         }
 202         else if (res == xmlreader::XmlReader::Result::Text)
 203         {
 204             if (bInMsg)
 205             {
 206                 OString sMsg(name.begin, name.length);
 207                 rDriver.maMsg = OStringToOUString(sMsg, RTL_TEXTENCODING_UTF8);
 208             }
 209         }
 210     }
 211 }
 212
 213 }
 214
 215 void WinBlocklistParser::handleEntry(wgl::DriverInfo& rDriver, xmlreader::XmlReader& rReader)
 216 {
 217     if (meBlockType == BlockType::WHITELIST)
 218     {
 219         rDriver.mbWhitelisted = true;
 220     }
 221     else if (meBlockType == BlockType::BLACKLIST)
 222     {
 223         rDriver.mbWhitelisted = false;
 224     }
 225     else if (meBlockType == BlockType::UNKNOWN)
 226     {
 227         throw InvalidFileException();
 228     }
 229
 230     xmlreader::Span name;
 231     int nsId;
 232
 233     while (rReader.nextAttribute(&nsId, &name))
 234     {
 235         if (name.equals("os"))
 236         {
 237             name = rReader.getAttributeValue(false);
 238             OString sOS(name.begin, name.length);
 239             rDriver.meOperatingSystem = getOperatingSystem(sOS);
 240         }
 241         else if (name.equals("vendor"))
 242         {
 243             name = rReader.getAttributeValue(false);
 244             OString sVendor(name.begin, name.length);
 245             rDriver.maAdapterVendor = getVendor(sVendor);
 246         }
 247         else if (name.equals("compare"))
 248         {
 249             name = rReader.getAttributeValue(false);
 250             OString sCompare(name.begin, name.length);
 251             rDriver.meComparisonOp = getComparison(sCompare);
 252         }
 253         else if (name.equals("version"))
 254         {
 255             name = rReader.getAttributeValue(false);
 256             OString sVersion(name.begin, name.length);
 257             rDriver.mnDriverVersion = getVersion(sVersion);
 258         }
 259         else if (name.equals("minVersion"))
 260         {
 261             name = rReader.getAttributeValue(false);
 262             OString sMinVersion(name.begin, name.length);
 263             rDriver.mnDriverVersion = getVersion(sMinVersion);
 264         }
 265         else if (name.equals("maxVersion"))
 266         {
 267             name = rReader.getAttributeValue(false);
 268             OString sMaxVersion(name.begin, name.length);
 269             rDriver.mnDriverVersionMax = getVersion(sMaxVersion);
 270         }
 271         else
 272         {
 273             OString aAttrName(name.begin, name.length);
 274             SAL_WARN("vcl.opengl", "unsupported attribute: " << aAttrName);
 275         }
 276     }
 277
 278     handleDevices(rDriver, rReader);
 279 }
 280
 281 void WinBlocklistParser::handleList(xmlreader::XmlReader& rReader)
 282 {
 283     xmlreader::Span name;
 284     int nsId;
 285
 286     while (true)
 287     {
 288         xmlreader::XmlReader::Result res = rReader.nextItem(
 289                 xmlreader::XmlReader::Text::NONE, &name, &nsId);
 290
 291         if (res == xmlreader::XmlReader::Result::Begin)
 292         {
 293             if (name.equals("entry"))
 294             {
 295                 wgl::DriverInfo aDriver;
 296                 handleEntry(aDriver, rReader);
 297                 mrDriverList.push_back(aDriver);
 298             }
 299             else if (name.equals("entryRange"))
 300             {
 301                 wgl::DriverInfo aDriver;
 302                 handleEntry(aDriver, rReader);
 303                 mrDriverList.push_back(aDriver);
 304             }
 305             else
 306             {
 307                 throw InvalidFileException();
 308             }
 309         }
 310         else if (res == xmlreader::XmlReader::Result::End)
 311         {
 312             break;
 313         }
 314     }
 315 }
 316
 317 void WinBlocklistParser::handleContent(xmlreader::XmlReader& rReader)
 318 {
 319     while (true)
 320     {
 321         xmlreader::Span name;
 322         int nsId;
 323
 324         xmlreader::XmlReader::Result res = rReader.nextItem(
 325                 xmlreader::XmlReader::Text::NONE, &name, &nsId);
 326
 327         if (res == xmlreader::XmlReader::Result::Begin)
 328         {
 329             if (name.equals("whitelist"))
 330             {
 331                 meBlockType = BlockType::WHITELIST;
 332                 handleList(rReader);
 333             }
 334             else if (name.equals("blacklist"))
 335             {
 336                 meBlockType = BlockType::BLACKLIST;
 337                 handleList(rReader);
 338             }
 339             else if (name.equals("root"))
 340             {
 341             }
 342             else
 343             {
 344                 throw InvalidFileException();
 345             }
 346         }
 347         else if (res == xmlreader::XmlReader::Result::End)
 348         {
 349             if (name.equals("whitelist")
 350                     ||
 351                     name.equals("blacklist"))
 352             {
 353                 meBlockType = BlockType::UNKNOWN;
 354             }
 355         }
 356         else if (res == xmlreader::XmlReader::Result::Done)
 357         {
 358             break;
 359         }
 360     }
 361 }
 362
 363 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */