qdbusmessage.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 "qdbusmessage.h"
#include "qdbusmessage_p.h"
 
#include <qdebug.h>
#include <qstringlist.h>
 
#include "qdbus_symbols_p.h"
 
#include "qdbusargument_p.h"
#include "qdbuserror.h"
#include "qdbusmetatype.h"
#include "qdbusconnection_p.h"
#include "qdbusutil_p.h"
 
#ifndef QT_NO_DBUS
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
QT_IMPL_METATYPE_EXTERN(QDBusMessage)
 
static_assert(QDBusMessage::InvalidMessage == DBUS_MESSAGE_TYPE_INVALID);
static_assert(QDBusMessage::MethodCallMessage == DBUS_MESSAGE_TYPE_METHOD_CALL);
static_assert(QDBusMessage::ReplyMessage == DBUS_MESSAGE_TYPE_METHOD_RETURN);
static_assert(QDBusMessage::ErrorMessage == DBUS_MESSAGE_TYPE_ERROR);
static_assert(QDBusMessage::SignalMessage == DBUS_MESSAGE_TYPE_SIGNAL);
 
static inline const char *data(const QByteArray &arr)
{
    return arr.isEmpty() ? nullptr : arr.constData();
}
 
QDBusMessagePrivate::QDBusMessagePrivate()
    : localReply(nullptr), ref(1), type(QDBusMessage::InvalidMessage),
      delayedReply(false), parametersValidated(false),
      localMessage(false), autoStartService(true),
      interactiveAuthorizationAllowed(false), isReplyRequired(false)
{
}
 
QDBusMessagePrivate::~QDBusMessagePrivate()
{
    delete localReply;
}
 
void QDBusMessagePrivate::createResponseLink(const QDBusMessagePrivate *call)
{
    if (Q_UNLIKELY(call->type != QDBusMessage::MethodCallMessage)) {
        qWarning("QDBusMessage: replying to a message that isn't a method call");
        return;
    }
 
    if (call->localMessage) {
        localMessage = true;
        call->localReply = new QDBusMessage(*this); // keep an internal copy
    } else {
        serial = call->serial;
        service = call->service;
    }
 
    // the reply must have a serial or be a local-loop optimization
    Q_ASSERT(serial || localMessage);
}
 
QString QDBusMessage::errorMessage() const
{
    if (d_ptr->type == ErrorMessage) {
        if (!d_ptr->message.isEmpty())
           return d_ptr->message;
        if (!d_ptr->arguments.isEmpty())
            return d_ptr->arguments.at(0).toString();
    }
    return QString();
}
 
