qserialportinfo_win.cpp

++ // Copyright (C) 2011-2012 Denis Shienkov <denis.shienkov@gmail.com>

++ // Copyright (C) 2011 Sergey Belyashov <Sergey.Belyashov@gmail.com>

++ // Copyright (C) 2012 Laszlo Papp <lpapp@kde.org>

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:critical reason:data-parser

++

++ #include "qserialportinfo.h"

++ #include "qserialportinfo_p.h"

++ #include "qserialport_p.h"

++

++ #include <QtCore/quuid.h>

++ #include <QtCore/qpair.h>

++ #include <QtCore/qstringlist.h>

++ #include <QtCore/private/qwinregistry_p.h>

++ #include <QtCore/private/quniquehandle_types_p.h>

++

++ #include <vector>

++

++ #include <initguid.h>

++ #include <devguid.h> // for GUID_DEVCLASS_PORTS and GUID_DEVCLASS_MODEM

++ #include <winioctl.h> // for GUID_DEVINTERFACE_COMPORT

++ #include <setupapi.h>

++ #include <cfgmgr32.h>

++ #include <usbioctl.h>

++ #include <usbiodef.h>

++ #include <ioapiset.h>

++

++ #ifdef QT_NO_REDEFINE_GUID_DEVINTERFACE_MODEM

++ #  include <ntddmodm.h> // for GUID_DEVINTERFACE_MODEM

++ #else

++   DEFINE_GUID(GUID_DEVINTERFACE_MODEM, 0x2c7089aa, 0x2e0e, 0x11d1, 0xb1, 0x14, 0x00, 0xc0, 0x4f, 0xc2, 0xaa, 0xe4);

++ #endif

++

++ QT_BEGIN_NAMESPACE

++

++ namespace {

++

++ struct DevInfoHandleTraits

++ {

++     using Type = HDEVINFO;

++     static Type invalidValue() noexcept

++     {

++         return INVALID_HANDLE_VALUE;

++     }

++     static bool close(Type handle) noexcept

++     {

++         return SetupDiDestroyDeviceInfoList(handle) == TRUE;

++     }

++ };

++

++ using DevInfoHandle = QUniqueHandle<DevInfoHandleTraits>;

++

++ } // namespace

++

++ static QStringList portNamesFromHardwareDeviceMap()

++ {

++     const QWinRegistryKey key{ HKEY_LOCAL_MACHINE, L"HARDWARE\\DEVICEMAP\\SERIALCOMM", 0,

++                                KEY_QUERY_VALUE };

++

++     if (!key.isValid())

++         return { };

++

++     QStringList result;

++     DWORD index = 0;

++

++     // This is a maximum length of value name, see:

++     // https://msdn.microsoft.com/en-us/library/windows/desktop/ms724872%28v=vs.85%29.aspx

++     enum { MaximumValueNameInChars = 16383 };

++

++     std::vector<wchar_t> outputValueName(MaximumValueNameInChars, 0);

++     std::vector<wchar_t> outputBuffer(MAX_PATH + 1, 0);

++     DWORD bytesRequired = MAX_PATH;

++     for (;;) {

++         DWORD requiredValueNameChars = MaximumValueNameInChars;

++         const LONG ret = ::RegEnumValue(key, index, &outputValueName[0], &requiredValueNameChars,

++                                         nullptr, nullptr, reinterpret_cast<PBYTE>(&outputBuffer[0]), &bytesRequired);

++         if (ret == ERROR_MORE_DATA) {

++             outputBuffer.resize(bytesRequired / sizeof(wchar_t) + 2, 0);

++         } else if (ret == ERROR_SUCCESS) {

++             result.append(QString::fromWCharArray(&outputBuffer[0]));

++             ++index;

++         } else {

++             break;

++         }

++     }

++     return result;

++ }

++

++ static QString deviceRegistryProperty(HDEVINFO deviceInfoSet,

++                                       PSP_DEVINFO_DATA deviceInfoData,

++                                       DWORD property)

