qdbusintegrator.cpp File Reference

#include <qcoreapplication.h>
#include <qdebug.h>
#include <qmetaobject.h>
#include <qobject.h>
#include <qsocketnotifier.h>
#include <qstringlist.h>
#include <qtimer.h>
#include <qthread.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 "qdbusutil_p.h"
#include "qdbusvirtualobject.h"
#include "qdbusmessage_p.h"
#include "qdbuscontext_p.h"
#include "qdbuspendingcall_p.h"
#include "qdbusintegrator_p.h"
#include "qdbusthreaddebug_p.h"

Go to the source code of this file.

Macros
#define	DBUS_TYPE_UNIX_FD   int('h')
#define	qDBusDebug   if (!::isDebugging); else qDebug

Typedefs
typedef void(*	QDBusSpyHook) (const QDBusMessage &)
typedef QVarLengthArray< QDBusSpyHook, 4 >	QDBusSpyHookList

Functions
static QByteArray	buildMatchRule (const QString &service, const QString &objectPath, const QString &interface, const QString &member, const QStringList &argMatch, const QString &)
static void	cleanupDeletedNodes (QDBusConnectionPrivate::ObjectTreeNode &parent)
static QDBusConnection::ConnectionCapabilities	connectionCapabilies (DBusConnection *connection)
static QString	dbusInterfaceString ()
static QObject *	findChildObject (const QDBusConnectionPrivate::ObjectTreeNode *root, const QString &fullpath, int start)
static bool	findObject (const QDBusConnectionPrivate::ObjectTreeNode *root, const QString &fullpath, int &usedLength, QDBusConnectionPrivate::ObjectTreeNode &result)
static int	findSlot (const QMetaObject *mo, const QByteArray &name, int flags, const QString &signature_, QList< int > &metaTypes)
static void	huntAndDestroy (QObject *needle, QDBusConnectionPrivate::ObjectTreeNode &haystack)
static void	huntAndEmit (DBusConnection *connection, DBusMessage *msg, QObject *needle, const QDBusConnectionPrivate::ObjectTreeNode &haystack, bool isScriptable, bool isAdaptor, const QString &path=QString())
static QDebug	operator<< (QDebug dbg, const QThread *th)
	Q_GLOBAL_STATIC_WITH_ARGS (const QString, orgFreedesktopDBusString,(QLatin1String(DBUS_SERVICE_DBUS))) static inline QString dbusServiceString()
Q_DBUS_EXPORT void	qDBusAddSpyHook (QDBusSpyHook)
static dbus_bool_t	qDBusAddTimeout (DBusTimeout *timeout, void *data)
static dbus_bool_t	qDBusAddWatch (DBusWatch *watch, void *data)
bool	qDBusInitThreads ()
static void	qDBusNewConnection (DBusServer *server, DBusConnection *connection, void *data)
static bool	qDBusRealAddTimeout (QDBusConnectionPrivate *d, DBusTimeout *timeout, int ms)
static bool	qDBusRealAddWatch (QDBusConnectionPrivate *d, DBusWatch *watch, int flags, int fd)
static void	qDBusRealToggleWatch (QDBusConnectionPrivate *d, DBusWatch *watch, int fd)
static void	qDBusRemoveTimeout (DBusTimeout *timeout, void *data)
static void	qDBusRemoveWatch (DBusWatch *watch, void *data)
static void	qDBusResultReceived (DBusPendingCall *pending, void *user_data)
static DBusHandlerResult	qDBusSignalFilter (DBusConnection *connection, DBusMessage *message, void *data)
static void	qDBusToggleTimeout (DBusTimeout *timeout, void *data)
static void	qDBusToggleWatch (DBusWatch *watch, void *data)
static void	qDBusUpdateDispatchStatus (DBusConnection *connection, DBusDispatchStatus new_status, void *data)
static bool	shouldWatchService (const QString &service)

Variables
static QDBusCallDeliveryEvent *const	DIRECT_DELIVERY = (QDBusCallDeliveryEvent *)1
static bool	isDebugging
static dbus_int32_t	server_slot = -1

Macro Definition Documentation

DBUS_TYPE_UNIX_FD

