// 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

// Qt-Security score:significant reason:default

#include "qdbusintegrator_p.h"

#include <qcoreapplication.h>

#include <qelapsedtimer.h>

#include <private/qlatch_p.h>

#include <qloggingcategory.h>

#include <qmetaobject.h>

#include <qobject.h>

#include <qsocketnotifier.h>

#include <qstringlist.h>

#include <qthread.h>

#include <private/qlocking_p.h>

#include <QtCore/qset.h>

#include "qdbusargument.h"

#include "qdbusconnection_p.h"

#include "qdbusconnectionmanager_p.h"

#include "qdbusinterface_p.h"

#include "qdbusmessage.h"

#include "qdbusmetatype.h"

#include "qdbusmetatype_p.h"

#include "qdbusabstractadaptor.h"

#include "qdbusabstractadaptor_p.h"

#include "qdbusserver.h"

#include "qdbusutil_p.h"

#include "qdbusvirtualobject.h"

#include "qdbusmessage_p.h"

#include "qdbuscontext_p.h"

#include "qdbuspendingcall_p.h"

#include "qdbusthreaddebug_p.h"

#include <algorithm>

#ifdef interface

#undef interface

#endif

#ifndef QT_NO_DBUS

QT_BEGIN_NAMESPACE

using namespace Qt::StringLiterals;

QT_IMPL_METATYPE_EXTERN(QDBusSlotCache)

// used with dbus_server_allocate_data_slot

static dbus_int32_t server_slot = -1;

Q_STATIC_LOGGING_CATEGORY(dbusIntegration, "qt.dbus.integration", QtWarningMsg)

Q_CONSTINIT static QBasicAtomicInt isDebugging = Q_BASIC_ATOMIC_INITIALIZER(-1);

#define qDBusDebug              if (::isDebugging.loadRelaxed() == 0); else qDebug

static inline QDebug operator<<(QDebug dbg, const QThread *th)

{

    QDebugStateSaver saver(dbg);

    dbg.nospace() << "QThread(ptr=" << (const void*)th;

    if (th && !th->objectName().isEmpty())

        dbg.nospace() << ", name=" << th->objectName();

    else if (th)

        dbg.nospace() << ", name=" << th->metaObject()->className();

    dbg.nospace() << ')';

    return dbg;

}

#if QDBUS_THREAD_DEBUG

static inline QDebug operator<<(QDebug dbg, const QDBusConnectionPrivate *conn)

{

    QDebugStateSaver saver(dbg);

    dbg.nospace() << "QDBusConnection("

                  << "ptr=" << (const void*)conn

                  << ", name=" << conn->name

                  << ", baseService=" << conn->baseService

                  << ')';

    return dbg;

}

void qdbusDefaultThreadDebug(int action, int condition, QDBusConnectionPrivate *conn)

{

    qDBusDebug() << QThread::currentThread()

                 << "Qt D-Bus threading action" << action

                 << (condition == QDBusLockerBase::BeforeLock ? "before lock" :

                     condition == QDBusLockerBase::AfterLock ? "after lock" :

                     condition == QDBusLockerBase::BeforeUnlock ? "before unlock" :

                     condition == QDBusLockerBase::AfterUnlock ? "after unlock" :

                     condition == QDBusLockerBase::BeforePost ? "before event posting" :

                     condition == QDBusLockerBase::AfterPost ? "after event posting" :

                     condition == QDBusLockerBase::BeforeDeliver ? "before event delivery" :

                     condition == QDBusLockerBase::AfterDeliver ? "after event delivery" :

                     condition == QDBusLockerBase::BeforeAcquire ? "before acquire" :

                     condition == QDBusLockerBase::AfterAcquire ? "after acquire" :

                     condition == QDBusLockerBase::BeforeRelease ? "before release" :

                     condition == QDBusLockerBase::AfterRelease ? "after release" :

                     "condition unknown")

                 << "in connection" << conn;

}

qdbusThreadDebugFunc qdbusThreadDebug = nullptr;

