qdbusconnectionmanager.cpp

++ // Copyright (C) 2016 The Qt Company Ltd.

++ // Copyright (C) 2016 Intel Corporation.

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

++ // Qt-Security score:significant reason:default

++

++ #include "qdbusconnectionmanager_p.h"

++

++ #include <qcoreapplication.h>

++ #include <qthread.h>

++ #include <qstringlist.h>

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

++

++ #include "qdbuserror.h"

++ #include "qdbuspendingcall_p.h"

++ #include "qdbusmetatype_p.h"

++

++ #ifndef QT_NO_DBUS

++

++ QT_BEGIN_NAMESPACE

++

++ #ifdef Q_OS_WIN

++ static void preventDllUnload();

++ #endif

++

++ Q_GLOBAL_STATIC(QDBusConnectionManager, _q_manager)

++

++ QDBusConnectionPrivate *QDBusConnectionManager::busConnection(QDBusConnection::BusType type)

++ {

++     static_assert(int(QDBusConnection::SessionBus) + int(QDBusConnection::SystemBus) == 1);

++     Q_ASSERT(type == QDBusConnection::SessionBus || type == QDBusConnection::SystemBus);

++

++     if (!qdbus_loadLibDBus())

++         return nullptr;

++

++     // we'll start in suspended delivery mode if we're in the main thread

++     // (the event loop will resume delivery) and QCoreApplication already exists

++     bool suspendedDelivery = QThread::isMainThread() && qApp;

++

++     const auto locker = qt_scoped_lock(defaultBusMutex);

++     if (defaultBuses[type])

++         return defaultBuses[type];

++

++     QString name = QStringLiteral("qt_default_session_bus");

++     if (type == QDBusConnection::SystemBus)

++         name = QStringLiteral("qt_default_system_bus");

++     return defaultBuses[type] = connectToBus(type, name, suspendedDelivery);

++ }

++

++ QDBusConnectionPrivate *QDBusConnectionManager::connection(const QString &name) const

++ {

++     return connectionHash.value(name, nullptr);

++ }

++

++ QDBusConnectionPrivate *QDBusConnectionManager::existingConnection(const QString &name) const

++ {

++     const auto locker = qt_scoped_lock(mutex);

++     auto *conn = connection(name);

++     if (conn)

++         conn->ref.ref();

++     return conn;

++ }

++

++ void QDBusConnectionManager::removeConnection(const QString &name)

++ {

++     QDBusConnectionPrivate *d = nullptr;

++     d = connectionHash.take(name);

++     if (d && !d->ref.deref())

++         d->deleteLater();

++

++     // Static objects may be keeping the connection open.

++     // However, it is harmless to have outstanding references to a connection that is

++     // closing as long as those references will be soon dropped without being used.

++

++     // ### Output a warning if connections are being used after they have been removed.

++ }

++

++ void QDBusConnectionManager::removeConnections(const QStringList &names)

++ {

++     const auto locker = qt_scoped_lock(mutex);

++

++     for (const auto &name : names)

++         removeConnection(name);

++ }

++

++ void QDBusConnectionManager::disconnectFrom(const QString &name,

++                                             QDBusConnectionPrivate::ConnectionMode mode)

++ {

++     const auto locker = qt_scoped_lock(mutex);

++

++     QDBusConnectionPrivate *d = connection(name);

++     if (d && d->mode != mode)

++         return;

++     removeConnection(name);

++ }

++

++ QDBusConnectionManager::QDBusConnectionManager()

++ {

++     // Ensure that the custom metatype registry is created before the instance

++     // of this class. This will ensure that the registry is not destroyed before

++     // the connection manager at application exit (see also QTBUG-58732). This

++     // works with compilers that use mechanism similar to atexit() to call

++     // destructurs for global statics.

++     QDBusMetaTypeId::init();

++

++     moveToThread(this);         // ugly, don't do this in other projects

++

++ #ifdef Q_OS_WIN

++     // prevent the library from being unloaded on Windows. See comments in the function.

++     preventDllUnload();

++ #endif

++     defaultBuses[0] = defaultBuses[1] = nullptr;

++     start();

++ }