#define DBUS_TYPE_UNIX_FD   int('h')

Referenced by connectionCapabilies().

qDBusDebug

#define qDBusDebug   if (!::isDebugging); else qDebug

Definition at line 74 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::connectSignal(), QDBusConnectionPrivate::deliverCall(), QDBusConnectionPrivate::disconnectSignal(), QDBusConnectionPrivate::handleMessage(), huntAndEmit(), operator<<(), QDBusConnectionPrivate::processFinishedCall(), qDBusSignalFilter(), QDBusConnectionPrivate::send(), QDBusConnectionPrivate::sendWithReply(), QDBusConnectionPrivate::sendWithReplyAsync(), QDBusConnectionPrivate::sendWithReplyLocal(), QDBusConnectionPrivate::serviceOwnerChangedNoLock(), and QDBusConnectionPrivate::setConnection().

Typedef Documentation

QDBusSpyHook

typedef void(* QDBusSpyHook) (const QDBusMessage &)

Definition at line 134 of file qdbusintegrator.cpp.

QDBusSpyHookList

typedef QVarLengthArray<QDBusSpyHook, 4> QDBusSpyHookList

Definition at line 135 of file qdbusintegrator.cpp.

Function Documentation

buildMatchRule()

static QByteArray buildMatchRule ( const QString &  service, const QString &  objectPath, const QString &  interface, const QString &  member, const QStringList &  argMatch, const QString &    )

static

Definition at line 408 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::prepareHook().

{
    QString result = QLatin1String("type='signal',");
    QString keyValue = QLatin1String("%1='%2',");

    if (!service.isEmpty())
        result += keyValue.arg(QLatin1String("sender"), service);
    if (!objectPath.isEmpty())
        result += keyValue.arg(QLatin1String("path"), objectPath);
    if (!interface.isEmpty())
        result += keyValue.arg(QLatin1String("interface"), interface);
    if (!member.isEmpty())
        result += keyValue.arg(QLatin1String("member"), member);

    // add the argument string-matching now
    if (!argMatch.isEmpty()) {
        keyValue = QLatin1String("arg%1='%2',");
        for (int i = 0; i < argMatch.count(); ++i)
            if (!argMatch.at(i).isNull())
                result += keyValue.arg(i).arg(argMatch.at(i));
    }

    result.chop(1);             // remove ending comma
    return result.toLatin1();
}

cleanupDeletedNodes()

static void cleanupDeletedNodes ( QDBusConnectionPrivate::ObjectTreeNode &  parent )

static

Definition at line 2230 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::registerObject().

{
    QMutableVectorIterator<QDBusConnectionPrivate::ObjectTreeNode> it(parent.children);
    while (it.hasNext()) {
        QDBusConnectionPrivate::ObjectTreeNode& node = it.next();
        if (node.obj == 0 && node.children.isEmpty())
            it.remove();
        else
            cleanupDeletedNodes(node);
    }
}

connectionCapabilies()

static QDBusConnection::ConnectionCapabilities connectionCapabilies ( DBusConnection *  connection )

static

Definition at line 1686 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::setConnection().

{
    QDBusConnection::ConnectionCapabilities result = 0;
    typedef dbus_bool_t (*can_send_type_t)(DBusConnection *, int);
    static can_send_type_t can_send_type = 0;

#if defined(QT_LINKED_LIBDBUS)
# if DBUS_VERSION-0 >= 0x010400
    can_send_type = dbus_connection_can_send_type;
# endif
#else
    // run-time check if the next functions are available
    can_send_type = (can_send_type_t)qdbus_resolve_conditionally("dbus_connection_can_send_type");
#endif

#ifndef DBUS_TYPE_UNIX_FD
# define DBUS_TYPE_UNIX_FD int('h')
#endif
    if (can_send_type && can_send_type(connection, DBUS_TYPE_UNIX_FD))
        result |= QDBusConnection::UnixFileDescriptorPassing;

    return result;
}

dbusInterfaceString()

static QString dbusInterfaceString ( )

inlinestatic

Definition at line 80 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::connectSignal(), QDBusConnectionPrivate::disconnectSignal(), and QDBusConnectionPrivate::getNameOwnerNoCache().