#endif

class QDBusSpyHookList

{

public:

    void add(QDBusSpyCallEvent::Hook hook)

    {

        const auto locker = qt_scoped_lock(lock);

        list.append(hook);

    }

    void invoke(const QDBusMessage &msg)

    {

        // Create a copy of the hook list here, so that the hooks can be called

        // without holding the lock.

        QList<QDBusSpyCallEvent::Hook> hookListCopy;

        {

            const auto locker = qt_scoped_lock(lock);

            hookListCopy = list;

        }

        for (auto hook : std::as_const(hookListCopy))

            hook(msg);

    }

private:

    QBasicMutex lock;

    QList<QDBusSpyCallEvent::Hook> list;

};

Q_GLOBAL_STATIC(QDBusSpyHookList, qDBusSpyHookList)

extern "C" {

    // libdbus-1 callbacks

static dbus_bool_t qDBusAddTimeout(DBusTimeout *timeout, void *data)

{

    Q_ASSERT(timeout);

    Q_ASSERT(data);

  //  qDebug("addTimeout %d", q_dbus_timeout_get_interval(timeout));

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    Q_ASSERT(QThread::currentThread() == d->thread());

    // we may get called from qDBusToggleTimeout

    if (Q_UNLIKELY(!q_dbus_timeout_get_enabled(timeout)))

        return false;

    Q_ASSERT(d->timeouts.key(timeout, 0) == 0);

    using namespace std::chrono_literals;

    int timerId = d->startTimer(q_dbus_timeout_get_interval(timeout) * 1ms); // no overflow possible

    if (!timerId)

        return false;

    d->timeouts[timerId] = timeout;

    return true;

}

static void qDBusRemoveTimeout(DBusTimeout *timeout, void *data)

{

    Q_ASSERT(timeout);

    Q_ASSERT(data);

  //  qDebug("removeTimeout");

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    Q_ASSERT(QThread::currentThread() == d->thread());

    QDBusConnectionPrivate::TimeoutHash::iterator it = d->timeouts.begin();

    while (it != d->timeouts.end()) {

        if (it.value() == timeout) {

            d->killTimer(it.key());

            it = d->timeouts.erase(it);

            break;

        } else {

            ++it;

        }

    }

}

static void qDBusToggleTimeout(DBusTimeout *timeout, void *data)

{

    Q_ASSERT(timeout);

    Q_ASSERT(data);

    //qDebug("ToggleTimeout");

    qDBusRemoveTimeout(timeout, data);

    qDBusAddTimeout(timeout, data);

}

static dbus_bool_t qDBusAddWatch(DBusWatch *watch, void *data)

{

    Q_ASSERT(watch);

    Q_ASSERT(data);

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    Q_ASSERT(QThread::currentThread() == d->thread());

    int flags = q_dbus_watch_get_flags(watch);

    int fd = q_dbus_watch_get_unix_fd(watch);

    QDBusConnectionPrivate::Watcher watcher;

    if (flags & DBUS_WATCH_READABLE) {

        //qDebug("addReadWatch %d", fd);

        watcher.watch = watch;

        watcher.read = new QSocketNotifier(fd, QSocketNotifier::Read, d);

        watcher.read->setEnabled(q_dbus_watch_get_enabled(watch));

        d->connect(watcher.read, &QSocketNotifier::activated, d, &QDBusConnectionPrivate::socketRead);

    }

    if (flags & DBUS_WATCH_WRITABLE) {

        //qDebug("addWriteWatch %d", fd);

        watcher.watch = watch;

        watcher.write = new QSocketNotifier(fd, QSocketNotifier::Write, d);

        watcher.write->setEnabled(q_dbus_watch_get_enabled(watch));

        d->connect(watcher.write, &QSocketNotifier::activated, d, &QDBusConnectionPrivate::socketWrite);

    }

    d->watchers.insert(fd, watcher);

    return true;

}

static void qDBusRemoveWatch(DBusWatch *watch, void *data)

{

    Q_ASSERT(watch);

    Q_ASSERT(data);

    //qDebug("remove watch");

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    Q_ASSERT(QThread::currentThread() == d->thread());

    int fd = q_dbus_watch_get_unix_fd(watch);

    QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd);

    while (i != d->watchers.end() && i.key() == fd) {

        if (i.value().watch == watch) {

            delete i.value().read;

            delete i.value().write;

            i = d->watchers.erase(i);

        } else {

            ++i;

        }

    }

}