++

++ QDBusConnectionManager::~QDBusConnectionManager()

++ {

++     quit();

++     wait();

++ }

++

++ QDBusConnectionManager* QDBusConnectionManager::instance()

++ {

++     return _q_manager();

++ }

++

++ Q_DBUS_EXPORT void qDBusBindToApplication();

++ void qDBusBindToApplication()

++ {

++ }

++

++ void QDBusConnectionManager::setConnection(const QString &name, QDBusConnectionPrivate *c)

++ {

++     connectionHash[name] = c;

++     c->name = name;

++ }

++

++ void QDBusConnectionManager::addConnection(const QString &name, QDBusConnectionPrivate *c)

++ {

++     const auto locker = qt_scoped_lock(mutex);

++     setConnection(name, c);

++ }

++

++ void QDBusConnectionManager::run()

++ {

++     exec();

++

++     // cleanup:

++     const auto locker = qt_scoped_lock(mutex);

++     for (QDBusConnectionPrivate *d : std::as_const(connectionHash)) {

++         if (!d->ref.deref()) {

++             delete d;

++         } else {

++             d->closeConnection();

++             d->moveToThread(nullptr);     // allow it to be deleted in another thread

++         }

++     }

++     connectionHash.clear();

++

++     // allow deletion from any thread without warning

++     moveToThread(nullptr);

++ }

++

++ QDBusConnectionPrivate *QDBusConnectionManager::connectToBus(QDBusConnection::BusType type, const QString &name,

++                                                              bool suspendedDelivery)

++ {

++     QDBusConnectionPrivate *result = nullptr;

++

++     QMetaObject::invokeMethod(this, &QDBusConnectionManager::doConnectToStandardBus,

++                               Qt::BlockingQueuedConnection, qReturnArg(result), type, name,

++                               suspendedDelivery);

++

++     if (suspendedDelivery && result && result->connection)

++         result->enableDispatchDelayed(qApp); // qApp was checked in the caller

++

++     return result;

++ }

++

++ QDBusConnectionPrivate *QDBusConnectionManager::connectToBus(const QString &address, const QString &name)

++ {

++     QDBusConnectionPrivate *result = nullptr;

++

++     QMetaObject::invokeMethod(this, &QDBusConnectionManager::doConnectToBus,

++                               Qt::BlockingQueuedConnection, qReturnArg(result), address, name);

++

++     return result;

++ }

++

++ QDBusConnectionPrivate *QDBusConnectionManager::connectToPeer(const QString &address, const QString &name)

++ {

++     QDBusConnectionPrivate *result = nullptr;

++

++     QMetaObject::invokeMethod(this, &QDBusConnectionManager::doConnectToPeer,

++                               Qt::BlockingQueuedConnection, qReturnArg(result), address, name);

++

++     return result;

++ }

++

++ QDBusConnectionPrivate *

++ QDBusConnectionManager::doConnectToStandardBus(QDBusConnection::BusType type, const QString &name,

++                                                bool suspendedDelivery)

++ {

++     const auto locker = qt_scoped_lock(mutex);

++

++     // check if the connection exists by name

++     QDBusConnectionPrivate *d = connection(name);

++     if (d || name.isEmpty())

++         return d;

++

++     d = new QDBusConnectionPrivate;

++     DBusConnection *c = nullptr;

++     QDBusErrorInternal error;

++

++     switch (type) {

++     case QDBusConnection::SystemBus:

++         c = q_dbus_bus_get_private(DBUS_BUS_SYSTEM, error);

++         break;

++     case QDBusConnection::SessionBus:

++         c = q_dbus_bus_get_private(DBUS_BUS_SESSION, error);

++         break;

++     case QDBusConnection::ActivationBus:

++         c = q_dbus_bus_get_private(DBUS_BUS_STARTER, error);

++         break;

++     }

++

++     setConnection(name, d);

++

++     // create the bus service

++     // will lock in QDBusConnectionPrivate::connectRelay()

++     d->setConnection(c, error);

++     d->createBusService();

++     if (c && suspendedDelivery)

++         d->setDispatchEnabled(false);

++

++     return d;

++ }

