qdbusabstractinterface.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 "qdbusabstractinterface.h"
#include "qdbusabstractinterface_p.h"
 
#include <qcoreapplication.h>
#include <qthread.h>
 
#include "qdbusargument.h"
#include "qdbuspendingcall.h"
#include "qdbusmessage_p.h"
#include "qdbusmetaobject_p.h"
#include "qdbusmetatype_p.h"
#include "qdbusservicewatcher.h"
#include "qdbusutil_p.h"
 
#include <qdebug.h>
 
#ifndef QT_NO_DBUS
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
namespace {
// ### Qt6: change to a regular QEvent (customEvent)
// We need to use a QMetaCallEvent here because we can't override customEvent() in
// Qt 5. Since QDBusAbstractInterface is meant to be derived from, the vtables of
// classes in generated code will have a pointer to QObject::customEvent instead
// of to QDBusAbstractInterface::customEvent.
// See solution in Patch Set 1 of this change in the Qt Gerrit servers.
// (https://codereview.qt-project.org/#/c/126384/1)
class DisconnectRelayEvent : public QAbstractMetaCallEvent
{
public:
    DisconnectRelayEvent(QObject *sender, const QMetaMethod &m)
        : QAbstractMetaCallEvent(sender, m.methodIndex())
    {}
 
    void placeMetaCall(QObject *object) override
    {
        QDBusAbstractInterface *iface = static_cast<QDBusAbstractInterface *>(object);
        QDBusAbstractInterfacePrivate::finishDisconnectNotify(iface, signalId());
    }
};
}
 
static QDBusError checkIfValid(const QString &service, const QString &path,
                               const QString &interface, bool isDynamic, bool isPeer)
{
    // We should be throwing exceptions here... oh well
    QDBusError error;
 
    // dynamic interfaces (QDBusInterface) can have empty interfaces, but not service and object paths
    // non-dynamic is the opposite: service and object paths can be empty, but not the interface
    if (!isDynamic) {
        // use assertion here because this should never happen, at all
        Q_ASSERT_X(!interface.isEmpty(), "QDBusAbstractInterface", "Interface name cannot be empty");
    }
    if (!QDBusUtil::checkBusName(service, (isDynamic && !isPeer) ? QDBusUtil::EmptyNotAllowed : QDBusUtil::EmptyAllowed, &error))
        return error;
    if (!QDBusUtil::checkObjectPath(path, isDynamic ? QDBusUtil::EmptyNotAllowed : QDBusUtil::EmptyAllowed, &error))
        return error;
    if (!QDBusUtil::checkInterfaceName(interface, QDBusUtil::EmptyAllowed, &error))
        return error;
 
    // no error
    return QDBusError();
}
 
QDBusAbstractInterfacePrivate::QDBusAbstractInterfacePrivate(const QString &serv,
                                                             const QString &p,
                                                             const QString &iface,
                                                             const QDBusConnection& con,
                                                             bool isDynamic)
    : connection(con), service(serv), path(p), interface(iface),
      lastError(checkIfValid(serv, p, iface, isDynamic, (connectionPrivate() &&
                                                         connectionPrivate()->mode == QDBusConnectionPrivate::PeerMode))),
      timeout(-1),
      interactiveAuthorizationAllowed(false),
      isValid(!lastError.isValid())
{
    if (!isValid)
        return;
 
    if (!connection.isConnected()) {
        lastError = QDBusError(QDBusError::Disconnected,
                               QDBusUtil::disconnectedErrorMessage());
    }
}
 