++ {

++     DWORD dataType = 0;

++     std::vector<wchar_t> outputBuffer(MAX_PATH + 1, 0);

++     DWORD bytesRequired = MAX_PATH;

++     for (;;) {

++         if (::SetupDiGetDeviceRegistryProperty(deviceInfoSet, deviceInfoData, property, &dataType,

++                                                reinterpret_cast<PBYTE>(&outputBuffer[0]),

++                                                bytesRequired, &bytesRequired)) {

++             break;

++         }

++

++         if (::GetLastError() != ERROR_INSUFFICIENT_BUFFER

++                 || (dataType != REG_SZ && dataType != REG_EXPAND_SZ)) {

++             return QString();

++         }

++         outputBuffer.resize(bytesRequired / sizeof(wchar_t) + 2, 0);

++     }

++     return QString::fromWCharArray(&outputBuffer[0]);

++ }

++

++ static QString getStringDescriptor(HANDLE hHubDevice, ULONG connectionIndex,

++                                    UCHAR descriptorIndex, USHORT languageID)

++ {

++

++     constexpr DWORD bufferSize = sizeof(USB_DESCRIPTOR_REQUEST) + MAXIMUM_USB_STRING_LENGTH;

++     std::array<UCHAR, bufferSize> buffer{};

++     auto request = reinterpret_cast<PUSB_DESCRIPTOR_REQUEST>(buffer.data());

++

++     request->ConnectionIndex = connectionIndex;

++     request->SetupPacket.wValue = (USB_STRING_DESCRIPTOR_TYPE << 8) | descriptorIndex;

++     request->SetupPacket.wIndex = languageID;

++     request->SetupPacket.wLength = MAXIMUM_USB_STRING_LENGTH;

++

++     ULONG   bytesReturned = 0;

++     BOOL success = DeviceIoControl(hHubDevice, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,

++                                    request, bufferSize, request, bufferSize, &bytesReturned,

++                                    nullptr);

++

++     if (!success)

++         return {};

++

++     constexpr ULONG minExpectedSize = sizeof(USB_DESCRIPTOR_REQUEST) +

++             sizeof(USB_STRING_DESCRIPTOR);

++

++     if (bytesReturned < minExpectedSize)

++         return {};

++

++     const auto stringDesc = reinterpret_cast<PUSB_STRING_DESCRIPTOR>(request->Data);

++

++     if (stringDesc->bDescriptorType != USB_STRING_DESCRIPTOR_TYPE)

++         return {};

++

++     if (stringDesc->bLength != bytesReturned - sizeof(USB_DESCRIPTOR_REQUEST))

++         return {};

++

++     if (stringDesc->bLength % 2 != 0)

++         return {};

++

++     // Offset per USB 2.0 standard, section 9.6.7 table 9-16.

++     // bLength appears to include the size of the first 2 bytes of the descriptor

++     constexpr int stringOffset = 2;

++     const int numWideChars = (stringDesc->bLength - stringOffset) / sizeof(wchar_t);

++     return QString::fromWCharArray(stringDesc->bString, numWideChars);

++ }

++

++ static std::vector<wchar_t> getDevicePath(DEVINST devInst)

++ {

++     unsigned long devIdSize;

++

++     if (::CM_Get_Device_ID_Size(&devIdSize, devInst, 0) != CR_SUCCESS) {

++         return {};

++     }

++

++     std::vector<wchar_t> buffer(devIdSize + 1);

++

++     if (::CM_Get_Device_ID(devInst, buffer.data(), devIdSize, 0) != CR_SUCCESS) {

++         return {};

++     }

++

++     return buffer;

++ }

++

++ // Returns true if a hub is found, false if we gave up and didn't find one

++ // Passes devLocation by ref - port number on the hub of the device we need info for.

++ // Passes buffer by ref - path to the device we need to query to get information

++ static bool getUSBLocationAndPath(DWORD devInst, int &devLocation, std::vector<wchar_t> &buffer)