static void qDBusToggleWatch(DBusWatch *watch, void *data)

{

    Q_ASSERT(watch);

    Q_ASSERT(data);

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    Q_ASSERT(QThread::currentThread() == d->thread());

    int fd = q_dbus_watch_get_unix_fd(watch);

    QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd);

    while (i != d->watchers.end() && i.key() == fd) {

        if (i.value().watch == watch) {

            bool enabled = q_dbus_watch_get_enabled(watch);

            int flags = q_dbus_watch_get_flags(watch);

            //qDebug("toggle watch %d to %d (write: %d, read: %d)", q_dbus_watch_get_fd(watch), enabled, flags & DBUS_WATCH_WRITABLE, flags & DBUS_WATCH_READABLE);

            if (flags & DBUS_WATCH_READABLE && i.value().read)

                i.value().read->setEnabled(enabled);

            if (flags & DBUS_WATCH_WRITABLE && i.value().write)

                i.value().write->setEnabled(enabled);

            return;

        }

        ++i;

    }

}

static void qDBusUpdateDispatchStatus(DBusConnection *connection, DBusDispatchStatus new_status, void *data)

{

    Q_ASSERT(connection);

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    if (new_status == DBUS_DISPATCH_DATA_REMAINS)

        emit d->dispatchStatusChanged();

}

static void qDBusNewConnection(DBusServer *server, DBusConnection *connection, void *data)

{

    // ### We may want to separate the server from the QDBusConnectionPrivate

    Q_ASSERT(server);

    Q_ASSERT(connection);

    Q_ASSERT(data);

    auto *manager = QDBusConnectionManager::instance();

    if (!manager)

        return;

    // keep the connection alive

    q_dbus_connection_ref(connection);

    QDBusConnectionPrivate *serverConnection = static_cast<QDBusConnectionPrivate *>(data);

    // allow anonymous authentication

    if (serverConnection->anonymousAuthenticationAllowed)

        q_dbus_connection_set_allow_anonymous(connection, true);

    QDBusConnectionPrivate *newConnection = new QDBusConnectionPrivate;

    manager->addConnection(

            "QDBusServer-"_L1 + QString::number(reinterpret_cast<qulonglong>(newConnection), 16),

            newConnection);

    {

        QWriteLocker locker(&serverConnection->lock);

        serverConnection->serverConnectionNames << newConnection->name;

    }

    // setPeer does the error handling for us

    QDBusErrorInternal error;

    newConnection->setPeer(connection, error);

    newConnection->setDispatchEnabled(false);

    QReadLocker serverLock(&serverConnection->lock);

    if (!serverConnection->serverObject)

        return;

    // this is a queued connection and will resume in the QDBusServer's thread

    QMetaObject::invokeMethod(serverConnection->serverObject, &QDBusServer::newConnection,

                              Qt::QueuedConnection, QDBusConnectionPrivate::q(newConnection));

    // we've disabled dispatching of events, so now we post an event to the

    // QDBusServer's thread in order to enable it after the

    // QDBusServer::newConnection() signal has been received by the

    // application's code

    newConnection->enableDispatchDelayed(serverConnection->serverObject);

}

} // extern "C"

static QByteArray buildMatchRule(const QString &service,

                                 const QString &objectPath, const QString &interface,

                                 const QString &member, const QDBusConnectionPrivate::ArgMatchRules &argMatch, const QString & /*signature*/)