void QDBusAbstractInterfacePrivate::initOwnerTracking()
{
    if (!isValid || !connection.isConnected() || !connectionPrivate()->shouldWatchService(service))
        return;
 
    QObject::connect(new QDBusServiceWatcher(service, connection, QDBusServiceWatcher::WatchForOwnerChange, q_func()),
                     SIGNAL(serviceOwnerChanged(QString,QString,QString)),
                     q_func(), SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
 
    currentOwner = connectionPrivate()->getNameOwner(service);
    if (currentOwner.isEmpty())
        lastError = connectionPrivate()->lastError;
}
 
bool QDBusAbstractInterfacePrivate::canMakeCalls() const
{
    // recheck only if we have a wildcard (i.e. empty) service or path
    // if any are empty, set the error message according to QDBusUtil
    if (service.isEmpty() && connectionPrivate()->mode != QDBusConnectionPrivate::PeerMode)
        return QDBusUtil::checkBusName(service, QDBusUtil::EmptyNotAllowed, &lastError);
    if (path.isEmpty())
        return QDBusUtil::checkObjectPath(path, QDBusUtil::EmptyNotAllowed, &lastError);
    return true;
}
 
bool QDBusAbstractInterfacePrivate::property(const QMetaProperty &mp, void *returnValuePtr) const
{
    if (!isValid || !canMakeCalls())   // can't make calls
        return false;
 
    QMetaType type = mp.metaType();
    // is this metatype registered?
    const char *expectedSignature = "";
    if (type.id() != QMetaType::QVariant) {
        expectedSignature = QDBusMetaType::typeToSignature(type);
        if (expectedSignature == nullptr) {
            qWarning("QDBusAbstractInterface: type %s must be registered with Qt D-Bus before it can be "
                     "used to read property %s.%s",
                     mp.typeName(), qPrintable(interface), mp.name());
            lastError = QDBusError(QDBusError::Failed, "Unregistered type %1 cannot be handled"_L1
                                   .arg(QLatin1StringView(mp.typeName())));
            return false;
        }
    }
 
    // try to read this property
    QDBusMessage msg = QDBusMessage::createMethodCall(service, path,
                                                      QDBusUtil::dbusInterfaceProperties(),
                                                      QStringLiteral("Get"));
    QDBusMessagePrivate::setParametersValidated(msg, true);
    msg << interface << QString::fromUtf8(mp.name());
    QDBusMessage reply = connection.call(msg, QDBus::Block, timeout);
 
    if (reply.type() != QDBusMessage::ReplyMessage) {
        lastError = QDBusError(reply);
        return false;
    }
    if (reply.signature() != "v"_L1) {
        QString errmsg =
                "Invalid signature '%1' in return from call to " DBUS_INTERFACE_PROPERTIES ""_L1;
        lastError = QDBusError(QDBusError::InvalidSignature, std::move(errmsg).arg(reply.signature()));
        return false;
    }
 
    QByteArray foundSignature;
    const char *foundType = nullptr;
    QVariant value = qvariant_cast<QDBusVariant>(reply.arguments().at(0)).variant();
 
    if (value.metaType() == type || type.id() == QMetaType::QVariant
        || (expectedSignature[0] == 'v' && expectedSignature[1] == '\0')) {
        // simple match
        if (type.id() == QMetaType::QVariant) {
            *reinterpret_cast<QVariant*>(returnValuePtr) = value;
        } else {
            QMetaType(type).destruct(returnValuePtr);
            QMetaType(type).construct(returnValuePtr, value.constData());
        }
        return true;
    }
 
    if (value.metaType() == QMetaType::fromType<QDBusArgument>()) {
        QDBusArgument arg = qvariant_cast<QDBusArgument>(value);
 
        foundType = "user type";
        foundSignature = arg.currentSignature().toLatin1();
        if (foundSignature == expectedSignature) {
            // signatures match, we can demarshall
            return QDBusMetaType::demarshall(arg, QMetaType(type), returnValuePtr);
        }
    } else {
        foundType = value.typeName();
        foundSignature = QDBusMetaType::typeToSignature(value.metaType());
    }
 
    // there was an error...
    const auto errmsg = "Unexpected '%1' (%2) when retrieving property '%3.%4' "
                        "(expected type '%5' (%6))"_L1;
    lastError = QDBusError(QDBusError::InvalidSignature,
                           errmsg.arg(QLatin1StringView(foundType),
                                      QLatin1StringView(foundSignature),
                                      interface,
                                      QLatin1StringView(mp.name()),
                                      QLatin1StringView(mp.typeName()),
                                      QLatin1StringView(expectedSignature)));
    return false;
}
 
bool QDBusAbstractInterfacePrivate::setProperty(const QMetaProperty &mp, const QVariant &value)
{
    if (!isValid || !canMakeCalls())    // can't make calls
        return false;
 
    // send the value
    QDBusMessage msg = QDBusMessage::createMethodCall(service, path,
                                                      QDBusUtil::dbusInterfaceProperties(),
                                                      QStringLiteral("Set"));
    QDBusMessagePrivate::setParametersValidated(msg, true);
    msg << interface << QString::fromUtf8(mp.name()) << QVariant::fromValue(QDBusVariant(value));
    QDBusMessage reply = connection.call(msg, QDBus::Block, timeout);
 
    if (reply.type() != QDBusMessage::ReplyMessage) {
        lastError = QDBusError(reply);
        return false;
    }
    return true;
}
 
void QDBusAbstractInterfacePrivate::_q_serviceOwnerChanged(const QString &name,
                                                           const QString &oldOwner,
                                                           const QString &newOwner)
{
    Q_UNUSED(oldOwner);
    //qDebug() << "QDBusAbstractInterfacePrivate serviceOwnerChanged" << name << oldOwner << newOwner;
    Q_ASSERT(name == service);
    currentOwner = newOwner;
}
 
QDBusAbstractInterfaceBase::QDBusAbstractInterfaceBase(QDBusAbstractInterfacePrivate &d, QObject *parent)
    : QObject(d, parent)
{
}
 
int QDBusAbstractInterfaceBase::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    int saved_id = _id;
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
 
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty) {
        QMetaProperty mp = metaObject()->property(saved_id);
        int &status = *reinterpret_cast<int *>(_a[2]);
 
        if (_c == QMetaObject::WriteProperty) {
            QVariant value;
            if (mp.metaType() == QMetaType::fromType<QDBusVariant>())
                value = reinterpret_cast<const QDBusVariant*>(_a[0])->variant();
            else
                value = QVariant(mp.metaType(), _a[0]);
            status = d_func()->setProperty(mp, value) ? 1 : 0;
        } else {
            bool readStatus = d_func()->property(mp, _a[0]);
            // Caller supports QVariant returns? Then we can also report errors
            // by storing an invalid variant.
            if (!readStatus && _a[1]) {
                status = 0;
                reinterpret_cast<QVariant*>(_a[1])->clear();
            }
        }
        _id = -1;
    }
    return _id;
}
 