++ {

++     bool hubFound = false;

++     int count = 0;

++     QString devLocationStr;

++     std::vector<wchar_t> devicePath = {};

++

++

++     // In order to find the actual information we want to find in subsequent function calls,

++     // We have to get the port number on the hub of the device we want from that device,

++     // and we have to get the path to the hub device. Both are required to get

++     // any of the usb data we want. So we loop through starting with the passed-in

++     // device instance, and we return (via out arguments) the port of the device connected

++     // to the hub, and the path to the hub itself.

++

++     while (!hubFound && (count < 3)) {

++         DEVINST parentDevInst;

++         if (count == 0) {

++             parentDevInst = devInst;

++         } else {

++             if (::CM_Get_Parent(&parentDevInst, devInst, 0) != CR_SUCCESS) {

++                 return false;

++             }

++         }

++

++         devicePath = getDevicePath(parentDevInst);

++

++         if (devicePath.empty())

++             return false;

++

++         // Get info for this device. If it's a composite device we'll have to go up another level.

++

++         const DevInfoHandle currDeviceInformation{ ::SetupDiGetClassDevsW(

++                 nullptr, devicePath.data(), nullptr,

++                 DIGCF_ALLCLASSES | DIGCF_PRESENT | DIGCF_DEVICEINTERFACE) };

++

++         if (!currDeviceInformation)

++             return false;

++

++         SP_DEVINFO_DATA currDeviceInfoData = {};

++         currDeviceInfoData.cbSize = sizeof(currDeviceInfoData);

++

++         // There should only be one since we're getting info for the parent device

++         if (!::SetupDiEnumDeviceInfo(currDeviceInformation.get(), 0, &currDeviceInfoData)) {

++             return false;

++         }

++

++         // Find out if this device is a hub device, if so, we're done

++         const QString devDescription = deviceRegistryProperty(currDeviceInformation.get(),

++                                                               &currDeviceInfoData,

++                                                               SPDRP_DEVICEDESC);

++

++         if (devDescription.contains(L"Hub")) {

++             hubFound = true;

++         }  else {

++             devInst = parentDevInst;

++             devLocationStr = deviceRegistryProperty(currDeviceInformation.get(),

++                                                     &currDeviceInfoData,

++                                                     SPDRP_LOCATION_INFORMATION);

++             count++;

++         }

++     }

++

++     if (count == 3)

++         // didn't find what we were looking for. Give up.

++         return false;

++

++     if (!hubFound)

++         return false;

++

++     const QString portString(L"Port_#");

++

++     if (devLocationStr.contains(portString)) {

++         devLocationStr.remove(portString);

++         devLocation = devLocationStr.left(devLocationStr.indexOf(u'.')).toInt();

++     } else {

++         return false;

++     }

++

++     // Build the path based on information found here:

++     // https://stackoverflow.com/questions/

++     // 8007468/how-do-i-obtain-usb-device-descriptor-given-a-device-path/32641140#32641140

++     QString devPath = QString::fromStdWString(devicePath.data());

++     QString hubUuidStr = u'#' + QUuid(GUID_DEVINTERFACE_USB_HUB).toString();

++

++     devPath.replace(u'\\', u'#');

++     devPath.prepend(L"\\\\?\\");

++     devPath.append(hubUuidStr); // GUID for hub devices

++     buffer.resize(devPath.size()+1, 0);

++     devPath.toWCharArray(buffer.data());

++

++     return true;

++ }

++

++ struct UsbData

++ {

++     QString iManufacturer;

++     QString iProduct;

++ };

++

++ static UsbData getUSBDataFromDevice(DWORD devInst)