{
    // it's the same string, but just be sure
    Q_ASSERT(*orgFreedesktopDBusString() == QLatin1String(DBUS_INTERFACE_DBUS));
    return *orgFreedesktopDBusString();
}

findChildObject()

static QObject* findChildObject ( const QDBusConnectionPrivate::ObjectTreeNode *  root, const QString &  fullpath, int  start  )

static

Definition at line 485 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::activateObject().

{
    int length = fullpath.length();

    // 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(QLatin1Char('/'), start);
            pos = (pos == -1 ? length : pos);
            QStringRef pathComponent(&fullpath, start, pos - start);

            const QObjectList children = obj->children();

            // find a child with the proper name
            QObject *next = 0;
            QObjectList::ConstIterator it = children.constBegin();
            QObjectList::ConstIterator end = children.constEnd();
            for ( ; it != end; ++it)
                if ((*it)->objectName() == pathComponent) {
                    next = *it;
                    break;
                }

            if (!next)
                break;

            obj = next;
            start = pos + 1;
        }
    }

    // object not found
    return 0;
}

findObject()

static bool findObject ( const QDBusConnectionPrivate::ObjectTreeNode *  root, const QString &  fullpath, int &  usedLength, QDBusConnectionPrivate::ObjectTreeNode &  result  )

static

Definition at line 436 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::handleObjectCall().

{
    if (!fullpath.compare(QLatin1String("/")) && root->obj) {
        usedLength = 1;
        result = *root;
        return root;
    }
    int start = 0;
    int length = fullpath.length();
    if (fullpath.at(0) == QLatin1Char('/'))
        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(QLatin1Char('/'), start);
        end = (end == -1 ? length : end);
        QStringRef pathComponent(&fullpath, start, end - start);

        QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it =
            qLowerBound(node->children.constBegin(), node->children.constEnd(), pathComponent);
        if (it != node->children.constEnd() && it->name == pathComponent)
            // match
            node = it;
        else
            node = 0;

        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 QVector
            node = 0;
    }
    return node;
}

findSlot()

static int findSlot ( const QMetaObject *  mo, const QByteArray &  name, int  flags, const QString &  signature_, QList< int > &  metaTypes  )

static

Definition at line 632 of file qdbusintegrator.cpp.

{
    QByteArray msgSignature = signature_.toLatin1();

    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:
        QByteArray slotname = mm.signature();
        int paren = slotname.indexOf('(');
        if (paren != name.length() || !slotname.startsWith(name))
            continue;

        int returnType = qDBusNameToTypeId(mm.typeName());
        bool isAsync = qDBusCheckAsyncTag(mm.tag());
        bool isScriptable = mm.attributes() & QMetaMethod::Scriptable;

        // consistency check:
        if (isAsync && returnType != QMetaType::Void)
            continue;

        int inputCount = qDBusParametersForMethod(mm, metaTypes);
        if (inputCount == -1)
            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 != 0 && QDBusMetaType::typeToSignature(returnType) == 0)
            continue;

        bool ok = true;
        for (int j = i; ok && j < metaTypes.count(); ++j)
            if (QDBusMetaType::typeToSignature(metaTypes.at(i)) == 0)
                ok = false;
        if (!ok)
            continue;

        // consistency check:
        if (isAsync && metaTypes.count() > 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
    return -1;
}

huntAndDestroy()

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

static

Definition at line 587 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::objectDestroyed().

{
    QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator it = haystack.children.begin();
    QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator end = haystack.children.end();
    for ( ; it != end; ++it)
        huntAndDestroy(needle, *it);

    if (needle == haystack.obj) {
        haystack.obj = 0;
        haystack.flags = 0;
    }
}

huntAndEmit()

static void huntAndEmit ( DBusConnection *  connection, DBusMessage *  msg, QObject *  needle, const QDBusConnectionPrivate::ObjectTreeNode &  haystack, bool  isScriptable, bool  isAdaptor, const QString &  path = QString()  )

static

Definition at line 600 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::relaySignal().