DBusMessage *QDBusMessagePrivate::toDBusMessage(const QDBusMessage &message, QDBusConnection::ConnectionCapabilities capabilities,
                                                QDBusError *error)
{
    if (!qdbus_loadLibDBus()) {
        *error = QDBusError(QDBusError::Failed, "Could not open lidbus-1 library"_L1);
        return nullptr;
    }
 
    DBusMessage *msg = nullptr;
    const QDBusMessagePrivate *d_ptr = message.d_ptr;
 
    switch (d_ptr->type) {
    case QDBusMessage::InvalidMessage:
        //qDebug() << "QDBusMessagePrivate::toDBusMessage" <<  "message is invalid";
        break;
    case QDBusMessage::MethodCallMessage:
        // only service and interface can be empty -> path and name must not be empty
        if (!d_ptr->parametersValidated) {
            if (!QDBusUtil::checkBusName(d_ptr->service, QDBusUtil::EmptyAllowed, error))
                return nullptr;
            if (!QDBusUtil::checkObjectPath(d_ptr->path, QDBusUtil::EmptyNotAllowed, error))
                return nullptr;
            if (!QDBusUtil::checkInterfaceName(d_ptr->interface, QDBusUtil::EmptyAllowed, error))
                return nullptr;
            if (!QDBusUtil::checkMemberName(d_ptr->name, QDBusUtil::EmptyNotAllowed, error, "method"))
                return nullptr;
        }
 
        msg = q_dbus_message_new_method_call(data(d_ptr->service.toUtf8()), d_ptr->path.toUtf8(),
                                             data(d_ptr->interface.toUtf8()), d_ptr->name.toUtf8());
        q_dbus_message_set_auto_start( msg, d_ptr->autoStartService );
        q_dbus_message_set_allow_interactive_authorization(msg, d_ptr->interactiveAuthorizationAllowed);
 
        break;
    case QDBusMessage::ReplyMessage:
        msg = q_dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
        if (!d_ptr->localMessage) {
            q_dbus_message_set_destination(msg, data(d_ptr->service.toUtf8()));
            q_dbus_message_set_reply_serial(msg, d_ptr->serial);
        }
        break;
    case QDBusMessage::ErrorMessage:
        // error name can't be empty
        if (!d_ptr->parametersValidated
            && !QDBusUtil::checkErrorName(d_ptr->name, QDBusUtil::EmptyNotAllowed, error))
            return nullptr;
 
        msg = q_dbus_message_new(DBUS_MESSAGE_TYPE_ERROR);
        q_dbus_message_set_error_name(msg, d_ptr->name.toUtf8());
        if (!d_ptr->localMessage) {
            q_dbus_message_set_destination(msg, data(d_ptr->service.toUtf8()));
            q_dbus_message_set_reply_serial(msg, d_ptr->serial);
        }
        break;
    case QDBusMessage::SignalMessage:
        // only the service name can be empty here
        if (!d_ptr->parametersValidated) {
            if (!QDBusUtil::checkBusName(d_ptr->service, QDBusUtil::EmptyAllowed, error))
                return nullptr;
            if (!QDBusUtil::checkObjectPath(d_ptr->path, QDBusUtil::EmptyNotAllowed, error))
                return nullptr;
            if (!QDBusUtil::checkInterfaceName(d_ptr->interface, QDBusUtil::EmptyAllowed, error))
                return nullptr;
            if (!QDBusUtil::checkMemberName(d_ptr->name, QDBusUtil::EmptyNotAllowed, error, "method"))
                return nullptr;
        }
 
        msg = q_dbus_message_new_signal(d_ptr->path.toUtf8(), d_ptr->interface.toUtf8(),
                                        d_ptr->name.toUtf8());
        q_dbus_message_set_destination(msg, data(d_ptr->service.toUtf8()));
        break;
    }
 
    // if we got here, the parameters validated
    // and since the message parameters cannot be changed once the message is created
    // we can record this fact
    d_ptr->parametersValidated = true;
 
    QDBusMarshaller marshaller(capabilities);
    q_dbus_message_iter_init_append(msg, &marshaller.iterator);
    if (!d_ptr->message.isEmpty())
        // prepend the error message
        marshaller.append(d_ptr->message);
    for (const QVariant &argument : std::as_const(d_ptr->arguments))
        marshaller.appendVariantInternal(argument);
 
    // check if everything is ok
    if (marshaller.ok)
        return msg;
 
    // not ok;
    q_dbus_message_unref(msg);
    *error = QDBusError(QDBusError::Failed, "Marshalling failed: "_L1 + marshaller.errorString);
    return nullptr;
}
 
/*
struct DBusMessage
{
    DBusAtomic refcount;
    DBusHeader header;
    DBusString body;
    char byte_order;
    unsigned int locked : 1;
DBUS_DISABLE_CHECKS
    unsigned int in_cache : 1;
#endif
    DBusList *size_counters;
    long size_counter_delta;
    dbus_uint32_t changed_stamp : CHANGED_STAMP_BITS;
    DBusDataSlotList slot_list;
#ifndef DBUS_DISABLE_CHECKS
    int generation;
#endif
};
*/
 