{

    QString result;

    result += "type='signal',"_L1;

    const auto keyValue = "%1='%2',"_L1;

    if (!service.isEmpty())

        result += keyValue.arg("sender"_L1, service);

    if (!objectPath.isEmpty())

        result += keyValue.arg("path"_L1, objectPath);

    if (!interface.isEmpty())

        result += keyValue.arg("interface"_L1, interface);

    if (!member.isEmpty())

        result += keyValue.arg("member"_L1, member);

    // add the argument string-matching now

    if (!argMatch.args.isEmpty()) {

        const QString keyValue = "arg%1='%2',"_L1;

        for (int i = 0; i < argMatch.args.size(); ++i)

            if (!argMatch.args.at(i).isNull())

                result += keyValue.arg(i).arg(argMatch.args.at(i));

    }

    if (!argMatch.arg0namespace.isEmpty()) {

        result += "arg0namespace='%1',"_L1.arg(argMatch.arg0namespace);

    }

    result.chop(1);             // remove ending comma

    return result.toLatin1();

}

static bool findObject(const QDBusConnectionPrivate::ObjectTreeNode *root,

                       const QString &fullpath, int &usedLength,

                       QDBusConnectionPrivate::ObjectTreeNode &result)

{

    if (!fullpath.compare("/"_L1) && root->obj) {

        usedLength = 1;

        result = *root;

        return root;

    }

    int start = 0;

    int length = fullpath.size();

    if (fullpath.at(0) == u'/')

        start = 1;

    // walk the object tree

    const QDBusConnectionPrivate::ObjectTreeNode *node = root;

    while (start < length && node) {

        if (node->flags & QDBusConnection::ExportChildObjects)

            break;

        if ((node->flags & QDBusConnectionPrivate::VirtualObject) && (node->flags & QDBusConnection::SubPath))

            break;

        int end = fullpath.indexOf(u'/', start);

        end = (end == -1 ? length : end);

        QStringView pathComponent = QStringView{fullpath}.mid(start, end - start);

        QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it =

            std::lower_bound(node->children.constBegin(), node->children.constEnd(), pathComponent);

        if (it != node->children.constEnd() && it->name == pathComponent)

            // match

            node = &(*it);

        else

            node = nullptr;

        start = end + 1;

    }

    // found our object

    usedLength = (start > length ? length : start);

    if (node) {

        if (node->obj || !node->children.isEmpty())

            result = *node;

        else

            // there really is no object here

            // we're just looking at an unused space in the QList

            node = nullptr;

    }

    return node;

}

static QObject *findChildObject(const QDBusConnectionPrivate::ObjectTreeNode *root,

                                const QString &fullpath, int start)

{

    int length = fullpath.size();

    // any object in the tree can tell us to switch to its own object tree:

    const QDBusConnectionPrivate::ObjectTreeNode *node = root;

    if (node && node->flags & QDBusConnection::ExportChildObjects) {

        QObject *obj = node->obj;

        while (obj) {

            if (start >= length)

                // we're at the correct level

                return obj;

            int pos = fullpath.indexOf(u'/', start);

            pos = (pos == -1 ? length : pos);

            auto pathComponent = QStringView{fullpath}.mid(start, pos - start);

            // find a child with the proper name

            QObject *next = nullptr;

            for (QObject *child : std::as_const(obj->children())) {

                if (child->objectName() == pathComponent) {

                    next = child;

                    break;

                }

            }

            if (!next)

                break;

            obj = next;

            start = pos + 1;

        }

    }

    // object not found

    return nullptr;

}

static QDBusConnectionPrivate::ArgMatchRules matchArgsForService(const QString &service, QDBusServiceWatcher::WatchMode mode)