{
    QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it = haystack.children.constBegin();
    QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator end = haystack.children.constEnd();
    for ( ; it != end; ++it)
        huntAndEmit(connection, msg, needle, *it, isScriptable, isAdaptor, path + QLatin1Char('/') + it->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, 0);
        q_dbus_message_unref(msg2);
    }
}

operator<<()

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

inlinestatic

Definition at line 87 of file qdbusintegrator.cpp.

{
    dbg.nospace() << "QThread(ptr=" << (void*)th;
    if (th && !th->objectName().isEmpty())
        dbg.nospace() << ", name=" << th->objectName();
    dbg.nospace() << ')';
    return dbg.space();
}

Q_GLOBAL_STATIC_WITH_ARGS()

Q_GLOBAL_STATIC_WITH_ARGS	(	const QString	,
		orgFreedesktopDBusString	,
		(QLatin1String(DBUS_SERVICE_DBUS))
	)

Definition at line 76 of file qdbusintegrator.cpp.

{ return *orgFreedesktopDBusString(); }

qDBusAddSpyHook()

void qDBusAddSpyHook

(

QDBusSpyHook

hook

)

Definition at line 534 of file qdbusintegrator.cpp.

Referenced by shouldWatchService().

{
    qDBusSpyHookList()->append(hook);
}

qDBusAddTimeout()

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

static

Definition at line 143 of file qdbusintegrator.cpp.

Referenced by qDBusToggleTimeout(), QDBusConnectionPrivate::setConnection(), QDBusConnectionPrivate::setPeer(), and QDBusConnectionPrivate::setServer().

{
    Q_ASSERT(timeout);
    Q_ASSERT(data);

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

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

    if (!q_dbus_timeout_get_enabled(timeout))
        return true;

    QDBusWatchAndTimeoutLocker locker(AddTimeoutAction, d);
    if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {
        // correct thread
        return qDBusRealAddTimeout(d, timeout, q_dbus_timeout_get_interval(timeout));
    } else {
        // wrong thread: sync back
        QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;
        ev->subtype = QDBusConnectionCallbackEvent::AddTimeout;
        d->timeoutsPendingAdd.append(qMakePair(timeout, q_dbus_timeout_get_interval(timeout)));
        d->postEventToThread(AddTimeoutAction, d, ev);
        return true;
    }
}

qDBusAddWatch()

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

static

Definition at line 236 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::setConnection(), QDBusConnectionPrivate::setPeer(), and QDBusConnectionPrivate::setServer().

{
    Q_ASSERT(watch);
    Q_ASSERT(data);

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

    int flags = q_dbus_watch_get_flags(watch);
    int fd = q_dbus_watch_get_fd(watch);

    if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {
        return qDBusRealAddWatch(d, watch, flags, fd);
    } else {
        QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;
        ev->subtype = QDBusConnectionCallbackEvent::AddWatch;
        ev->watch = watch;
        ev->fd = fd;
        ev->extra = flags;
        d->postEventToThread(AddWatchAction, d, ev);
        return true;
    }
}

qDBusInitThreads()

bool qDBusInitThreads

(

)

Referenced by QDBusConnectionPrivate::deliverCall().

qDBusNewConnection()

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

static

Definition at line 380 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::setServer().

{
    // ### We may want to separate the server from the QDBusConnectionPrivate
    Q_ASSERT(server); Q_UNUSED(server);
    Q_ASSERT(connection);
    Q_ASSERT(data);

    // keep the connection alive
    q_dbus_connection_ref(connection);
    QDBusConnectionPrivate *serverConnection = static_cast<QDBusConnectionPrivate *>(data);

    QDBusConnectionPrivate *newConnection = new QDBusConnectionPrivate(serverConnection->parent());
    QMutexLocker locker(&QDBusConnectionManager::instance()->mutex);
    QDBusConnectionManager::instance()->setConnection(QLatin1String("QDBusServer-") + QString::number(reinterpret_cast<qulonglong>(newConnection)), newConnection);
    serverConnection->serverConnectionNames << newConnection->name;

    // setPeer does the error handling for us
    QDBusErrorInternal error;
    newConnection->setPeer(connection, error);

    QDBusConnection retval = QDBusConnectionPrivate::q(newConnection);

    // make QDBusServer emit the newConnection signal
    serverConnection->serverConnection(retval);
}

