qdbusconnection.cpp

Go to the documentation of this file.

// 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
 
#include "qdbusconnection.h"
#include "qdbusconnection_p.h"
 
#include <qdebug.h>
#include <qstringlist.h>
 
#include "qdbusconnectioninterface.h"
#include "qdbuserror.h"
#include "qdbusmessage.h"
#include "qdbusutil_p.h"
#include "qdbusconnectionmanager_p.h"
#include "qdbuspendingcall_p.h"
#include "qdbusthreaddebug_p.h"
 
#include <algorithm>
 
#ifdef interface
#undef interface
#endif
 
#ifndef QT_NO_DBUS
 
QT_BEGIN_NAMESPACE
 
QDBusConnection::QDBusConnection(const QString &name)
{
    if (name.isEmpty()) {
        d = nullptr;
        return;
    }
 
    auto *manager = QDBusConnectionManager::instance();
 
    if (!manager) {
        d = nullptr;
    } else {
        d = manager->existingConnection(name);
    }
}
 
QDBusConnection::QDBusConnection(const QDBusConnection &other)
{
    d = other.d;
    if (d)
        d->ref.ref();
}
 
QDBusConnection::QDBusConnection(QDBusConnectionPrivate *dd)
{
    d = dd;
    if (d)
        d->ref.ref();
}
 
QDBusConnection::~QDBusConnection()
{
    if (d && !d->ref.deref())
        d->deleteLater();
}
 
QDBusConnection &QDBusConnection::operator=(const QDBusConnection &other)
{
    if (other.d)
        other.d->ref.ref();
    if (d && !d->ref.deref())
        d->deleteLater();
    d = other.d;
    return *this;
}
 
QDBusConnection QDBusConnection::connectToBus(BusType type, const QString &name)
{
    auto *manager = QDBusConnectionManager::instance();
 
    if (!manager || !qdbus_loadLibDBus()) {
        QDBusConnectionPrivate *d = nullptr;
        return QDBusConnection(d);
    }
    return QDBusConnection(manager->connectToBus(type, name, false));
}
 
QDBusConnection QDBusConnection::connectToBus(const QString &address,
                                              const QString &name)
{
    auto *manager = QDBusConnectionManager::instance();
 
    if (!manager || !qdbus_loadLibDBus()) {
        QDBusConnectionPrivate *d = nullptr;
        return QDBusConnection(d);
    }
    return QDBusConnection(manager->connectToBus(address, name));
}
QDBusConnection QDBusConnection::connectToPeer(const QString &address,
                                               const QString &name)
{
    auto *manager = QDBusConnectionManager::instance();
 
    if (!manager || !qdbus_loadLibDBus()) {
        QDBusConnectionPrivate *d = nullptr;
        return QDBusConnection(d);
    }
    return QDBusConnection(manager->connectToPeer(address, name));
}
 
void QDBusConnection::disconnectFromBus(const QString &name)
{
    auto *manager = QDBusConnectionManager::instance();
    if (!manager)
        return;
 
    manager->disconnectFrom(name, QDBusConnectionPrivate::ClientMode);
}
 
void QDBusConnection::disconnectFromPeer(const QString &name)
{
    auto *manager = QDBusConnectionManager::instance();
    if (!manager)
        return;
 
    manager->disconnectFrom(name, QDBusConnectionPrivate::PeerMode);
}
 
bool QDBusConnection::send(const QDBusMessage &message) const
{
    if (!d || !d->connection) {
        QDBusError err = QDBusError(QDBusError::Disconnected,
                                    QDBusUtil::disconnectedErrorMessage());
        if (d)
            d->lastError = err;
        return false;
    }
    return d->send(message);
}
 
bool QDBusConnection::callWithCallback(const QDBusMessage &message, QObject *receiver,
                                       const char *returnMethod, const char *errorMethod,
                                       int timeout) const
{
    if (!d || !d->connection) {
        QDBusError err = QDBusError(QDBusError::Disconnected,
                                    QDBusUtil::disconnectedErrorMessage());
        if (d)
            d->lastError = err;
        return false;
    }
    return d->sendWithReplyAsync(message, receiver, returnMethod, errorMethod, timeout) != nullptr;
}
 