{

    QDBusConnectionPrivate::ArgMatchRules matchArgs;

    if (service.endsWith(u'*')) {

        matchArgs.arg0namespace = service.chopped(1);

        matchArgs.args << QString();

    }

    else

        matchArgs.args << service;

    switch (mode) {

    case QDBusServiceWatcher::WatchForOwnerChange:

        break;

    case QDBusServiceWatcher::WatchForRegistration:

        matchArgs.args << QString::fromLatin1("", 0);

        break;

    case QDBusServiceWatcher::WatchForUnregistration:

        matchArgs.args << QString() << QString::fromLatin1("", 0);

        break;

    }

    return matchArgs;

}

extern Q_DBUS_EXPORT void qDBusAddSpyHook(QDBusSpyCallEvent::Hook);

void qDBusAddSpyHook(QDBusSpyCallEvent::Hook hook)

{

    auto *hooks = qDBusSpyHookList();

    if (!hooks)

        return;

    hooks->add(hook);

}

QDBusSpyCallEvent::~QDBusSpyCallEvent()

{

    // Reinsert the message into the processing queue for the connection.

    // This is done in the destructor so the message is reinserted even if

    // QCoreApplication is destroyed.

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(const_cast<QObject *>(sender()));

    qDBusDebug() << d << "message spies done for" << msg;

    emit d->spyHooksFinished(msg);

}

void QDBusSpyCallEvent::placeMetaCall(QObject *)

{

    invokeSpyHooks(msg);

}

inline void QDBusSpyCallEvent::invokeSpyHooks(const QDBusMessage &msg)

{

    if (!qDBusSpyHookList.exists())

        return;

    qDBusSpyHookList->invoke(msg);

}

extern "C" {

static DBusHandlerResult

qDBusSignalFilter(DBusConnection *connection, DBusMessage *message, void *data)

{

    Q_ASSERT(data);

    Q_UNUSED(connection);

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    if (d->mode == QDBusConnectionPrivate::InvalidMode)

        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(message, d->connectionCapabilities());

    qDBusDebug() << d << "got message (signal):" << amsg;

    return d->handleMessage(amsg) ?

        DBUS_HANDLER_RESULT_HANDLED :

        DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

}

}

bool QDBusConnectionPrivate::handleMessage(const QDBusMessage &amsg)

{

    if (!ref.loadRelaxed())

        return false;

    // local message are always delivered, regardless of filtering

    // or whether the dispatcher is enabled

    bool isLocal = QDBusMessagePrivate::isLocal(amsg);

    if (!dispatchEnabled && !isLocal) {

        // queue messages only, we'll handle them later

        qDBusDebug() << this << "delivery is suspended";

        pendingMessages << amsg;

        return amsg.type() == QDBusMessage::MethodCallMessage;

    }

    switch (amsg.type()) {

    case QDBusMessage::SignalMessage:

        handleSignal(amsg);

        // if there are any other filters in this DBusConnection,

        // let them see the signal too

        return false;

    case QDBusMessage::MethodCallMessage:

        // run it through the spy filters (if any) before the regular processing:

        // a) if it's a local message, we're in the caller's thread, so invoke the filter directly

        // b) if it's an external message, post to the main thread

        if (Q_UNLIKELY(qDBusSpyHookList.exists()) && QCoreApplication::instanceExists()) {

            if (isLocal) {

                Q_ASSERT(QThread::currentThread() != thread());

                qDBusDebug() << this << "invoking message spies directly";

                QDBusSpyCallEvent::invokeSpyHooks(amsg);

            } else {

                qDBusDebug() << this << "invoking message spies via event";

                QCoreApplication::postEvent(

                        qApp, new QDBusSpyCallEvent(this, QDBusConnection(this), amsg));

                // we'll be called back, so return

                return true;

            }

        }

        handleObjectCall(amsg);

        return true;

    case QDBusMessage::ReplyMessage:

    case QDBusMessage::ErrorMessage:

    case QDBusMessage::InvalidMessage:

        return false;           // we don't handle those here

    }

    return false;

}

static void huntAndDestroy(QObject *needle, QDBusConnectionPrivate::ObjectTreeNode &haystack)