QDBusMessage QDBusMessagePrivate::fromDBusMessage(DBusMessage *dmsg, QDBusConnection::ConnectionCapabilities capabilities)
{
    QDBusMessage message;
    if (!dmsg)
        return message;
 
    message.d_ptr->type = QDBusMessage::MessageType(q_dbus_message_get_type(dmsg));
    message.d_ptr->serial = q_dbus_message_get_serial(dmsg);
    message.d_ptr->path = QString::fromUtf8(q_dbus_message_get_path(dmsg));
    message.d_ptr->interface = QString::fromUtf8(q_dbus_message_get_interface(dmsg));
    message.d_ptr->name = message.d_ptr->type == DBUS_MESSAGE_TYPE_ERROR ?
                      QString::fromUtf8(q_dbus_message_get_error_name(dmsg)) :
                      QString::fromUtf8(q_dbus_message_get_member(dmsg));
    message.d_ptr->service = QString::fromUtf8(q_dbus_message_get_sender(dmsg));
    message.d_ptr->signature = QString::fromUtf8(q_dbus_message_get_signature(dmsg));
    message.d_ptr->interactiveAuthorizationAllowed = q_dbus_message_get_allow_interactive_authorization(dmsg);
    message.d_ptr->isReplyRequired = !q_dbus_message_get_no_reply(dmsg);
 
    QDBusDemarshaller demarshaller(capabilities);
    demarshaller.message = q_dbus_message_ref(dmsg);
    if (q_dbus_message_iter_init(demarshaller.message, &demarshaller.iterator))
        while (!demarshaller.atEnd())
            message << demarshaller.toVariantInternal();
    return message;
}
 
bool QDBusMessagePrivate::isLocal(const QDBusMessage &message)
{
    return message.d_ptr->localMessage;
}
 
QDBusMessage QDBusMessagePrivate::makeLocal(const QDBusConnectionPrivate &conn,
                                            const QDBusMessage &asSent)
{
    // simulate the message being sent to the bus and then received back
    // the only field that the bus sets when delivering the message
    // (as opposed to the message as we send it), is the sender
    // so we simply set the sender to our unique name
 
    // determine if we are carrying any complex types
    QString computedSignature;
    for (const QVariant &argument : std::as_const(asSent.d_ptr->arguments)) {
        QMetaType id = argument.metaType();
        const char *signature = QDBusMetaType::typeToSignature(id);
        if ((id.id() != QMetaType::QStringList && id.id() != QMetaType::QByteArray &&
             qstrlen(signature) != 1) || id == QMetaType::fromType<QDBusVariant>()) {
            // yes, we are
            // we must marshall and demarshall again so as to create QDBusArgument
            // entries for the complex types
            QDBusError error;
            DBusMessage *message = toDBusMessage(asSent, conn.connectionCapabilities(), &error);
            if (!message) {
                // failed to marshall, so it's a call error
                return QDBusMessage::createError(error);
            }
 
            q_dbus_message_set_sender(message, conn.baseService.toUtf8());
 
            QDBusMessage retval = fromDBusMessage(message, conn.connectionCapabilities());
            retval.d_ptr->localMessage = true;
            q_dbus_message_unref(message);
            if (retval.d_ptr->service.isEmpty())
                retval.d_ptr->service = conn.baseService;
            return retval;
        } else {
            computedSignature += QLatin1StringView(signature);
        }
    }
 
    // no complex types seen
    // optimize by using the variant list itself
    QDBusMessage retval;
    QDBusMessagePrivate *d = retval.d_ptr;
    d->arguments = asSent.d_ptr->arguments;
    d->path = asSent.d_ptr->path;
    d->interface = asSent.d_ptr->interface;
    d->name = asSent.d_ptr->name;
    d->message = asSent.d_ptr->message;
    d->type = asSent.d_ptr->type;
 
    d->service = conn.baseService;
    d->signature = computedSignature;
    d->localMessage = true;
    return retval;
}
 
