qdbusinterface.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdbusinterface.h"
#include "qdbusinterface_p.h"
 
#include "qdbus_symbols_p.h"
#include <QtCore/qpointer.h>
#include <QtCore/qstringlist.h>
 
#include "qdbusmetatype_p.h"
#include "qdbusconnection_p.h"
 
#ifndef QT_NO_DBUS
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
static void copyArgument(void *to, int id, const QVariant &arg)
{
    if (id == arg.metaType().id()) {
        switch (id) {
        case QMetaType::Bool:
            *reinterpret_cast<bool *>(to) = arg.toBool();
            return;
 
        case QMetaType::UChar:
            *reinterpret_cast<uchar *>(to) = qvariant_cast<uchar>(arg);
            return;
 
        case QMetaType::Short:
            *reinterpret_cast<short *>(to) = qvariant_cast<short>(arg);
            return;
 
        case QMetaType::UShort:
            *reinterpret_cast<ushort *>(to) = qvariant_cast<ushort>(arg);
            return;
 
        case QMetaType::Int:
            *reinterpret_cast<int *>(to) = arg.toInt();
            return;
 
        case QMetaType::UInt:
            *reinterpret_cast<uint *>(to) = arg.toUInt();
            return;
 
        case QMetaType::LongLong:
            *reinterpret_cast<qlonglong *>(to) = arg.toLongLong();
            return;
 
        case QMetaType::ULongLong:
            *reinterpret_cast<qulonglong *>(to) = arg.toULongLong();
            return;
 
        case QMetaType::Double:
            *reinterpret_cast<double *>(to) = arg.toDouble();
            return;
 
        case QMetaType::QString:
            *reinterpret_cast<QString *>(to) = arg.toString();
            return;
 
        case QMetaType::QByteArray:
            *reinterpret_cast<QByteArray *>(to) = arg.toByteArray();
            return;
 
        case QMetaType::QStringList:
            *reinterpret_cast<QStringList *>(to) = arg.toStringList();
            return;
        }
 
        if (id == QDBusMetaTypeId::variant().id()) {
            *reinterpret_cast<QDBusVariant *>(to) = qvariant_cast<QDBusVariant>(arg);
            return;
        } else if (id == QDBusMetaTypeId::objectpath().id()) {
            *reinterpret_cast<QDBusObjectPath *>(to) = qvariant_cast<QDBusObjectPath>(arg);
            return;
        } else if (id == QDBusMetaTypeId::signature().id()) {
            *reinterpret_cast<QDBusSignature *>(to) = qvariant_cast<QDBusSignature>(arg);
            return;
        }
 
        // those above are the only types possible
        // the demarshaller code doesn't demarshall anything else
        qFatal("Found a decoded basic type in a D-Bus reply that shouldn't be there");
    }
 
    // if we got here, it's either an un-dermarshalled type or a mismatch
    if (arg.metaType() != QDBusMetaTypeId::argument()) {
        // it's a mismatch
        //qWarning?
        return;
    }
 
    // is this type registered?
    const char *userSignature = QDBusMetaType::typeToSignature(QMetaType(id));
    if (!userSignature || !*userSignature) {
        // type not registered
        //qWarning?
        return;
    }
 
    // is it the same signature?
    QDBusArgument dbarg = qvariant_cast<QDBusArgument>(arg);
    if (dbarg.currentSignature() != QLatin1StringView(userSignature)) {
        // not the same signature, another mismatch
        //qWarning?
        return;
    }
 
    // we can demarshall
    QDBusMetaType::demarshall(dbarg, QMetaType(id), to);
}
 