qDBusRealAddTimeout()

static bool qDBusRealAddTimeout ( QDBusConnectionPrivate *  d, DBusTimeout *  timeout, int  ms  )

static

Definition at line 169 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::customEvent(), and qDBusAddTimeout().

{
    Q_ASSERT(d->timeouts.keys(timeout).isEmpty());

    int timerId = d->startTimer(ms);
    if (!timerId)
        return false;

    d->timeouts[timerId] = timeout;
    return true;
}

qDBusRealAddWatch()

static bool qDBusRealAddWatch ( QDBusConnectionPrivate *  d, DBusWatch *  watch, int  flags, int  fd  )

static

Definition at line 259 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::customEvent(), qDBusAddWatch(), and qDBusToggleTimeout().

{
    QDBusConnectionPrivate::Watcher watcher;

    QDBusWatchAndTimeoutLocker locker(AddWatchAction, d);
    if (flags & DBUS_WATCH_READABLE) {
        //qDebug("addReadWatch %d", fd);
        watcher.watch = watch;
        if (QCoreApplication::instance()) {
            watcher.read = new QSocketNotifier(fd, QSocketNotifier::Read, d);
            watcher.read->setEnabled(q_dbus_watch_get_enabled(watch));
            d->connect(watcher.read, SIGNAL(activated(int)), SLOT(socketRead(int)));
        }
    }
    if (flags & DBUS_WATCH_WRITABLE) {
        //qDebug("addWriteWatch %d", fd);
        watcher.watch = watch;
        if (QCoreApplication::instance()) {
            watcher.write = new QSocketNotifier(fd, QSocketNotifier::Write, d);
            watcher.write->setEnabled(q_dbus_watch_get_enabled(watch));
            d->connect(watcher.write, SIGNAL(activated(int)), SLOT(socketWrite(int)));
        }
    }
    d->watchers.insertMulti(fd, watcher);

    return true;
}

qDBusRealToggleWatch()

static void qDBusRealToggleWatch ( QDBusConnectionPrivate *  d, DBusWatch *  watch, int  fd  )

static

Definition at line 339 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::customEvent(), qDBusRemoveWatch(), and qDBusToggleWatch().

{
    QDBusWatchAndTimeoutLocker locker(ToggleWatchAction, d);

    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;
    }
}

qDBusRemoveTimeout()

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

static

Definition at line 181 of file qdbusintegrator.cpp.

Referenced by qDBusToggleTimeout(), QDBusConnectionPrivate::setConnection(), QDBusConnectionPrivate::setPeer(), and QDBusConnectionPrivate::setServer().

{
    Q_ASSERT(timeout);
    Q_ASSERT(data);

  //  qDebug("removeTimeout");

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

    QDBusWatchAndTimeoutLocker locker(RemoveTimeoutAction, d);

    // is it pending addition?
    QDBusConnectionPrivate::PendingTimeoutList::iterator pit = d->timeoutsPendingAdd.begin();
    while (pit != d->timeoutsPendingAdd.end()) {
        if (pit->first == timeout)
            pit = d->timeoutsPendingAdd.erase(pit);
        else
            ++pit;
    }

    // is it a running timer?
    bool correctThread = QCoreApplication::instance() && QThread::currentThread() == d->thread();
    QDBusConnectionPrivate::TimeoutHash::iterator it = d->timeouts.begin();
    while (it != d->timeouts.end()) {
        if (it.value() == timeout) {
            if (correctThread) {
                // correct thread
                d->killTimer(it.key());
            } else {
                // incorrect thread or no application, post an event for later
                QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;
                ev->subtype = QDBusConnectionCallbackEvent::KillTimer;
                ev->timerId = it.key();
                d->postEventToThread(KillTimerAction, d, ev);
            }
            it = d->timeouts.erase(it);
            break;
        } else {
            ++it;
        }
    }
}

qDBusRemoveWatch()

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

static

Definition at line 287 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::setConnection(), QDBusConnectionPrivate::setPeer(), and QDBusConnectionPrivate::setServer().