QDBusMessage QDBusMessagePrivate::makeLocalReply(const QDBusConnectionPrivate &conn,
                                                 const QDBusMessage &callMsg)
{
    // simulate the reply (return or error) message being sent to the bus and
    // then received back.
    if (callMsg.d_ptr->localReply)
        return makeLocal(conn, *callMsg.d_ptr->localReply);
    return QDBusMessage();      // failed
}
 
QDBusMessage QDBusMessage::createSignal(const QString &path, const QString &interface,
                                        const QString &name)
{
    QDBusMessage message;
    message.d_ptr->type = SignalMessage;
    message.d_ptr->path = path;
    message.d_ptr->interface = interface;
    message.d_ptr->name = name;
 
    return message;
}
 
QDBusMessage QDBusMessage::createTargetedSignal(const QString &service, const QString &path,
                                                const QString &interface, const QString &name)
{
    QDBusMessage message;
    message.d_ptr->type = SignalMessage;
    message.d_ptr->service = service;
    message.d_ptr->path = path;
    message.d_ptr->interface = interface;
    message.d_ptr->name = name;
 
    return message;
}
 
QDBusMessage QDBusMessage::createMethodCall(const QString &service, const QString &path,
                                            const QString &interface, const QString &method)
{
    QDBusMessage message;
    message.d_ptr->type = MethodCallMessage;
    message.d_ptr->service = service;
    message.d_ptr->path = path;
    message.d_ptr->interface = interface;
    message.d_ptr->name = method;
    message.d_ptr->isReplyRequired = true;
 
    return message;
}
 
QDBusMessage QDBusMessage::createError(const QString &name, const QString &msg)
{
    QDBusMessage error;
    error.d_ptr->type = ErrorMessage;
    error.d_ptr->name = name;
    error.d_ptr->message = msg;
 
    return error;
}
 
QDBusMessage QDBusMessage::createReply(const QVariantList &arguments) const
{
    QDBusMessage reply;
    reply.setArguments(arguments);
    reply.d_ptr->type = ReplyMessage;
    reply.d_ptr->createResponseLink(d_ptr);
    return reply;
}
 
QDBusMessage QDBusMessage::createErrorReply(const QString &name, const QString &msg) const
{
    QDBusMessage reply = QDBusMessage::createError(name, msg);
    reply.d_ptr->createResponseLink(d_ptr);
    return reply;
}
 
QDBusMessage QDBusMessage::createReply(const QVariant &argument) const
{
    return createReply(QList{argument});
}
 
QDBusMessage QDBusMessage::createErrorReply(QDBusError::ErrorType atype, const QString &amsg) const
{
    QDBusMessage msg = createErrorReply(QDBusError::errorString(atype), amsg);
    msg.d_ptr->parametersValidated = true;
    return msg;
}
 
 
QDBusMessage::QDBusMessage()
{
    d_ptr = new QDBusMessagePrivate;
}
 
QDBusMessage::QDBusMessage(const QDBusMessage &other)
{
    d_ptr = other.d_ptr;
    d_ptr->ref.ref();
}
 
QDBusMessage::~QDBusMessage()
{
    if (!d_ptr->ref.deref())
        delete d_ptr;
}
 
QDBusMessage &QDBusMessage::operator=(const QDBusMessage &other)
{
    qAtomicAssign(d_ptr, other.d_ptr);
    return *this;
}
 
QString QDBusMessage::service() const
{
    if (d_ptr->type == ErrorMessage || d_ptr->type == ReplyMessage)
        return QString();   // d_ptr->service holds the destination
    return d_ptr->service;
}
 
QString QDBusMessage::path() const
{
    return d_ptr->path;
}
 
QString QDBusMessage::interface() const
{
    return d_ptr->interface;
}
 
QString QDBusMessage::member() const
{
    if (d_ptr->type != ErrorMessage)
        return d_ptr->name;
    return QString();
}
 
QString QDBusMessage::errorName() const
{
    if (d_ptr->type == ErrorMessage)
        return d_ptr->name;
    return QString();
}
 
QString QDBusMessage::signature() const
{
    return d_ptr->signature;
}
 
