qdbuspendingcall.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 "qdbuspendingcall.h"
#include "qdbuspendingcall_p.h"
 
#include "qdbusconnection_p.h"
#include "qdbusmetatype_p.h"
#include "qdbusutil_p.h"
#include "qcoreapplication.h"
#include "qcoreevent.h"
#include <private/qobject_p.h>
#include <private/qlocking_p.h>
 
#ifndef QT_NO_DBUS
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
void QDBusPendingCallWatcherHelper::add(QDBusPendingCallWatcher *watcher)
{
    connect(this, SIGNAL(finished()), watcher, SLOT(_q_finished()), Qt::QueuedConnection);
}
 
QDBusPendingCallPrivate::~QDBusPendingCallPrivate()
{
    if (pending) {
        q_dbus_pending_call_cancel(pending);
        q_dbus_pending_call_unref(pending);
    }
    delete watcherHelper;
}
 
bool QDBusPendingCallPrivate::setReplyCallback(QObject *target, const char *member)
{
    receiver = target;
    metaTypes.clear();
    methodIdx = -1;
    if (!target)
        return true;;           // unsetting
 
    if (!member || !*member) {
        // would not be able to deliver a reply
        qWarning("QDBusPendingCall::setReplyCallback: error: cannot deliver a reply to %s::%s (%s)",
                 target ? target->metaObject()->className() : "(null)",
                 member ? member + 1 : "(null)",
                 target ? qPrintable(target->objectName()) : "no name");
        return false;
    }
 
    QString errorMsg;
    methodIdx = QDBusConnectionPrivate::findSlot(target, member + 1, metaTypes, errorMsg);
    if (methodIdx == -1) {
        QByteArray normalizedName = QMetaObject::normalizedSignature(member + 1);
        methodIdx = QDBusConnectionPrivate::findSlot(target, normalizedName, metaTypes, errorMsg);
    }
    if (methodIdx == -1) {
        // would not be able to deliver a reply
        qWarning("QDBusPendingCall::setReplyCallback: error: cannot deliver a reply to %s::%s (%s) "
                 "because %s",
                 target->metaObject()->className(), member + 1, qPrintable(target->objectName()),
                 qPrintable(errorMsg));
        return false;
    }
 
    // success
    // construct the expected signature
    int count = metaTypes.size() - 1;
    if (count == 1 && metaTypes.at(1) == QDBusMetaTypeId::message()) {
        // wildcard slot, can receive anything, so don't set the signature
        return true;
    }
 
    if (metaTypes.at(count) == QDBusMetaTypeId::message())
        --count;
 
    setMetaTypes(count, count ? metaTypes.constData() + 1 : nullptr);
    return true;
}
 
void QDBusPendingCallPrivate::setMetaTypes(int count, const QMetaType *types)
{
    if (count == 0) {
        expectedReplySignature = ""_L1; // not null
        return;
    }
 
    QByteArray sig;
    sig.reserve(count + count / 2);
    for (int i = 0; i < count; ++i) {
        const char *typeSig = QDBusMetaType::typeToSignature(types[i]);
        if (Q_UNLIKELY(!typeSig))
            qFatal("QDBusPendingReply: type %s is not registered with QtDBus", types[i].name());
        sig += typeSig;
    }
 
    expectedReplySignature = QString::fromLatin1(sig);
}
 
void QDBusPendingCallPrivate::checkReceivedSignature()
{
    // MUST BE CALLED WITH A LOCKED MUTEX!
 
    if (replyMessage.type() == QDBusMessage::InvalidMessage)
        return;                 // not yet finished - no message to
                                // validate against
    if (replyMessage.type() == QDBusMessage::ErrorMessage)
        return;                 // we don't have to check the signature of an error reply
 
    if (expectedReplySignature.isNull())
        return;                 // no signature to validate against
 
    // can't use startsWith here because a null string doesn't start or end with an empty string
    if (replyMessage.signature().indexOf(expectedReplySignature) != 0) {
        const auto errorMsg = "Unexpected reply signature: got \"%1\", expected \"%2\""_L1;
        replyMessage = QDBusMessage::createError(
            QDBusError::InvalidSignature,
            errorMsg.arg(replyMessage.signature(), expectedReplySignature));
 
    }
}
 
void QDBusPendingCallPrivate::waitForFinished()
{
    const auto locker = qt_scoped_lock(mutex);
 
    if (replyMessage.type() != QDBusMessage::InvalidMessage)
        return;                 // already finished
 
    waitForFinishedCondition.wait(&mutex);
}
 
QDBusPendingCall::QDBusPendingCall(const QDBusPendingCall &other)
    : d(other.d)
{
}
 
QDBusPendingCall::QDBusPendingCall(QDBusPendingCallPrivate *dd)
    : d(dd)
{
    if (dd) {
        bool r = dd->ref.deref();
        Q_ASSERT(r);
        Q_UNUSED(r);
    }
}
 