QDBusAbstractInterface::QDBusAbstractInterface(QDBusAbstractInterfacePrivate &d, QObject *parent)
    : QDBusAbstractInterfaceBase(d, parent)
{
    d.initOwnerTracking();
}
 
QDBusAbstractInterface::QDBusAbstractInterface(const QString &service, const QString &path,
                                               const char *interface, const QDBusConnection &con,
                                               QObject *parent)
    : QDBusAbstractInterfaceBase(*new QDBusAbstractInterfacePrivate(service, path, QString::fromLatin1(interface),
                                                 con, false), parent)
{
    // keep track of the service owner
    d_func()->initOwnerTracking();
}
 
QDBusAbstractInterface::~QDBusAbstractInterface()
{
}
 
bool QDBusAbstractInterface::isValid() const
{
    Q_D(const QDBusAbstractInterface);
    /* We don't retrieve the owner name for peer connections */
    if (d->connectionPrivate() && d->connectionPrivate()->mode == QDBusConnectionPrivate::PeerMode) {
        return d->isValid;
    } else {
        return !d->currentOwner.isEmpty();
    }
}
 
QDBusConnection QDBusAbstractInterface::connection() const
{
    return d_func()->connection;
}
 
QString QDBusAbstractInterface::service() const
{
    return d_func()->service;
}
 
QString QDBusAbstractInterface::path() const
{
    return d_func()->path;
}
 