bool QDBusConnection::callWithCallback(const QDBusMessage &message, QObject *receiver,
                                       const char *returnMethod, int timeout) const
{
    return callWithCallback(message, receiver, returnMethod, nullptr, timeout);
}
 
QDBusMessage QDBusConnection::call(const QDBusMessage &message, QDBus::CallMode mode, int timeout) const
{
    if (!d || !d->connection) {
        QDBusError err = QDBusError(QDBusError::Disconnected,
                                    QDBusUtil::disconnectedErrorMessage());
        if (d)
            d->lastError = err;
 
        return QDBusMessage::createError(err);
    }
 
    if (mode != QDBus::NoBlock)
        return d->sendWithReply(message, mode, timeout);
 
    d->send(message);
    QDBusMessage retval;
    retval << QVariant(); // add one argument (to avoid .at(0) problems)
    return retval;
}
 
QDBusPendingCall QDBusConnection::asyncCall(const QDBusMessage &message, int timeout) const
{
    if (!d || !d->connection) {
        return QDBusPendingCall(nullptr); // null pointer -> disconnected
    }
 
    QDBusPendingCallPrivate *priv = d->sendWithReplyAsync(message, nullptr, nullptr, nullptr, timeout);
    return QDBusPendingCall(priv);
}
 
bool QDBusConnection::connect(const QString &service, const QString &path, const QString& interface,
                              const QString &name, QObject *receiver, const char *slot)
{
    return connect(service, path, interface, name, QStringList(), QString(), receiver, slot);
}
 
bool QDBusConnection::connect(const QString &service, const QString &path, const QString& interface,
                              const QString &name, const QString &signature,
                              QObject *receiver, const char *slot)
{
    return connect(service, path, interface, name, QStringList(), signature, receiver, slot);
}
 
bool QDBusConnection::connect(const QString &service, const QString &path, const QString& interface,
                              const QString &name, const QStringList &argumentMatch, const QString &signature,
                              QObject *receiver, const char *slot)
{
 
    if (!receiver || !slot || !d || !d->connection)
        return false;
    if (interface.isEmpty() && name.isEmpty())
        return false;
    if (!interface.isEmpty() && !QDBusUtil::isValidInterfaceName(interface)) {
#ifndef QT_NO_DEBUG
        qWarning("QDBusConnection::connect: interface name '%s' is not valid", interface.toLatin1().constData());
#endif
        return false;
    }
    if (!service.isEmpty() && !QDBusUtil::isValidBusName(service)) {
#ifndef QT_NO_DEBUG
        qWarning("QDBusConnection::connect: service name '%s' is not valid", service.toLatin1().constData());
#endif
        return false;
    }
    if (!path.isEmpty() && !QDBusUtil::isValidObjectPath(path)) {
#ifndef QT_NO_DEBUG
        qWarning("QDBusConnection::connect: object path '%s' is not valid", path.toLatin1().constData());
#endif
        return false;
    }
 
    return d->connectSignal(service, path, interface, name, argumentMatch, signature, receiver, slot);
}
 
bool QDBusConnection::disconnect(const QString &service, const QString &path, const QString &interface,
                                 const QString &name, QObject *receiver, const char *slot)
{
    return disconnect(service, path, interface, name, QStringList(), QString(), receiver, slot);
}
 
bool QDBusConnection::disconnect(const QString &service, const QString &path, const QString& interface,
                                 const QString &name, const QString &signature,
                                 QObject *receiver, const char *slot)
{
    return disconnect(service, path, interface, name, QStringList(), signature, receiver, slot);
}
 