QDBusPendingCall::~QDBusPendingCall()
{
    // d deleted by QExplicitlySharedDataPointer
}
 
 
QDBusPendingCall &QDBusPendingCall::operator=(const QDBusPendingCall &other)
{
    d = other.d;
    return *this;
}
 
bool QDBusPendingCall::isFinished() const
{
    if (!d)
        return true; // considered finished
 
    const auto locker = qt_scoped_lock(d->mutex);
    return d->replyMessage.type() != QDBusMessage::InvalidMessage;
}
 
void QDBusPendingCall::waitForFinished()
{
    if (d) d->waitForFinished();
}
 
bool QDBusPendingCall::isValid() const
{
    if (!d)
        return false;
    const auto locker = qt_scoped_lock(d->mutex);
    return d->replyMessage.type() == QDBusMessage::ReplyMessage;
}
 
bool QDBusPendingCall::isError() const
{
    if (!d)
        return true; // considered finished and an error
    const auto locker = qt_scoped_lock(d->mutex);
    return d->replyMessage.type() == QDBusMessage::ErrorMessage;
}
 
QDBusError QDBusPendingCall::error() const
{
    if (d) {
        const auto locker = qt_scoped_lock(d->mutex);
        return QDBusError(d->replyMessage);
    }
 
    // not connected, return an error
    QDBusError err = QDBusError(QDBusError::Disconnected,
                                QDBusUtil::disconnectedErrorMessage());
    return err;
}
 
QDBusMessage QDBusPendingCall::reply() const
{
    if (!d)
        return QDBusMessage::createError(error());
    const auto locker = qt_scoped_lock(d->mutex);
    return d->replyMessage;
}
 
#if 0
/*
    Sets the slot \a member in object \a target to be called when the
    reply arrives. The slot's parameter list must match the reply
    message's arguments for it to be called.
 
    It may, optionally, contain a QDBusMessage final parameter. If it
    is present, the parameter will contain the reply message object.
 
    The callback will not be called if the reply is an error message.
 
    This function returns \c true if it could set the callback, false
    otherwise. It is not a guarantee that the callback will be
    called.
 
    \warning QDBusPendingCall only supports one callback per pending
             asynchronous call, even if multiple QDBusPendingCall
             objects are referencing the same pending call.
*/
bool QDBusPendingCall::setReplyCallback(QObject *target, const char *member)
{
    if (!d)
        return false;
 
    return d->setReplyCallback(target, member);
}
#endif
 
QDBusPendingCall QDBusPendingCall::fromError(const QDBusError &error)
{
    return fromCompletedCall(QDBusMessage::createError(error));
}
 
QDBusPendingCall QDBusPendingCall::fromCompletedCall(const QDBusMessage &msg)
{
    QDBusPendingCallPrivate *d = nullptr;
    if (msg.type() == QDBusMessage::ErrorMessage ||
        msg.type() == QDBusMessage::ReplyMessage) {
        d = new QDBusPendingCallPrivate(QDBusMessage(), nullptr);
        d->replyMessage = msg;
        d->ref.storeRelaxed(1);
    }
 
    return QDBusPendingCall(d);
}
 
 
class QDBusPendingCallWatcherPrivate: public QObjectPrivate
{
public:
    void _q_finished();
 
    Q_DECLARE_PUBLIC(QDBusPendingCallWatcher)
};
 
inline void QDBusPendingCallWatcherPrivate::_q_finished()
{
    Q_Q(QDBusPendingCallWatcher);
    emit q->finished(q);
}
 
QDBusPendingCallWatcher::QDBusPendingCallWatcher(const QDBusPendingCall &call, QObject *parent)
    : QObject(*new QDBusPendingCallWatcherPrivate, parent), QDBusPendingCall(call)
{
    if (d) {                    // QDBusPendingCall::d
        const auto locker = qt_scoped_lock(d->mutex);
        if (!d->watcherHelper) {
            d->watcherHelper = new QDBusPendingCallWatcherHelper;
            if (d->replyMessage.type() != QDBusMessage::InvalidMessage) {
                // cause a signal emission anyways
                QMetaObject::invokeMethod(d->watcherHelper,
                                          &QDBusPendingCallWatcherHelper::finished,
                                          Qt::QueuedConnection);
            }
        }
        d->watcherHelper->add(this);
    }
}
 
QDBusPendingCallWatcher::~QDBusPendingCallWatcher()
{
}
 
void QDBusPendingCallWatcher::waitForFinished()
{
    if (d) {
        d->waitForFinished();
 
        // our signals were queued, so deliver them
        QCoreApplication::sendPostedEvents(d->watcherHelper, QEvent::MetaCall);
        QCoreApplication::sendPostedEvents(this, QEvent::MetaCall);
    }
}
QT_END_NAMESPACE
 
#include "moc_qdbuspendingcall_p.cpp"
 
#endif // QT_NO_DBUS
 
#include "moc_qdbuspendingcall.cpp"