QString QDBusAbstractInterface::interface() const
{
    return d_func()->interface;
}
 
QDBusError QDBusAbstractInterface::lastError() const
{
    return d_func()->lastError;
}
 
void QDBusAbstractInterface::setTimeout(int timeout)
{
    d_func()->timeout = timeout;
}
 
int QDBusAbstractInterface::timeout() const
{
    return d_func()->timeout;
}
 
void QDBusAbstractInterface::setInteractiveAuthorizationAllowed(bool enable)
{
    d_func()->interactiveAuthorizationAllowed = enable;
}
 
bool QDBusAbstractInterface::isInteractiveAuthorizationAllowed() const
{
    return d_func()->interactiveAuthorizationAllowed;
}
 
QDBusMessage QDBusAbstractInterface::callWithArgumentList(QDBus::CallMode mode,
                                                          const QString& method,
                                                          const QList<QVariant>& args)
{
    Q_D(QDBusAbstractInterface);
 
    if (!d->isValid || !d->canMakeCalls())
        return QDBusMessage::createError(d->lastError);
 
    QString m = method;
    // split out the signature from the method
    int pos = method.indexOf(u'.');
    if (pos != -1)
        m.truncate(pos);
 
    if (mode == QDBus::AutoDetect) {
        // determine if this a sync or async call
        mode = QDBus::Block;
        const QMetaObject *mo = metaObject();
        QByteArray match = m.toLatin1();
 
        for (int i = staticMetaObject.methodCount(); i < mo->methodCount(); ++i) {
            QMetaMethod mm = mo->method(i);
            if (mm.name() == match) {
                // found a method with the same name as what we're looking for
                // hopefully, nobody is overloading asynchronous and synchronous methods with
                // the same name
 
                QList<QByteArray> tags = QByteArray(mm.tag()).split(' ');
                if (tags.contains("Q_NOREPLY"))
                    mode = QDBus::NoBlock;
 
                break;
            }
        }
    }
 
//    qDebug() << "QDBusAbstractInterface" << "Service" << service() << "Path:" << path();
    QDBusMessage msg = QDBusMessage::createMethodCall(service(), path(), interface(), m);
    QDBusMessagePrivate::setParametersValidated(msg, true);
    msg.setArguments(args);
 
    QDBusMessage reply = d->connection.call(msg, mode, d->timeout);
    if (thread() == QThread::currentThread())
        d->lastError = QDBusError(reply);       // will clear if reply isn't an error
 
    // ensure that there is at least one element
    if (reply.arguments().isEmpty())
        reply << QVariant();
 
    return reply;
}
 
QDBusPendingCall QDBusAbstractInterface::asyncCallWithArgumentList(const QString& method,
                                                                   const QList<QVariant>& args)
{
    Q_D(QDBusAbstractInterface);
 
    if (!d->isValid || !d->canMakeCalls())
        return QDBusPendingCall::fromError(d->lastError);
 
    QDBusMessage msg = QDBusMessage::createMethodCall(service(), path(), interface(), method);
    QDBusMessagePrivate::setParametersValidated(msg, true);
    msg.setArguments(args);
    if (d->interactiveAuthorizationAllowed)
        msg.setInteractiveAuthorizationAllowed(true);
    return d->connection.asyncCall(msg, d->timeout);
}
 
bool QDBusAbstractInterface::callWithCallback(const QString &method,
                                              const QList<QVariant> &args,
                                              QObject *receiver,
                                              const char *returnMethod,
                                              const char *errorMethod)
{
    Q_D(QDBusAbstractInterface);
 
    if (!d->isValid || !d->canMakeCalls())
        return false;
 
    QDBusMessage msg = QDBusMessage::createMethodCall(service(),
                                                      path(),
                                                      interface(),
                                                      method);
    QDBusMessagePrivate::setParametersValidated(msg, true);
    msg.setArguments(args);
 
    d->lastError = QDBusError();
    return d->connection.callWithCallback(msg,
                                          receiver,
                                          returnMethod,
                                          errorMethod,
                                          d->timeout);
}
 