bool QDBusConnection::disconnect(const QString &service, const QString &path, const QString& interface,
                                 const QString &name, const QStringList &argumentMatch, const QString &signature,
                                 QObject *receiver, const char *slot)
{
    if (!receiver || !slot || !d || !d->connection)
        return false;
    if (!interface.isEmpty() && !QDBusUtil::isValidInterfaceName(interface))
        return false;
    if (interface.isEmpty() && name.isEmpty())
        return false;
 
    return d->disconnectSignal(service, path, interface, name, argumentMatch, signature, receiver, slot);
}
 
bool QDBusConnection::registerObject(const QString &path, QObject *object, RegisterOptions options)
{
   return registerObject(path, QString(), object, options);
}
 
bool QDBusConnection::registerObject(const QString &path, const QString &interface, QObject *object, RegisterOptions options)
{
    Q_ASSERT_X(QDBusUtil::isValidObjectPath(path), "QDBusConnection::registerObject",
               "Invalid object path given");
    if (!d || !d->connection || !object || !options || !QDBusUtil::isValidObjectPath(path))
        return false;
 
    auto pathComponents = QStringView{path}.split(u'/');
    if (pathComponents.constLast().isEmpty())
        pathComponents.removeLast();
    QDBusWriteLocker locker(RegisterObjectAction, d);
 
    // lower-bound search for where this object should enter in the tree
    QDBusConnectionPrivate::ObjectTreeNode *node = &d->rootNode;
    int i = 1;
    while (node) {
        if (pathComponents.size() == i) {
            // this node exists
            // consider it free if there's no object here and the user is not trying to
            // replace the object sub-tree
            if (node->obj)
                return false;
 
            if (options & QDBusConnectionPrivate::VirtualObject) {
                if (options & SubPath && !node->children.isEmpty())
                    return false;
            } else {
                if ((options & ExportChildObjects && !node->children.isEmpty()))
                    return false;
            }
            // we can add the object here
            node->obj = object;
            node->flags = options;
            node->interfaceName = interface;
 
            d->registerObject(node);
            //qDebug("REGISTERED FOR %s", path.toLocal8Bit().constData());
            return true;
        }
 
        // if a virtual object occupies this path, return false
        if (node->obj && (node->flags & QDBusConnectionPrivate::VirtualObject) && (node->flags & QDBusConnection::SubPath)) {
            //qDebug("Cannot register object at %s because QDBusVirtualObject handles all sub-paths.",
            //       qPrintable(path));
            return false;
        }
 
        // find the position where we'd insert the node
        QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator it =
            std::lower_bound(node->children.begin(), node->children.end(), pathComponents.at(i));
        if (it != node->children.end() && it->name == pathComponents.at(i)) {
            // match: this node exists
            node = &(*it);
 
            // are we allowed to go deeper?
            if (node->flags & ExportChildObjects) {
                // we're not
                //qDebug("Cannot register object at %s because %s exports its own child objects",
                //       qPrintable(path), qPrintable(pathComponents.at(i)));
                return false;
            }
        } else {
            // add entry
            it = node->children.insert(it, pathComponents.at(i).toString());
            node = &(*it);
        }
 
        // iterate
        ++i;
    }
 
    Q_ASSERT_X(false, "QDBusConnection::registerObject", "The impossible happened");
    return false;
}
 
bool QDBusConnection::registerVirtualObject(const QString &path, QDBusVirtualObject *treeNode,
                      VirtualObjectRegisterOption options)
{
    int opts = options | QDBusConnectionPrivate::VirtualObject;
    return registerObject(path, (QObject*) treeNode, (RegisterOptions) opts);
}
 
void QDBusConnection::unregisterObject(const QString &path, UnregisterMode mode)
{
    if (!d || !d->connection || !QDBusUtil::isValidObjectPath(path))
        return;
 
    QDBusWriteLocker locker(UnregisterObjectAction, d);
    d->unregisterObject(path, mode);
}
 