{

    for (QDBusConnectionPrivate::ObjectTreeNode &node : haystack.children)

        huntAndDestroy(needle, node);

    auto isInactive = [](const QDBusConnectionPrivate::ObjectTreeNode &node) { return !node.isActive(); };

    haystack.children.removeIf(isInactive);

    if (needle == haystack.obj) {

        haystack.obj = nullptr;

        haystack.flags = {};

    }

}

static void huntAndUnregister(const QList<QStringView> &pathComponents, int i,

                              QDBusConnection::UnregisterMode mode,

                              QDBusConnectionPrivate::ObjectTreeNode *node)

{

    if (pathComponents.size() == i) {

        // found it

        node->obj = nullptr;

        node->flags = {};

        if (mode == QDBusConnection::UnregisterTree) {

            // clear the sub-tree as well

            node->children.clear();  // can't disconnect the objects because we really don't know if they can

                            // be found somewhere else in the path too

        }

    } else {

        // keep going

        QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator end = node->children.end();

        QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator it =

            std::lower_bound(node->children.begin(), end, pathComponents.at(i));

        if (it == end || it->name != pathComponents.at(i))

            return;              // node not found

        huntAndUnregister(pathComponents, i + 1, mode, &(*it));

        if (!it->isActive())

            node->children.erase(it);

    }

}

static void huntAndEmit(DBusConnection *connection, DBusMessage *msg,

                        QObject *needle, const QDBusConnectionPrivate::ObjectTreeNode &haystack,

                        bool isScriptable, bool isAdaptor, const QString &path = QString())

{

    for (const QDBusConnectionPrivate::ObjectTreeNode &node : std::as_const(haystack.children)) {

        if (node.isActive()) {

            huntAndEmit(connection, msg, needle, node, isScriptable, isAdaptor,

                        path + u'/' + node.name);

        }

    }

    if (needle == haystack.obj) {

        // is this a signal we should relay?

        if (isAdaptor && (haystack.flags & QDBusConnection::ExportAdaptors) == 0)

            return;             // no: it comes from an adaptor and we're not exporting adaptors

        else if (!isAdaptor) {

            int mask = isScriptable

                       ? QDBusConnection::ExportScriptableSignals

                       : QDBusConnection::ExportNonScriptableSignals;

            if ((haystack.flags & mask) == 0)

                return;         // signal was not exported

        }

        QByteArray p = path.toLatin1();

        if (p.isEmpty())

            p = "/";

        qDBusDebug() << QThread::currentThread() << "emitting signal at" << p;

        DBusMessage *msg2 = q_dbus_message_copy(msg);

        q_dbus_message_set_path(msg2, p);

        q_dbus_connection_send(connection, msg2, nullptr);

        q_dbus_message_unref(msg2);

    }

}

static int findSlot(const QMetaObject *mo, const QByteArray &name, int flags,

                    const QString &signature_, QList<QMetaType> &metaTypes)