++ {

++     std::vector<wchar_t> buffer;

++     int devLocation;

++

++     if (!getUSBLocationAndPath(devInst, devLocation, buffer))

++         return {};

++

++     // Open the Hub device. To get the information we want, we have to open the Hub device,

++     // and pass in the port number in the argument structure.

++

++     const QUniqueWin32Handle fileHandle{ ::CreateFile(buffer.data(), GENERIC_READ, FILE_SHARE_READ,

++                                                       nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,

++                                                       nullptr) };

++

++     if (!fileHandle)

++         return {};

++

++     // Some of the following code was from Microsoft's sample usbview code

++     constexpr ULONG size = sizeof(USB_NODE_CONNECTION_INFORMATION);

++     std::array<UCHAR, size> connectionInfoData;

++

++     // Set the port number of the device on the hub for the DeviceIoControl call.

++     auto connectionInfo =

++             reinterpret_cast<PUSB_NODE_CONNECTION_INFORMATION>(connectionInfoData.data());

++     connectionInfo->ConnectionIndex = devLocation;

++

++     ULONG dataSize = 0;

++     if (!::DeviceIoControl(fileHandle.get(), IOCTL_USB_GET_NODE_CONNECTION_INFORMATION,

++                           connectionInfo, size, connectionInfo, size, &dataSize, nullptr)) {

++         return {};

++     }

++

++     // Get the language information, but we're only going to use the first one since we're going to

++     // use this information for the manufacturer returned to Qt's caller, and there's only 1 allowed

++     // there

++

++     QString usbStringData = getStringDescriptor(fileHandle.get(),

++                                                 connectionInfo->ConnectionIndex,

++                                                 0, 0);

++

++     if (usbStringData.isEmpty())

++         return {};

++

++     USHORT languageIDs = usbStringData[0].unicode();

++     UsbData usbData;

++

++     if (connectionInfo->DeviceDescriptor.iManufacturer != 0)

++         usbData.iManufacturer = getStringDescriptor(fileHandle.get(),

++                                                     connectionInfo->ConnectionIndex,

++                                                     connectionInfo->DeviceDescriptor.iManufacturer,

++                                                     languageIDs);

++

++     if (connectionInfo->DeviceDescriptor.iProduct != 0)

++         usbData.iProduct = getStringDescriptor(fileHandle.get(),

++                                                connectionInfo->ConnectionIndex,

++                                                connectionInfo->DeviceDescriptor.iProduct,

++                                                languageIDs);

++

++     return usbData;

++ }

++

++ static QString deviceInstanceIdentifier(DEVINST deviceInstanceNumber)

++ {

++     std::vector<wchar_t> outputBuffer(MAX_DEVICE_ID_LEN + 1, 0);

++     if (::CM_Get_Device_ID(

++                 deviceInstanceNumber,

++                 &outputBuffer[0],

++                 MAX_DEVICE_ID_LEN,

++                 0) != CR_SUCCESS) {

++         return QString();

++     }

++     return QString::fromWCharArray(&outputBuffer[0]).toUpper();

++ }

++

++ static DEVINST parentDeviceInstanceNumber(DEVINST childDeviceInstanceNumber)

++ {

++     ULONG nodeStatus = 0;

++     ULONG problemNumber = 0;

++     if (::CM_Get_DevNode_Status(&nodeStatus, &problemNumber,

++                                 childDeviceInstanceNumber, 0) != CR_SUCCESS) {

++         return 0;

++     }

++     DEVINST parentInstanceNumber = 0;

++     if (::CM_Get_Parent(&parentInstanceNumber, childDeviceInstanceNumber, 0) != CR_SUCCESS)

++         return 0;

++     return parentInstanceNumber;

++ }

++

++ static QString devicePortName(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData)

++ {

++     const HKEY key = ::SetupDiOpenDevRegKey(deviceInfoSet, deviceInfoData, DICS_FLAG_GLOBAL,

++                                             0, DIREG_DEV, KEY_READ);

++     if (key == INVALID_HANDLE_VALUE)

++         return QString();

++

++     static const wchar_t * const keyTokens[] = {

++             L"PortName\0",

++             L"PortNumber\0"

++     };

++

++     QString portName;

++     for (auto keyToken : keyTokens) {

++         DWORD dataType = 0;

++         std::vector<wchar_t> outputBuffer(MAX_PATH + 1, 0);

++         DWORD bytesRequired = MAX_PATH;

++         for (;;) {

++             const LONG ret = ::RegQueryValueEx(key, keyToken, nullptr, &dataType,

++                                                reinterpret_cast<PBYTE>(&outputBuffer[0]), &bytesRequired);

++             if (ret == ERROR_MORE_DATA) {

++                 outputBuffer.resize(bytesRequired / sizeof(wchar_t) + 2, 0);

++                 continue;

++             } else if (ret == ERROR_SUCCESS) {

++                 if (dataType == REG_SZ)

++                     portName = QString::fromWCharArray(&outputBuffer[0]);

++                 else if (dataType == REG_DWORD)

++                     portName = QStringLiteral("COM%1").arg(*(PDWORD(&outputBuffer[0])));

++             }

++             break;

++         }

++

++         if (!portName.isEmpty())

++             break;

++     }

++     ::RegCloseKey(key);

++     return portName;

++ }