QDBusInterfacePrivate::QDBusInterfacePrivate(const QString &serv, const QString &p,
                                             const QString &iface, const QDBusConnection &con)
    : QDBusAbstractInterfacePrivate(serv, p, iface, con, true), metaObject(nullptr)
{
    // QDBusAbstractInterfacePrivate's constructor checked the parameters for us
    if (connection.isConnected()) {
        metaObject = connectionPrivate()->findMetaObject(service, path, interface, lastError);
 
        if (!metaObject) {
            // creation failed, somehow
            // most common causes are that the service doesn't exist or doesn't support introspection
            // those are not fatal errors, so we continue working
 
            if (!lastError.isValid())
                lastError = QDBusError(QDBusError::InternalError, "Unknown error"_L1);
        }
    }
}
 
QDBusInterfacePrivate::~QDBusInterfacePrivate()
{
    if (metaObject && !metaObject->cached)
        delete metaObject;
}
 
 
QDBusInterface::QDBusInterface(const QString &service, const QString &path, const QString &interface,
                               const QDBusConnection &connection, QObject *parent)
    : QDBusAbstractInterface(*new QDBusInterfacePrivate(service, path, interface, connection),
                             parent)
{
}
 
QDBusInterface::~QDBusInterface()
{
    // resources are freed in QDBusInterfacePrivate::~QDBusInterfacePrivate()
}
 
const QMetaObject *QDBusInterface::metaObject() const
{
    return d_func()->metaObject ? d_func()->metaObject : &QDBusAbstractInterface::staticMetaObject;
}
 
void *QDBusInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, "QDBusInterface"))
        return static_cast<void*>(const_cast<QDBusInterface*>(this));
    if (d_func()->interface.toLatin1() == _clname)
        return static_cast<void*>(const_cast<QDBusInterface*>(this));
    return QDBusAbstractInterface::qt_metacast(_clname);
}
 
int QDBusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0 || !d_func()->isValid || !d_func()->metaObject)
        return _id;
    return d_func()->metacall(_c, _id, _a);
}
 
int QDBusInterfacePrivate::metacall(QMetaObject::Call c, int id, void **argv)
{
    Q_Q(QDBusInterface);
 
    if (c == QMetaObject::InvokeMetaMethod) {
        int offset = metaObject->methodOffset();
        QMetaMethod mm = metaObject->method(id + offset);
 
        if (mm.methodType() == QMetaMethod::Signal) {
            // signal relay from D-Bus world to Qt world
            QMetaObject::activate(q, metaObject, id, argv);
 
        } else if (mm.methodType() == QMetaMethod::Slot || mm.methodType() == QMetaMethod::Method) {
            // method call relay from Qt world to D-Bus world
            // get D-Bus equivalent signature
            QString methodName = QString::fromLatin1(mm.name());
            const int *inputTypes = metaObject->inputTypesForMethod(id);
            int inputTypesCount = *inputTypes;
 
            // we will assume that the input arguments were passed correctly
            QVariantList args;
            args.reserve(inputTypesCount);
            int i = 1;
            for ( ; i <= inputTypesCount; ++i)
                args << QVariant(QMetaType(inputTypes[i]), argv[i]);
 
            // make the call
            QDBusMessage reply = q->callWithArgumentList(QDBus::Block, methodName, args);
 
            if (reply.type() == QDBusMessage::ReplyMessage) {
                // attempt to demarshall the return values
                args = reply.arguments();
                QVariantList::ConstIterator it = args.constBegin();
                const int *outputTypes = metaObject->outputTypesForMethod(id);
                int outputTypesCount = *outputTypes++;
 
                if (mm.returnType() != QMetaType::UnknownType && mm.returnType() != QMetaType::Void) {
                    // this method has a return type
                    if (argv[0] && it != args.constEnd())
                        copyArgument(argv[0], *outputTypes++, *it);
 
                    // skip this argument even if we didn't copy it
                    --outputTypesCount;
                    ++it;
                }
 
                for (int j = 0; j < outputTypesCount && it != args.constEnd(); ++i, ++j, ++it) {
                    copyArgument(argv[i], outputTypes[j], *it);
                }
            }
 
            // done
            lastError = QDBusError(reply);
            return -1;
        }
    }
    return id;
}
 
QT_END_NAMESPACE
 
#endif // QT_NO_DBUS