{

    QByteArray msgSignature = signature_.toLatin1();

    QString parametersErrorMsg;

    for (int idx = mo->methodCount() - 1 ; idx >= QObject::staticMetaObject.methodCount(); --idx) {

        QMetaMethod mm = mo->method(idx);

        // check access:

        if (mm.access() != QMetaMethod::Public)

            continue;

        // check type:

        if (mm.methodType() != QMetaMethod::Slot && mm.methodType() != QMetaMethod::Method)

            continue;

        // check name:

        if (mm.name() != name)

            continue;

        QMetaType returnType = mm.returnMetaType();

        bool isAsync = qDBusCheckAsyncTag(mm.tag());

        bool isScriptable = mm.attributes() & QMetaMethod::Scriptable;

        // consistency check:

        if (isAsync && returnType.id() != QMetaType::Void)

            continue;

        QString errorMsg;

        int inputCount = qDBusParametersForMethod(mm, metaTypes, errorMsg);

        if (inputCount == -1) {

            parametersErrorMsg = errorMsg;

            continue;           // problem parsing

        }

        metaTypes[0] = returnType;

        bool hasMessage = false;

        if (inputCount > 0 &&

            metaTypes.at(inputCount) == QDBusMetaTypeId::message()) {

            // "no input parameters" is allowed as long as the message meta type is there

            hasMessage = true;

            --inputCount;

        }

        // try to match the parameters

        int i;

        QByteArray reconstructedSignature;

        for (i = 1; i <= inputCount; ++i) {

            const char *typeSignature = QDBusMetaType::typeToSignature( metaTypes.at(i) );

            if (!typeSignature)

                break;          // invalid

            reconstructedSignature += typeSignature;

            if (!msgSignature.startsWith(reconstructedSignature))

                break;

        }

        if (reconstructedSignature != msgSignature)

            continue;           // we didn't match them all

        if (hasMessage)

            ++i;

        // make sure that the output parameters have signatures too

        if (returnType.isValid() && returnType.id() != QMetaType::Void && QDBusMetaType::typeToSignature(returnType) == nullptr)

            continue;

        bool ok = true;

        for (int j = i; ok && j < metaTypes.size(); ++j)

            if (QDBusMetaType::typeToSignature(metaTypes.at(i)) == nullptr)

                ok = false;

        if (!ok)

            continue;

        // consistency check:

        if (isAsync && metaTypes.size() > i + 1)

            continue;

        if (mm.methodType() == QMetaMethod::Slot) {

            if (isScriptable && (flags & QDBusConnection::ExportScriptableSlots) == 0)

                continue;           // scriptable slots not exported

            if (!isScriptable && (flags & QDBusConnection::ExportNonScriptableSlots) == 0)

                continue;           // non-scriptable slots not exported

        } else {

            if (isScriptable && (flags & QDBusConnection::ExportScriptableInvokables) == 0)

                continue;           // scriptable invokables not exported

            if (!isScriptable && (flags & QDBusConnection::ExportNonScriptableInvokables) == 0)

                continue;           // non-scriptable invokables not exported

        }

        // if we got here, this slot matched

        return idx;

    }

    // no slot matched

    if (!parametersErrorMsg.isEmpty()) {

        qCWarning(dbusIntegration, "QDBusConnection: couldn't handle call to %s: %ls",

                  name.constData(), qUtf16Printable(parametersErrorMsg));

    } else {

        qCWarning(dbusIntegration, "QDBusConnection: couldn't handle call to %s, no slot matched",

                  name.constData());

    }

    return -1;

}

/*!

    \internal

    Enables or disables the delivery of incoming method calls and signals. If

    \a enable is true, this will also cause any queued, pending messages to be

    delivered.

 */

void QDBusConnectionPrivate::setDispatchEnabled(bool enable)

{

    checkThread();

    dispatchEnabled = enable;

    if (enable)

        emit dispatchStatusChanged();

}

static QDBusCallDeliveryEvent * const DIRECT_DELIVERY = (QDBusCallDeliveryEvent *)1;

QDBusCallDeliveryEvent *QDBusConnectionPrivate::prepareReply(QDBusConnectionPrivate *target,

                                                             QObject *object, int idx,

                                                             const QList<QMetaType> &metaTypes,

                                                             const QDBusMessage &msg)

{

    Q_ASSERT(object);

    int n = metaTypes.size() - 1;

    if (metaTypes[n] == QDBusMetaTypeId::message())

        --n;

    if (msg.arguments().size() < n)

        return nullptr;               // too few arguments

    // check that types match

    for (int i = 0; i < n; ++i)

        if (metaTypes.at(i + 1) != msg.arguments().at(i).metaType() &&

            msg.arguments().at(i).metaType() != QMetaType::fromType<QDBusArgument>())

            return nullptr;           // no match

    // we can deliver

    // prepare for the call

    if (target == object)

        return DIRECT_DELIVERY;

    return new QDBusCallDeliveryEvent(QDBusConnection(target), idx, target, msg, metaTypes);

}

void QDBusConnectionPrivate::activateSignal(const QDBusConnectionPrivate::SignalHook& hook,

                                            const QDBusMessage &msg)