bool QDBusAbstractInterface::callWithCallback(const QString &method,
                                              const QList<QVariant> &args,
                                              QObject *receiver,
                                              const char *slot)
{
    return callWithCallback(method, args, receiver, slot, nullptr);
}
 
void QDBusAbstractInterface::connectNotify(const QMetaMethod &signal)
{
    // someone connecting to one of our signals
    Q_D(QDBusAbstractInterface);
    if (!d->isValid)
        return;
 
    // we end up recursing here, so optimize away
    static const QMetaMethod destroyedSignal = QMetaMethod::fromSignal(&QDBusAbstractInterface::destroyed);
    if (signal == destroyedSignal)
        return;
 
    QDBusConnectionPrivate *conn = d->connectionPrivate();
    if (conn) {
        conn->connectRelay(d->service, d->path, d->interface,
                           this, signal);
    }
}
 
void QDBusAbstractInterface::disconnectNotify(const QMetaMethod &signal)
{
    // someone disconnecting from one of our signals
    Q_D(QDBusAbstractInterface);
    if (!d->isValid)
        return;
 
    // disconnection is just resource freeing, so it can be delayed;
    // let's do that later, after all the QObject mutexes have been unlocked.
    QCoreApplication::postEvent(this, new DisconnectRelayEvent(this, signal));
}
 
void QDBusAbstractInterfacePrivate::finishDisconnectNotify(QDBusAbstractInterface *ptr, int signalId)
{
    QDBusAbstractInterfacePrivate *d = ptr->d_func();
    QDBusConnectionPrivate *conn = d->connectionPrivate();
    if (!conn)
        return;
 
    const QMetaObject *mo = ptr->metaObject();
    QMetaMethod signal = signalId >= 0 ? mo->method(signalId) : QMetaMethod();
    if (signal.isValid()) {
        if (!ptr->isSignalConnected(signal))
            return conn->disconnectRelay(d->service, d->path, d->interface,
                                         ptr, signal);
    } else {
        // wildcard disconnecting, we need to figure out which of our signals are
        // no longer connected to anything
        int midx = QObject::staticMetaObject.methodCount();
        const int end = mo->methodCount();
        for ( ; midx < end; ++midx) {
            QMetaMethod mm = mo->method(midx);
            if (mm.methodType() == QMetaMethod::Signal && !ptr->isSignalConnected(mm))
                conn->disconnectRelay(d->service, d->path, d->interface, ptr, mm);
        }
    }
}
 
QVariant QDBusAbstractInterface::internalPropGet(const char *propname) const
{
    // assume this property exists and is readable
    // we're only called from generated code anyways
 
    return property(propname);
}
 
void QDBusAbstractInterface::internalPropSet(const char *propname, const QVariant &value)
{
    setProperty(propname, value);
}
 
QDBusMessage QDBusAbstractInterface::internalConstCall(QDBus::CallMode mode,
                                                       const QString &method,
                                                       const QList<QVariant> &args) const
{
    // ### move the code here, and make the other functions call this
    return const_cast<QDBusAbstractInterface*>(this)->callWithArgumentList(mode, method, args);
}
 
QDBusMessage QDBusAbstractInterface::doCall(QDBus::CallMode mode, const QString &method, const QVariant *args, size_t numArgs)
{
    QList<QVariant> list;
    list.reserve(int(numArgs));
    for (size_t i = 0; i < numArgs; ++i)
        list.append(args[i]);
    return callWithArgumentList(mode, method, list);
}
 
QDBusPendingCall QDBusAbstractInterface::doAsyncCall(const QString &method, const QVariant *args, size_t numArgs)
{
    QList<QVariant> list;
    list.reserve(int(numArgs));
    for (size_t i = 0; i < numArgs; ++i)
        list.append(args[i]);
    return asyncCallWithArgumentList(method, list);
}
 
QT_END_NAMESPACE
 
#endif // QT_NO_DBUS
 
#include "moc_qdbusabstractinterface.cpp"