QObject *QDBusConnection::objectRegisteredAt(const QString &path) const
{
    Q_ASSERT_X(QDBusUtil::isValidObjectPath(path), "QDBusConnection::registeredObject",
               "Invalid object path given");
    if (!d || !d->connection || !QDBusUtil::isValidObjectPath(path))
        return nullptr;
 
    auto pathComponents = QStringView{path}.split(u'/');
    if (pathComponents.constLast().isEmpty())
        pathComponents.removeLast();
 
    // lower-bound search for where this object should enter in the tree
    QDBusReadLocker lock(ObjectRegisteredAtAction, d);
    const QDBusConnectionPrivate::ObjectTreeNode *node = &d->rootNode;
 
    int i = 1;
    while (node) {
        if (pathComponents.size() == i)
            return node->obj;
        if ((node->flags & QDBusConnectionPrivate::VirtualObject) && (node->flags & QDBusConnection::SubPath))
            return node->obj;
 
        QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it =
            std::lower_bound(node->children.constBegin(), node->children.constEnd(), pathComponents.at(i));
        if (it == node->children.constEnd() || it->name != pathComponents.at(i))
            break;              // node not found
 
        node = &(*it);
        ++i;
    }
    return nullptr;
}
 
 
 
QDBusConnectionInterface *QDBusConnection::interface() const
{
    if (!d || d->mode != QDBusConnectionPrivate::ClientMode)
        return nullptr;
    return d->busService;
}
 
void *QDBusConnection::internalPointer() const
{
    return d ? d->connection : nullptr;
}
 
bool QDBusConnection::isConnected() const
{
    return d && d->connection && q_dbus_connection_get_is_connected(d->connection);
}
 
QDBusError QDBusConnection::lastError() const
{
    return d ? d->lastError : QDBusError(QDBusError::Disconnected, QDBusUtil::disconnectedErrorMessage());
}
 
QString QDBusConnection::baseService() const
{
    return d ? d->baseService : QString();
}
 
QString QDBusConnection::name() const
{
    return d ? d->name : QString();
}
 
QDBusConnection::ConnectionCapabilities QDBusConnection::connectionCapabilities() const
{
    return d ? d->connectionCapabilities() : ConnectionCapabilities();
}
 
bool QDBusConnection::registerService(const QString &serviceName)
{
    if (interface() && interface()->registerService(serviceName)) {
        if (d) d->registerService(serviceName);
        return true;
    }
    return false;
}
 
bool QDBusConnection::unregisterService(const QString &serviceName)
{
    if (interface()->unregisterService(serviceName)) {
        if (d) d->unregisterService(serviceName);
        return true;
    }
    return false;
}
 
QDBusConnection QDBusConnection::sessionBus()
{
    auto *manager = QDBusConnectionManager::instance();
 
    if (!manager)
        return QDBusConnection(nullptr);
    return QDBusConnection(manager->busConnection(SessionBus));
}
 
QDBusConnection QDBusConnection::systemBus()
{
    auto *manager = QDBusConnectionManager::instance();
 
    if (!manager)
        return QDBusConnection(nullptr);
    return QDBusConnection(manager->busConnection(SystemBus));
}
 
void QDBusConnectionPrivate::createBusService()
{
    Q_ASSERT(mode == ClientMode);
    QDBusConnection connection(this);
    busService = new QDBusConnectionInterface(connection, this);
    ref.deref(); // busService has increased the refcounting to us
                 // avoid cyclic refcounting
 
    QObject::connect(this, &QDBusConnectionPrivate::callWithCallbackFailed,
                     busService, emit &QDBusConnectionInterface::callWithCallbackFailed,
                     Qt::QueuedConnection);
}
 
QByteArray QDBusConnection::localMachineId()
{
    char *dbus_machine_id = q_dbus_get_local_machine_id();
    QByteArray result = dbus_machine_id;
    q_dbus_free(dbus_machine_id);
    return result;
}
 
QT_END_NAMESPACE
 
#include "moc_qdbusconnection_p.cpp"
#include "moc_qdbusconnection.cpp"
 
#endif // QT_NO_DBUS