++

++ static QString deviceDescription(HDEVINFO deviceInfoSet,

++                                  PSP_DEVINFO_DATA deviceInfoData)

++ {

++     return deviceRegistryProperty(deviceInfoSet, deviceInfoData, SPDRP_DEVICEDESC);

++ }

++

++ static QString deviceManufacturer(HDEVINFO deviceInfoSet,

++                                   PSP_DEVINFO_DATA deviceInfoData)

++ {

++     return deviceRegistryProperty(deviceInfoSet, deviceInfoData, SPDRP_MFG);

++ }

++

++ static quint16 parseDeviceIdentifier(const QString &instanceIdentifier,

++                                      const QString &identifierPrefix,

++                                      qsizetype identifierSize, bool &ok)

++ {

++     const qsizetype index = instanceIdentifier.indexOf(identifierPrefix);

++     if (index == -1)

++         return quint16(0);

++     return instanceIdentifier.mid(index + identifierPrefix.size(), identifierSize).toInt(&ok, 16);

++ }

++

++ static quint16 deviceVendorIdentifier(const QString &instanceIdentifier, bool &ok)

++ {

++     static constexpr qsizetype vendorIdentifierSize = 4;

++     quint16 result = parseDeviceIdentifier(

++                 instanceIdentifier, QStringLiteral("VID_"), vendorIdentifierSize, ok);

++     if (!ok)

++         result = parseDeviceIdentifier(

++                     instanceIdentifier, QStringLiteral("VEN_"), vendorIdentifierSize, ok);

++     return result;

++ }

++

++ static quint16 deviceProductIdentifier(const QString &instanceIdentifier, bool &ok)

++ {

++     static constexpr qsizetype productIdentifierSize = 4;

++     quint16 result = parseDeviceIdentifier(

++                 instanceIdentifier, QStringLiteral("PID_"), productIdentifierSize, ok);

++     if (!ok)

++         result = parseDeviceIdentifier(

++                     instanceIdentifier, QStringLiteral("DEV_"), productIdentifierSize, ok);

++     return result;

++ }

++

++ static QString parseDeviceSerialNumber(const QString &instanceIdentifier)

++ {

++     qsizetype firstbound = instanceIdentifier.lastIndexOf(QLatin1Char('\\'));

++     qsizetype lastbound = instanceIdentifier.indexOf(QLatin1Char('_'), firstbound);

++     if (instanceIdentifier.startsWith(QLatin1String("USB\\"))) {

++         if (lastbound != instanceIdentifier.size() - 3)

++             lastbound = instanceIdentifier.size();

++         qsizetype ampersand = instanceIdentifier.indexOf(QLatin1Char('&'), firstbound);

++         if (ampersand != -1 && ampersand < lastbound)

++             return QString();

++     } else if (instanceIdentifier.startsWith(QLatin1String("FTDIBUS\\"))) {

++         firstbound = instanceIdentifier.lastIndexOf(QLatin1Char('+'));

++         lastbound = instanceIdentifier.indexOf(QLatin1Char('\\'), firstbound);

++         if (lastbound == -1)

++             return QString();

++     } else {

++         return QString();

++     }

++

++     return instanceIdentifier.mid(firstbound + 1, lastbound - firstbound - 1);

++ }

++

++ static QString deviceSerialNumber(QString instanceIdentifier,

++                                   DEVINST deviceInstanceNumber)

++ {

++     for (;;) {

++         const QString result = parseDeviceSerialNumber(instanceIdentifier);

++         if (!result.isEmpty())

++             return result;

++         deviceInstanceNumber = parentDeviceInstanceNumber(deviceInstanceNumber);

++         if (deviceInstanceNumber == 0)

++             break;

++         instanceIdentifier = deviceInstanceIdentifier(deviceInstanceNumber);

++         if (instanceIdentifier.isEmpty())

++             break;

++     }

++

++     return QString();

++ }

++

++ static bool anyOfPorts(const QList<QSerialPortInfo> &ports, const QString &portName)

++ {

++     const auto end = ports.end();

++     auto isPortNamesEquals = [&portName](const QSerialPortInfo &portInfo) {

++         return portInfo.portName() == portName;

++     };

++     return std::find_if(ports.begin(), end, isPortNamesEquals) != end;

++ }