{

    // This is called by QDBusConnectionPrivate::handleSignal to deliver a signal

    // that was received from D-Bus

    //

    // Signals are delivered to slots if the parameters match

    // Slots can have less parameters than there are on the message

    // Slots can optionally have one final parameter that is a QDBusMessage

    // Slots receive read-only copies of the message (i.e., pass by value or by const-ref)

    QDBusCallDeliveryEvent *call = prepareReply(this, hook.obj, hook.midx, hook.params, msg);

    if (call == DIRECT_DELIVERY) {

        // short-circuit delivery

        Q_ASSERT(this == hook.obj);

        deliverCall(this, msg, hook.params, hook.midx);

        return;

    }

    if (call)

        postEventToThread(ActivateSignalAction, hook.obj, call);

}

bool QDBusConnectionPrivate::activateCall(QObject *object, QDBusConnection::RegisterOptions flags,

                                          const QDBusMessage &msg)

{

    // This is called by QDBusConnectionPrivate::handleObjectCall to place a call

    // to a slot on the object.

    //

    // The call is delivered to the first slot that matches the following conditions:

    //  - has the same name as the message's target member

    //  - ALL of the message's types are found in slot's parameter list

    //  - optionally has one more parameter of type QDBusMessage

    // If none match, then the slot of the same name as the message target and with

    // the first type of QDBusMessage is delivered.

    //

    // The D-Bus specification requires that all MethodCall messages be replied to, unless the

    // caller specifically waived this requirement. This means that we inspect if the user slot

    // generated a reply and, if it didn't, we will. Obviously, if the user slot doesn't take a

    // QDBusMessage parameter, it cannot generate a reply.

    //

    // When a return message is generated, the slot's return type, if any, will be placed

    // in the message's first position. If there are non-const reference parameters to the

    // slot, they must appear at the end and will be placed in the subsequent message

    // positions.

    static const char cachePropertyName[] = "_qdbus_slotCache";

    if (!object)

        return false;

    Q_ASSERT_X(QThread::currentThread() == object->thread(),

               "QDBusConnection: internal threading error",

               "function called for an object that is in another thread!!");

    QDBusSlotCache slotCache =

        qvariant_cast<QDBusSlotCache>(object->property(cachePropertyName));

    QString cacheKey = msg.member(), signature = msg.signature();

    if (!signature.isEmpty()) {

        cacheKey.reserve(cacheKey.size() + 1 + signature.size());

        cacheKey += u'.';

        cacheKey += signature;

    }

    QDBusSlotCache::Key compoundKey{ std::move(cacheKey), flags };

    QDBusSlotCache::Hash::ConstIterator cacheIt = slotCache.hash.constFind(compoundKey);

    if (cacheIt == slotCache.hash.constEnd()) {

        // not cached, analyze the meta object

        const QMetaObject *mo = object->metaObject();

        QByteArray memberName = msg.member().toUtf8();

        // find a slot that matches according to the rules above

        QDBusSlotCache::Data slotData;

        slotData.slotIdx = ::findSlot(mo, memberName, flags, msg.signature(), slotData.metaTypes);

        if (slotData.slotIdx == -1) {

            // ### this is where we want to add the connection as an arg too

            // try with no parameters, but with a QDBusMessage

            slotData.slotIdx = ::findSlot(mo, memberName, flags, QString(), slotData.metaTypes);

            if (slotData.metaTypes.size() != 2 ||

                slotData.metaTypes.at(1) != QDBusMetaTypeId::message()) {

                // not found

                // save the negative lookup

                slotData.slotIdx = -1;

                slotData.metaTypes.clear();

                slotCache.hash.insert(compoundKey, slotData);

                object->setProperty(cachePropertyName, QVariant::fromValue(slotCache));

                qCWarning(dbusIntegration).nospace() << "Could not find slot " << mo->className()

                                                     << "::" << memberName.constData();

                return false;