++

++ QDBusConnectionPrivate *QDBusConnectionManager::doConnectToBus(const QString &address,

++                                                                const QString &name)

++ {

++     const auto locker = qt_scoped_lock(mutex);

++

++     // check if the connection exists by name

++     QDBusConnectionPrivate *d = connection(name);

++     if (d || name.isEmpty())

++         return d;

++

++     d = new QDBusConnectionPrivate;

++     QDBusErrorInternal error;

++

++     DBusConnection *c = q_dbus_connection_open_private(address.toUtf8().constData(), error);

++     if (c) {

++         // register on the bus

++         if (!q_dbus_bus_register(c, error)) {

++             q_dbus_connection_close(c);

++             q_dbus_connection_unref(c);

++             c = nullptr;

++         }

++     }

++

++     setConnection(name, d);

++

++     // create the bus service

++     // will lock in QDBusConnectionPrivate::connectRelay()

++     d->setConnection(c, error);

++     d->createBusService();

++

++     return d;

++ }

++

++ QDBusConnectionPrivate *QDBusConnectionManager::doConnectToPeer(const QString &address,

++                                                                 const QString &name)

++ {

++     const auto locker = qt_scoped_lock(mutex);

++

++     // check if the connection exists by name

++     QDBusConnectionPrivate *d = connection(name);

++     if (d || name.isEmpty())

++         return d;

++

++     d = new QDBusConnectionPrivate;

++     QDBusErrorInternal error;

++

++     DBusConnection *c = q_dbus_connection_open_private(address.toUtf8().constData(), error);

++

++     setConnection(name, d);

++     d->setPeer(c, error);

++

++     return d;

++ }

++

++ void QDBusConnectionManager::createServer(const QString &address, QDBusServer *server)

++ {

++     QMetaObject::invokeMethod(

++             this,

++             [&address, server] {

++                 QDBusErrorInternal error;

++                 QDBusConnectionPrivate *d = new QDBusConnectionPrivate;

++                 d->setServer(server, q_dbus_server_listen(address.toUtf8().constData(), error),

++                              error);

++             },

++             Qt::BlockingQueuedConnection);

++ }

++

++ QT_END_NAMESPACE

++

++ #include "moc_qdbusconnectionmanager_p.cpp"

++

++ #ifdef Q_OS_WIN

++ #  include <qt_windows.h>

++

++ QT_BEGIN_NAMESPACE

++ static void preventDllUnload()

++ {

++     // Thread termination is really wacky on Windows. For some reason we don't

++     // understand, exiting from the thread may try to unload the DLL. Since the

++     // QDBusConnectionManager thread runs until the DLL is unloaded, we've got

++     // a deadlock: the main thread is waiting for the manager thread to exit,

++     // but the manager thread is attempting to acquire a lock to unload the DLL.

++     //

++     // We work around the issue by preventing the unload from happening in the

++     // first place.

++     //

++     // For this trick, see the blog post titled "What is the point of FreeLibraryAndExitThread?"

++     // https://devblogs.microsoft.com/oldnewthing/20131105-00/?p=2733

++

++     static HMODULE self;

++     GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |

++                       GET_MODULE_HANDLE_EX_FLAG_PIN,

++                       reinterpret_cast<const wchar_t *>(&self), // any address in this DLL

++                       &self);

++ }

++ QT_END_NAMESPACE

++ #endif

++

++ #endif // QT_NO_DBUS

Revision control