++

++ QList<QSerialPortInfo> QSerialPortInfo::availablePorts()

++ {

++     static const struct {

++         GUID guid; DWORD flags;

++     } setupTokens[] =  {

++         { GUID_DEVCLASS_PORTS, DIGCF_PRESENT },

++         { GUID_DEVCLASS_MODEM, DIGCF_PRESENT },

++         { GUID_DEVINTERFACE_COMPORT, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE },

++         { GUID_DEVINTERFACE_MODEM, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE }

++     };

++

++     QList<QSerialPortInfo> serialPortInfoList;

++

++     for (const auto& setupToken : setupTokens) {

++         const DevInfoHandle deviceInfoSet{ ::SetupDiGetClassDevs(&setupToken.guid, nullptr,

++                                                                  nullptr, setupToken.flags) };

++         if (!deviceInfoSet)

++             return serialPortInfoList;

++

++         SP_DEVINFO_DATA deviceInfoData{};

++         deviceInfoData.cbSize = sizeof(deviceInfoData);

++

++         DWORD index = 0;

++         while (::SetupDiEnumDeviceInfo(deviceInfoSet.get(), index++, &deviceInfoData)) {

++             const QString portName = devicePortName(deviceInfoSet.get(), &deviceInfoData);

++             if (portName.isEmpty() || portName.contains(QLatin1String("LPT")))

++                 continue;

++

++             if (anyOfPorts(serialPortInfoList, portName))

++                 continue;

++

++             QSerialPortInfoPrivate priv;

++

++             priv.portName = portName;

++             priv.device = QSerialPortInfoPrivate::portNameToSystemLocation(portName);

++             priv.description = deviceDescription(deviceInfoSet.get(), &deviceInfoData);

++             priv.manufacturer = deviceManufacturer(deviceInfoSet.get(), &deviceInfoData);

++

++             const QString instanceIdentifier = deviceInstanceIdentifier(deviceInfoData.DevInst);

++

++             priv.serialNumber =

++                     deviceSerialNumber(instanceIdentifier, deviceInfoData.DevInst);

++             priv.vendorIdentifier =

++                     deviceVendorIdentifier(instanceIdentifier, priv.hasVendorIdentifier);

++             priv.productIdentifier =

++                     deviceProductIdentifier(instanceIdentifier, priv.hasProductIdentifier);

++

++             // This makes Windows return the same data that linux does for Manufacturer and Product

++             if ((instanceIdentifier.startsWith(L"USB\\")

++                  || instanceIdentifier.startsWith(L"FTDIBUS\\"))

++                 && priv.hasVendorIdentifier && priv.hasProductIdentifier) {

++                 UsbData usbStrings = getUSBDataFromDevice(deviceInfoData.DevInst);

++

++                 if (!usbStrings.iManufacturer.isEmpty())

++                     priv.manufacturer = usbStrings.iManufacturer;

++

++                 if (!usbStrings.iProduct.isEmpty())

++                     priv.description = usbStrings.iProduct;

++                 // End of making Windows return the same data as Linux

++             }

++

++             serialPortInfoList.append(priv);

++         }

++     }

++

++     const auto portNames = portNamesFromHardwareDeviceMap();

++     for (const QString &portName : portNames) {

++         if (!anyOfPorts(serialPortInfoList, portName)) {

++             QSerialPortInfoPrivate priv;

++             priv.portName = portName;

++             priv.device =  QSerialPortInfoPrivate::portNameToSystemLocation(portName);

++             serialPortInfoList.append(priv);

++         }

++     }

++

++     return serialPortInfoList;

++ }

++

++ QString QSerialPortInfoPrivate::portNameToSystemLocation(const QString &source)

++ {

++     return source.startsWith(QLatin1String("COM"))

++             ? (QLatin1String("\\\\.\\") + source) : source;

++ }

++

++ QString QSerialPortInfoPrivate::portNameFromSystemLocation(const QString &source)

++ {

++     return (source.startsWith(QLatin1String("\\\\.\\"))

++             || source.startsWith(QLatin1String("//./")))

++             ? source.mid(4) : source;

++ }

++

++ QT_END_NAMESPACE

Revision control