{
    Q_ASSERT(watch);
    Q_ASSERT(data);

    //qDebug("remove watch");

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
    int fd = q_dbus_watch_get_fd(watch);

    QDBusWatchAndTimeoutLocker locker(RemoveWatchAction, d);
    QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd);
    while (i != d->watchers.end() && i.key() == fd) {
        if (i.value().watch == watch) {
            if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {
                // correct thread, delete the socket notifiers
                delete i.value().read;
                delete i.value().write;
            } else {
                // incorrect thread or no application, use delete later
                if (i->read)
                    i->read->deleteLater();
                if (i->write)
                    i->write->deleteLater();
            }
            i = d->watchers.erase(i);
        } else {
            ++i;
        }
    }
}

qDBusResultReceived()

static void qDBusResultReceived ( DBusPendingCall *  pending, void *  user_data  )

static

Definition at line 1757 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::sendWithReplyAsync().

{
    QDBusPendingCallPrivate *call = reinterpret_cast<QDBusPendingCallPrivate *>(user_data);
    Q_ASSERT(call->pending == pending);
    Q_UNUSED(pending);
    QDBusConnectionPrivate::processFinishedCall(call);
}

qDBusSignalFilter()

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

static

Definition at line 541 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::setConnection(), and QDBusConnectionPrivate::setPeer().

{
    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->capabilities);
    qDBusDebug() << d << "got message (signal):" << amsg;

    return d->handleMessage(amsg) ?
        DBUS_HANDLER_RESULT_HANDLED :
        DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

qDBusToggleTimeout()

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

static

Definition at line 224 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::setConnection(), QDBusConnectionPrivate::setPeer(), and QDBusConnectionPrivate::setServer().

{
    Q_ASSERT(timeout);
    Q_ASSERT(data);

    //qDebug("ToggleTimeout");

    qDBusRemoveTimeout(timeout, data);
    qDBusAddTimeout(timeout, data);
}

qDBusToggleWatch()

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

static

Definition at line 320 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::setConnection(), QDBusConnectionPrivate::setPeer(), and QDBusConnectionPrivate::setServer().

{
    Q_ASSERT(watch);
    Q_ASSERT(data);

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
    int fd = q_dbus_watch_get_fd(watch);

    if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {
        qDBusRealToggleWatch(d, watch, fd);
    } else {
        QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;
        ev->subtype = QDBusConnectionCallbackEvent::ToggleWatch;
        ev->watch = watch;
        ev->fd = fd;
        d->postEventToThread(ToggleWatchAction, d, ev);
    }
}

qDBusUpdateDispatchStatus()

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

static

Definition at line 361 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::setConnection(), and QDBusConnectionPrivate::setPeer().

{
    Q_ASSERT(connection);
    Q_UNUSED(connection);
    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    static int slotId; // 0 is QObject::deleteLater()
    if (!slotId) {
        // it's ok to do this: there's no race condition because the store is atomic
        // and we always set to the same value
        slotId = QDBusConnectionPrivate::staticMetaObject.indexOfSlot("doDispatch()");
    }

    //qDBusDebug() << "Updating dispatcher status" << slotId;
    if (new_status == DBUS_DISPATCH_DATA_REMAINS)
        QDBusConnectionPrivate::staticMetaObject.method(slotId).
            invoke(d, Qt::QueuedConnection);
}

shouldWatchService()

static bool shouldWatchService ( const QString &  service )

static

Definition at line 528 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::connectSignal(), and QDBusConnectionPrivate::handleSignal().

{
    return !service.isEmpty() && !service.startsWith(QLatin1Char(':'));
}

Variable Documentation

DIRECT_DELIVERY

QDBusCallDeliveryEvent* const DIRECT_DELIVERY = (QDBusCallDeliveryEvent *)1

static

Definition at line 729 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionPrivate::prepareReply().

isDebugging

bool isDebugging

static

Definition at line 73 of file qdbusintegrator.cpp.

Referenced by QDeclarativeEnginePrivate::init(), and QDBusConnectionPrivate::QDBusConnectionPrivate().

server_slot

dbus_int32_t server_slot = -1

static

Definition at line 1618 of file qdbusintegrator.cpp.