bool QDBusMessage::isReplyRequired() const
{
    // Only method calls can have replies
    if (d_ptr->type != QDBusMessage::MethodCallMessage)
        return false;
 
    if (d_ptr->localMessage) // if it's a local message, reply is required
        return true;
    return d_ptr->isReplyRequired;
}
 
void QDBusMessage::setDelayedReply(bool enable) const
{
    d_ptr->delayedReply = enable;
}
 
bool QDBusMessage::isDelayedReply() const
{
    return d_ptr->delayedReply;
}
 
void QDBusMessage::setAutoStartService(bool enable)
{
    d_ptr->autoStartService = enable;
}
 
bool QDBusMessage::autoStartService() const
{
    return d_ptr->autoStartService;
}
 
void QDBusMessage::setInteractiveAuthorizationAllowed(bool enable)
{
    d_ptr->interactiveAuthorizationAllowed = enable;
}
 
bool QDBusMessage::isInteractiveAuthorizationAllowed() const
{
    return d_ptr->interactiveAuthorizationAllowed;
}
 
void QDBusMessage::setArguments(const QList<QVariant> &arguments)
{
    d_ptr->arguments = arguments;
}
 
QList<QVariant> QDBusMessage::arguments() const
{
    return d_ptr->arguments;
}
 
QDBusMessage &QDBusMessage::operator<<(const QVariant &arg)
{
    d_ptr->arguments.append(arg);
    return *this;
}
 
QDBusMessage::QDBusMessage(QDBusMessagePrivate &dd)
    : d_ptr(&dd)
{
    d_ptr->ref.ref();
}
 
QDBusMessage::MessageType QDBusMessage::type() const
{
    switch (d_ptr->type) {
    case DBUS_MESSAGE_TYPE_METHOD_CALL:
        return MethodCallMessage;
    case DBUS_MESSAGE_TYPE_METHOD_RETURN:
        return ReplyMessage;
    case DBUS_MESSAGE_TYPE_ERROR:
        return ErrorMessage;
    case DBUS_MESSAGE_TYPE_SIGNAL:
        return SignalMessage;
    default:
        break;
    }
    return InvalidMessage;
}
 
#ifndef QT_NO_DEBUG_STREAM
static QDebug operator<<(QDebug dbg, QDBusMessage::MessageType t)
{
    switch (t)
    {
    case QDBusMessage::MethodCallMessage:
        return dbg << "MethodCall";
    case QDBusMessage::ReplyMessage:
        return dbg << "MethodReturn";
    case QDBusMessage::SignalMessage:
        return dbg << "Signal";
    case QDBusMessage::ErrorMessage:
        return dbg << "Error";
    default:
        return dbg << "Invalid";
    }
}
 
static void debugVariantList(QDebug dbg, const QVariantList &list)
{
    bool first = true;
    for (const QVariant &elem : list) {
        if (!first)
            dbg.nospace() << ", ";
        dbg.nospace() << qPrintable(QDBusUtil::argumentToString(elem));
        first = false;
    }
}
 
QDebug operator<<(QDebug dbg, const QDBusMessage &msg)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QDBusMessage(type=" << msg.type()
                  << ", service=" << msg.service();
    if (msg.type() == QDBusMessage::MethodCallMessage ||
        msg.type() == QDBusMessage::SignalMessage)
        dbg.nospace() << ", path=" << msg.path()
                      << ", interface=" << msg.interface()
                      << ", member=" << msg.member();
    if (msg.type() == QDBusMessage::ErrorMessage)
        dbg.nospace() << ", error name=" << msg.errorName()
                      << ", error message=" << msg.errorMessage();
    dbg.nospace() << ", signature=" << msg.signature()
                  << ", contents=(";
    debugVariantList(dbg, msg.arguments());
    dbg.nospace() << ") )";
    return dbg;
}
#endif
 
QT_END_NAMESPACE
 
#endif // QT_NO_DBUS