1 /****************************************************************************
3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/
6 ** This file is part of the QtDBus module of the Qt Toolkit.
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** GNU Lesser General Public License Usage
10 ** This file may be used under the terms of the GNU Lesser General Public
11 ** License version 2.1 as published by the Free Software Foundation and
12 ** appearing in the file LICENSE.LGPL included in the packaging of this
13 ** file. Please review the following information to ensure the GNU Lesser
14 ** General Public License version 2.1 requirements will be met:
15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
17 ** In addition, as a special exception, Nokia gives you certain additional
18 ** rights. These rights are described in the Nokia Qt LGPL Exception
19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
21 ** GNU General Public License Usage
22 ** Alternatively, this file may be used under the terms of the GNU General
23 ** Public License version 3.0 as published by the Free Software Foundation
24 ** and appearing in the file LICENSE.GPL included in the packaging of this
25 ** file. Please review the following information to ensure the GNU General
26 ** Public License version 3.0 requirements will be met:
27 ** http://www.gnu.org/copyleft/gpl.html.
30 ** Alternatively, this file may be used in accordance with the terms and
31 ** conditions contained in a signed written agreement between you and Nokia.
40 ****************************************************************************/
42 #include "qdbusintegrator_p.h"
44 #include <qcoreapplication.h>
46 #include <qmetaobject.h>
48 #include <qsocketnotifier.h>
49 #include <qstringlist.h>
53 #include "qdbusargument.h"
54 #include "qdbusconnection_p.h"
55 #include "qdbusconnectionmanager_p.h"
56 #include "qdbusinterface_p.h"
57 #include "qdbusmessage.h"
58 #include "qdbusmetatype.h"
59 #include "qdbusmetatype_p.h"
60 #include "qdbusabstractadaptor.h"
61 #include "qdbusabstractadaptor_p.h"
62 #include "qdbusutil_p.h"
63 #include "qdbusvirtualobject.h"
64 #include "qdbusmessage_p.h"
65 #include "qdbuscontext_p.h"
66 #include "qdbuspendingcall_p.h"
68 #include "qdbusthreaddebug_p.h"
76 static bool isDebugging;
77 #define qDBusDebug if (!::isDebugging); else qDebug
79 Q_GLOBAL_STATIC_WITH_ARGS(const QString, orgFreedesktopDBusString, (QLatin1String(DBUS_SERVICE_DBUS)))
81 static inline QString dbusServiceString()
82 { return *orgFreedesktopDBusString(); }
83 static inline QString dbusInterfaceString()
85 // it's the same string, but just be sure
86 Q_ASSERT(*orgFreedesktopDBusString() == QLatin1String(DBUS_INTERFACE_DBUS));
87 return *orgFreedesktopDBusString();
90 static inline QDebug operator<<(QDebug dbg, const QThread *th)
92 dbg.nospace() << "QThread(ptr=" << (void*)th;
93 if (th && !th->objectName().isEmpty())
94 dbg.nospace() << ", name=" << th->objectName();
99 #if QDBUS_THREAD_DEBUG
100 static inline QDebug operator<<(QDebug dbg, const QDBusConnectionPrivate *conn)
102 dbg.nospace() << "QDBusConnection("
103 << "ptr=" << (void*)conn
104 << ", name=" << conn->name
105 << ", baseService=" << conn->baseService
107 if (conn->thread() == QThread::currentThread())
108 dbg.nospace() << "same thread";
110 dbg.nospace() << conn->thread();
111 dbg.nospace() << ')';
115 Q_AUTOTEST_EXPORT void qdbusDefaultThreadDebug(int action, int condition, QDBusConnectionPrivate *conn)
117 qDBusDebug() << QThread::currentThread()
118 << "QtDBus threading action" << action
119 << (condition == QDBusLockerBase::BeforeLock ? "before lock" :
120 condition == QDBusLockerBase::AfterLock ? "after lock" :
121 condition == QDBusLockerBase::BeforeUnlock ? "before unlock" :
122 condition == QDBusLockerBase::AfterUnlock ? "after unlock" :
123 condition == QDBusLockerBase::BeforePost ? "before event posting" :
124 condition == QDBusLockerBase::AfterPost ? "after event posting" :
125 condition == QDBusLockerBase::BeforeDeliver ? "before event delivery" :
126 condition == QDBusLockerBase::AfterDeliver ? "after event delivery" :
127 condition == QDBusLockerBase::BeforeAcquire ? "before acquire" :
128 condition == QDBusLockerBase::AfterAcquire ? "after acquire" :
129 condition == QDBusLockerBase::BeforeRelease ? "before release" :
130 condition == QDBusLockerBase::AfterRelease ? "after release" :
132 << "in connection" << conn;
134 Q_AUTOTEST_EXPORT qdbusThreadDebugFunc qdbusThreadDebug = 0;
137 typedef void (*QDBusSpyHook)(const QDBusMessage&);
138 typedef QVarLengthArray<QDBusSpyHook, 4> QDBusSpyHookList;
139 Q_GLOBAL_STATIC(QDBusSpyHookList, qDBusSpyHookList)
143 // libdbus-1 callbacks
145 static bool qDBusRealAddTimeout(QDBusConnectionPrivate *d, DBusTimeout *timeout, int ms);
146 static dbus_bool_t qDBusAddTimeout(DBusTimeout *timeout, void *data)
151 // qDebug("addTimeout %d", q_dbus_timeout_get_interval(timeout));
153 QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
155 if (!q_dbus_timeout_get_enabled(timeout))
158 QDBusWatchAndTimeoutLocker locker(AddTimeoutAction, d);
159 if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {
161 return qDBusRealAddTimeout(d, timeout, q_dbus_timeout_get_interval(timeout));
163 // wrong thread: sync back
164 QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;
165 ev->subtype = QDBusConnectionCallbackEvent::AddTimeout;
166 d->timeoutsPendingAdd.append(qMakePair(timeout, q_dbus_timeout_get_interval(timeout)));
167 d->postEventToThread(AddTimeoutAction, d, ev);
172 static bool qDBusRealAddTimeout(QDBusConnectionPrivate *d, DBusTimeout *timeout, int ms)
174 Q_ASSERT(d->timeouts.keys(timeout).isEmpty());
176 int timerId = d->startTimer(ms);
180 d->timeouts[timerId] = timeout;
184 static void qDBusRemoveTimeout(DBusTimeout *timeout, void *data)
189 // qDebug("removeTimeout");
191 QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
193 QDBusWatchAndTimeoutLocker locker(RemoveTimeoutAction, d);
195 // is it pending addition?
196 QDBusConnectionPrivate::PendingTimeoutList::iterator pit = d->timeoutsPendingAdd.begin();
197 while (pit != d->timeoutsPendingAdd.end()) {
198 if (pit->first == timeout)
199 pit = d->timeoutsPendingAdd.erase(pit);
204 // is it a running timer?
205 bool correctThread = QCoreApplication::instance() && QThread::currentThread() == d->thread();
206 QDBusConnectionPrivate::TimeoutHash::iterator it = d->timeouts.begin();
207 while (it != d->timeouts.end()) {
208 if (it.value() == timeout) {
211 d->killTimer(it.key());
213 // incorrect thread or no application, post an event for later
214 QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;
215 ev->subtype = QDBusConnectionCallbackEvent::KillTimer;
216 ev->timerId = it.key();
217 d->postEventToThread(KillTimerAction, d, ev);
219 it = d->timeouts.erase(it);
227 static void qDBusToggleTimeout(DBusTimeout *timeout, void *data)
232 //qDebug("ToggleTimeout");
234 qDBusRemoveTimeout(timeout, data);
235 qDBusAddTimeout(timeout, data);
238 static bool qDBusRealAddWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int flags, int fd);
239 static dbus_bool_t qDBusAddWatch(DBusWatch *watch, void *data)
244 QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
246 int flags = q_dbus_watch_get_flags(watch);
247 int fd = q_dbus_watch_get_fd(watch);
249 if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {
250 return qDBusRealAddWatch(d, watch, flags, fd);
252 QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;
253 ev->subtype = QDBusConnectionCallbackEvent::AddWatch;
257 d->postEventToThread(AddWatchAction, d, ev);
262 static bool qDBusRealAddWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int flags, int fd)
264 QDBusConnectionPrivate::Watcher watcher;
266 QDBusWatchAndTimeoutLocker locker(AddWatchAction, d);
267 if (flags & DBUS_WATCH_READABLE) {
268 //qDebug("addReadWatch %d", fd);
269 watcher.watch = watch;
270 if (QCoreApplication::instance()) {
271 watcher.read = new QSocketNotifier(fd, QSocketNotifier::Read, d);
272 watcher.read->setEnabled(q_dbus_watch_get_enabled(watch));
273 d->connect(watcher.read, SIGNAL(activated(int)), SLOT(socketRead(int)));
276 if (flags & DBUS_WATCH_WRITABLE) {
277 //qDebug("addWriteWatch %d", fd);
278 watcher.watch = watch;
279 if (QCoreApplication::instance()) {
280 watcher.write = new QSocketNotifier(fd, QSocketNotifier::Write, d);
281 watcher.write->setEnabled(q_dbus_watch_get_enabled(watch));
282 d->connect(watcher.write, SIGNAL(activated(int)), SLOT(socketWrite(int)));
285 d->watchers.insertMulti(fd, watcher);
290 static void qDBusRemoveWatch(DBusWatch *watch, void *data)
295 //qDebug("remove watch");
297 QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
298 int fd = q_dbus_watch_get_fd(watch);
300 QDBusWatchAndTimeoutLocker locker(RemoveWatchAction, d);
301 QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd);
302 while (i != d->watchers.end() && i.key() == fd) {
303 if (i.value().watch == watch) {
304 if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {
305 // correct thread, delete the socket notifiers
306 delete i.value().read;
307 delete i.value().write;
309 // incorrect thread or no application, use delete later
311 i->read->deleteLater();
313 i->write->deleteLater();
315 i = d->watchers.erase(i);
322 static void qDBusRealToggleWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int fd);
323 static void qDBusToggleWatch(DBusWatch *watch, void *data)
328 QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
329 int fd = q_dbus_watch_get_fd(watch);
331 if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {
332 qDBusRealToggleWatch(d, watch, fd);
334 QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;
335 ev->subtype = QDBusConnectionCallbackEvent::ToggleWatch;
338 d->postEventToThread(ToggleWatchAction, d, ev);
342 static void qDBusRealToggleWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int fd)
344 QDBusWatchAndTimeoutLocker locker(ToggleWatchAction, d);
346 QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd);
347 while (i != d->watchers.end() && i.key() == fd) {
348 if (i.value().watch == watch) {
349 bool enabled = q_dbus_watch_get_enabled(watch);
350 int flags = q_dbus_watch_get_flags(watch);
352 //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);
354 if (flags & DBUS_WATCH_READABLE && i.value().read)
355 i.value().read->setEnabled(enabled);
356 if (flags & DBUS_WATCH_WRITABLE && i.value().write)
357 i.value().write->setEnabled(enabled);
364 static void qDBusUpdateDispatchStatus(DBusConnection *connection, DBusDispatchStatus new_status, void *data)
366 Q_ASSERT(connection);
367 Q_UNUSED(connection);
368 QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
370 static int slotId; // 0 is QObject::deleteLater()
372 // it's ok to do this: there's no race condition because the store is atomic
373 // and we always set to the same value
374 slotId = QDBusConnectionPrivate::staticMetaObject.indexOfSlot("doDispatch()");
377 //qDBusDebug() << "Updating dispatcher status" << slotId;
378 if (new_status == DBUS_DISPATCH_DATA_REMAINS)
379 QDBusConnectionPrivate::staticMetaObject.method(slotId).
380 invoke(d, Qt::QueuedConnection);
383 static void qDBusNewConnection(DBusServer *server, DBusConnection *connection, void *data)
385 // ### We may want to separate the server from the QDBusConnectionPrivate
386 Q_ASSERT(server); Q_UNUSED(server);
387 Q_ASSERT(connection);
390 // keep the connection alive
391 q_dbus_connection_ref(connection);
392 QDBusConnectionPrivate *serverConnection = static_cast<QDBusConnectionPrivate *>(data);
394 QDBusConnectionPrivate *newConnection = new QDBusConnectionPrivate(serverConnection->parent());
395 QMutexLocker locker(&QDBusConnectionManager::instance()->mutex);
396 QDBusConnectionManager::instance()->setConnection(QLatin1String("QDBusServer-") + QString::number(reinterpret_cast<qulonglong>(newConnection)), newConnection);
397 serverConnection->serverConnectionNames << newConnection->name;
399 // setPeer does the error handling for us
400 QDBusErrorInternal error;
401 newConnection->setPeer(connection, error);
403 QDBusConnection retval = QDBusConnectionPrivate::q(newConnection);
405 // make QDBusServer emit the newConnection signal
406 serverConnection->serverConnection(retval);
411 static QByteArray buildMatchRule(const QString &service,
412 const QString &objectPath, const QString &interface,
413 const QString &member, const QStringList &argMatch, const QString & /*signature*/)
415 QString result = QLatin1String("type='signal',");
416 QString keyValue = QLatin1String("%1='%2',");
418 if (!service.isEmpty())
419 result += keyValue.arg(QLatin1String("sender"), service);
420 if (!objectPath.isEmpty())
421 result += keyValue.arg(QLatin1String("path"), objectPath);
422 if (!interface.isEmpty())
423 result += keyValue.arg(QLatin1String("interface"), interface);
424 if (!member.isEmpty())
425 result += keyValue.arg(QLatin1String("member"), member);
427 // add the argument string-matching now
428 if (!argMatch.isEmpty()) {
429 keyValue = QLatin1String("arg%1='%2',");
430 for (int i = 0; i < argMatch.count(); ++i)
431 if (!argMatch.at(i).isNull())
432 result += keyValue.arg(i).arg(argMatch.at(i));
435 result.chop(1); // remove ending comma
436 return result.toLatin1();
439 static bool findObject(const QDBusConnectionPrivate::ObjectTreeNode *root,
440 const QString &fullpath, int &usedLength,
441 QDBusConnectionPrivate::ObjectTreeNode &result)
443 if (!fullpath.compare(QLatin1String("/")) && root->obj) {
449 int length = fullpath.length();
450 if (fullpath.at(0) == QLatin1Char('/'))
453 // walk the object tree
454 QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator node = root;
455 while (start < length && node) {
456 if (node->flags & QDBusConnection::ExportChildObjects)
458 if ((node->flags & QDBusConnectionPrivate::VirtualObject) && (node->flags & QDBusConnection::SubPath))
460 int end = fullpath.indexOf(QLatin1Char('/'), start);
461 end = (end == -1 ? length : end);
462 QStringRef pathComponent(&fullpath, start, end - start);
464 QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it =
465 std::lower_bound(node->children.constBegin(), node->children.constEnd(), pathComponent);
466 if (it != node->children.constEnd() && it->name == pathComponent)
476 usedLength = (start > length ? length : start);
478 if (node->obj || !node->children.isEmpty())
481 // there really is no object here
482 // we're just looking at an unused space in the QVector
488 static QObject *findChildObject(const QDBusConnectionPrivate::ObjectTreeNode *root,
489 const QString &fullpath, int start)
491 int length = fullpath.length();
493 // any object in the tree can tell us to switch to its own object tree:
494 const QDBusConnectionPrivate::ObjectTreeNode *node = root;
495 if (node && node->flags & QDBusConnection::ExportChildObjects) {
496 QObject *obj = node->obj;
500 // we're at the correct level
503 int pos = fullpath.indexOf(QLatin1Char('/'), start);
504 pos = (pos == -1 ? length : pos);
505 QStringRef pathComponent(&fullpath, start, pos - start);
507 const QObjectList children = obj->children();
509 // find a child with the proper name
511 QObjectList::ConstIterator it = children.constBegin();
512 QObjectList::ConstIterator end = children.constEnd();
513 for ( ; it != end; ++it)
514 if ((*it)->objectName() == pathComponent) {
531 static bool shouldWatchService(const QString &service)
533 return !service.isEmpty() && !service.startsWith(QLatin1Char(':'));
536 extern Q_DBUS_EXPORT void qDBusAddSpyHook(QDBusSpyHook);
537 void qDBusAddSpyHook(QDBusSpyHook hook)
539 qDBusSpyHookList()->append(hook);
543 static DBusHandlerResult
544 qDBusSignalFilter(DBusConnection *connection, DBusMessage *message, void *data)
547 Q_UNUSED(connection);
548 QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
549 if (d->mode == QDBusConnectionPrivate::InvalidMode)
550 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
552 QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(message, d->capabilities);
553 qDBusDebug() << d << "got message (signal):" << amsg;
555 return d->handleMessage(amsg) ?
556 DBUS_HANDLER_RESULT_HANDLED :
557 DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
561 bool QDBusConnectionPrivate::handleMessage(const QDBusMessage &amsg)
563 const QDBusSpyHookList *list = qDBusSpyHookList();
564 for (int i = 0; i < list->size(); ++i) {
565 qDBusDebug() << "calling the message spy hook";
572 switch (amsg.type()) {
573 case QDBusMessage::SignalMessage:
575 // if there are any other filters in this DBusConnection,
576 // let them see the signal too
578 case QDBusMessage::MethodCallMessage:
579 handleObjectCall(amsg);
581 case QDBusMessage::ReplyMessage:
582 case QDBusMessage::ErrorMessage:
583 case QDBusMessage::InvalidMessage:
584 return false; // we don't handle those here
590 static void huntAndDestroy(QObject *needle, QDBusConnectionPrivate::ObjectTreeNode &haystack)
592 QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator it = haystack.children.begin();
593 QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator end = haystack.children.end();
594 for ( ; it != end; ++it)
595 huntAndDestroy(needle, *it);
597 if (needle == haystack.obj) {
603 static void huntAndEmit(DBusConnection *connection, DBusMessage *msg,
604 QObject *needle, const QDBusConnectionPrivate::ObjectTreeNode &haystack,
605 bool isScriptable, bool isAdaptor, const QString &path = QString())
607 QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it = haystack.children.constBegin();
608 QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator end = haystack.children.constEnd();
609 for ( ; it != end; ++it)
610 huntAndEmit(connection, msg, needle, *it, isScriptable, isAdaptor, path + QLatin1Char('/') + it->name);
612 if (needle == haystack.obj) {
613 // is this a signal we should relay?
614 if (isAdaptor && (haystack.flags & QDBusConnection::ExportAdaptors) == 0)
615 return; // no: it comes from an adaptor and we're not exporting adaptors
616 else if (!isAdaptor) {
617 int mask = isScriptable
618 ? QDBusConnection::ExportScriptableSignals
619 : QDBusConnection::ExportNonScriptableSignals;
620 if ((haystack.flags & mask) == 0)
621 return; // signal was not exported
624 QByteArray p = path.toLatin1();
627 qDBusDebug() << QThread::currentThread() << "emitting signal at" << p;
628 DBusMessage *msg2 = q_dbus_message_copy(msg);
629 q_dbus_message_set_path(msg2, p);
630 q_dbus_connection_send(connection, msg2, 0);
631 q_dbus_message_unref(msg2);
635 static int findSlot(const QMetaObject *mo, const QByteArray &name, int flags,
636 const QString &signature_, QVector<int> &metaTypes)
638 QByteArray msgSignature = signature_.toLatin1();
640 for (int idx = mo->methodCount() - 1 ; idx >= QObject::staticMetaObject.methodCount(); --idx) {
641 QMetaMethod mm = mo->method(idx);
644 if (mm.access() != QMetaMethod::Public)
648 if (mm.methodType() != QMetaMethod::Slot && mm.methodType() != QMetaMethod::Method)
652 if (mm.name() != name)
655 int returnType = mm.returnType();
656 bool isAsync = qDBusCheckAsyncTag(mm.tag());
657 bool isScriptable = mm.attributes() & QMetaMethod::Scriptable;
659 // consistency check:
660 if (isAsync && returnType != QMetaType::Void)
663 int inputCount = qDBusParametersForMethod(mm, metaTypes);
664 if (inputCount == -1)
665 continue; // problem parsing
667 metaTypes[0] = returnType;
668 bool hasMessage = false;
669 if (inputCount > 0 &&
670 metaTypes.at(inputCount) == QDBusMetaTypeId::message) {
671 // "no input parameters" is allowed as long as the message meta type is there
676 // try to match the parameters
678 QByteArray reconstructedSignature;
679 for (i = 1; i <= inputCount; ++i) {
680 const char *typeSignature = QDBusMetaType::typeToSignature( metaTypes.at(i) );
684 reconstructedSignature += typeSignature;
685 if (!msgSignature.startsWith(reconstructedSignature))
689 if (reconstructedSignature != msgSignature)
690 continue; // we didn't match them all
695 // make sure that the output parameters have signatures too
696 if (returnType != QMetaType::UnknownType && returnType != QMetaType::Void && QDBusMetaType::typeToSignature(returnType) == 0)
700 for (int j = i; ok && j < metaTypes.count(); ++j)
701 if (QDBusMetaType::typeToSignature(metaTypes.at(i)) == 0)
706 // consistency check:
707 if (isAsync && metaTypes.count() > i + 1)
710 if (mm.methodType() == QMetaMethod::Slot) {
711 if (isScriptable && (flags & QDBusConnection::ExportScriptableSlots) == 0)
712 continue; // scriptable slots not exported
713 if (!isScriptable && (flags & QDBusConnection::ExportNonScriptableSlots) == 0)
714 continue; // non-scriptable slots not exported
716 if (isScriptable && (flags & QDBusConnection::ExportScriptableInvokables) == 0)
717 continue; // scriptable invokables not exported
718 if (!isScriptable && (flags & QDBusConnection::ExportNonScriptableInvokables) == 0)
719 continue; // non-scriptable invokables not exported
722 // if we got here, this slot matched
730 static QDBusCallDeliveryEvent * const DIRECT_DELIVERY = (QDBusCallDeliveryEvent *)1;
732 QDBusCallDeliveryEvent* QDBusConnectionPrivate::prepareReply(QDBusConnectionPrivate *target,
733 QObject *object, int idx,
734 const QVector<int> &metaTypes,
735 const QDBusMessage &msg)
740 int n = metaTypes.count() - 1;
741 if (metaTypes[n] == QDBusMetaTypeId::message)
744 if (msg.arguments().count() < n)
745 return 0; // too few arguments
747 // check that types match
748 for (int i = 0; i < n; ++i)
749 if (metaTypes.at(i + 1) != msg.arguments().at(i).userType() &&
750 msg.arguments().at(i).userType() != qMetaTypeId<QDBusArgument>())
751 return 0; // no match
754 // prepare for the call
755 if (target == object)
756 return DIRECT_DELIVERY;
757 return new QDBusCallDeliveryEvent(QDBusConnection(target), idx, target, msg, metaTypes);
760 void QDBusConnectionPrivate::activateSignal(const QDBusConnectionPrivate::SignalHook& hook,
761 const QDBusMessage &msg)
763 // This is called by QDBusConnectionPrivate::handleSignal to deliver a signal
764 // that was received from D-Bus
766 // Signals are delivered to slots if the parameters match
767 // Slots can have less parameters than there are on the message
768 // Slots can optionally have one final parameter that is a QDBusMessage
769 // Slots receive read-only copies of the message (i.e., pass by value or by const-ref)
770 QDBusCallDeliveryEvent *call = prepareReply(this, hook.obj, hook.midx, hook.params, msg);
771 if (call == DIRECT_DELIVERY) {
772 // short-circuit delivery
773 Q_ASSERT(this == hook.obj);
774 deliverCall(this, 0, msg, hook.params, hook.midx);
778 postEventToThread(ActivateSignalAction, hook.obj, call);
781 bool QDBusConnectionPrivate::activateCall(QObject* object, int flags, const QDBusMessage &msg)
783 // This is called by QDBusConnectionPrivate::handleObjectCall to place a call
784 // to a slot on the object.
786 // The call is delivered to the first slot that matches the following conditions:
787 // - has the same name as the message's target member
788 // - ALL of the message's types are found in slot's parameter list
789 // - optionally has one more parameter of type QDBusMessage
790 // If none match, then the slot of the same name as the message target and with
791 // the first type of QDBusMessage is delivered.
793 // The D-Bus specification requires that all MethodCall messages be replied to, unless the
794 // caller specifically waived this requirement. This means that we inspect if the user slot
795 // generated a reply and, if it didn't, we will. Obviously, if the user slot doesn't take a
796 // QDBusMessage parameter, it cannot generate a reply.
798 // When a return message is generated, the slot's return type, if any, will be placed
799 // in the message's first position. If there are non-const reference parameters to the
800 // slot, they must appear at the end and will be placed in the subsequent message
803 static const char cachePropertyName[] = "_qdbus_slotCache";
808 #ifndef QT_NO_PROPERTIES
809 Q_ASSERT_X(QThread::currentThread() == object->thread(),
810 "QDBusConnection: internal threading error",
811 "function called for an object that is in another thread!!");
813 QDBusSlotCache slotCache =
814 qvariant_cast<QDBusSlotCache>(object->property(cachePropertyName));
815 QString cacheKey = msg.member(), signature = msg.signature();
816 if (!signature.isEmpty()) {
817 cacheKey.reserve(cacheKey.length() + 1 + signature.length());
818 cacheKey += QLatin1Char('.');
819 cacheKey += signature;
822 QDBusSlotCache::Hash::ConstIterator cacheIt = slotCache.hash.constFind(cacheKey);
823 while (cacheIt != slotCache.hash.constEnd() && cacheIt->flags != flags &&
824 cacheIt.key() == cacheKey)
826 if (cacheIt == slotCache.hash.constEnd() || cacheIt.key() != cacheKey)
828 // not cached, analyze the meta object
829 const QMetaObject *mo = object->metaObject();
830 QByteArray memberName = msg.member().toUtf8();
832 // find a slot that matches according to the rules above
833 QDBusSlotCache::Data slotData;
834 slotData.flags = flags;
835 slotData.slotIdx = ::findSlot(mo, memberName, flags, msg.signature(), slotData.metaTypes);
836 if (slotData.slotIdx == -1) {
837 // ### this is where we want to add the connection as an arg too
838 // try with no parameters, but with a QDBusMessage
839 slotData.slotIdx = ::findSlot(mo, memberName, flags, QString(), slotData.metaTypes);
840 if (slotData.metaTypes.count() != 2 ||
841 slotData.metaTypes.at(1) != QDBusMetaTypeId::message) {
843 // save the negative lookup
844 slotData.slotIdx = -1;
845 slotData.metaTypes.clear();
846 slotCache.hash.insert(cacheKey, slotData);
847 object->setProperty(cachePropertyName, QVariant::fromValue(slotCache));
853 slotCache.hash.insert(cacheKey, slotData);
854 object->setProperty(cachePropertyName, QVariant::fromValue(slotCache));
856 // found the slot to be called
857 deliverCall(object, flags, msg, slotData.metaTypes, slotData.slotIdx);
859 } else if (cacheIt->slotIdx == -1) {
864 deliverCall(object, flags, msg, cacheIt->metaTypes, cacheIt->slotIdx);
867 #endif // QT_NO_PROPERTIES
871 void QDBusConnectionPrivate::deliverCall(QObject *object, int /*flags*/, const QDBusMessage &msg,
872 const QVector<int> &metaTypes, int slotIdx)
874 Q_ASSERT_X(!object || QThread::currentThread() == object->thread(),
875 "QDBusConnection: internal threading error",
876 "function called for an object that is in another thread!!");
878 QVarLengthArray<void *, 10> params;
879 params.reserve(metaTypes.count());
881 QVariantList auxParameters;
882 // let's create the parameter list
884 // first one is the return type -- add it below
887 // add the input parameters
889 int pCount = qMin(msg.arguments().count(), metaTypes.count() - 1);
890 for (i = 1; i <= pCount; ++i) {
891 int id = metaTypes[i];
892 if (id == QDBusMetaTypeId::message)
895 const QVariant &arg = msg.arguments().at(i - 1);
896 if (arg.userType() == id)
897 // no conversion needed
898 params.append(const_cast<void *>(arg.constData()));
899 else if (arg.userType() == qMetaTypeId<QDBusArgument>()) {
900 // convert to what the function expects
902 auxParameters.append(QVariant(id, null));
904 const QDBusArgument &in =
905 *reinterpret_cast<const QDBusArgument *>(arg.constData());
906 QVariant &out = auxParameters[auxParameters.count() - 1];
908 if (!QDBusMetaType::demarshall(in, out.userType(), out.data()))
909 qFatal("Internal error: demarshalling function for type '%s' (%d) failed!",
910 out.typeName(), out.userType());
912 params.append(const_cast<void *>(out.constData()));
914 qFatal("Internal error: got invalid meta type %d (%s) "
915 "when trying to convert to meta type %d (%s)",
916 arg.userType(), QMetaType::typeName(arg.userType()),
917 id, QMetaType::typeName(id));
921 if (metaTypes.count() > i && metaTypes[i] == QDBusMetaTypeId::message) {
922 params.append(const_cast<void*>(static_cast<const void*>(&msg)));
927 QVariantList outputArgs;
929 if (metaTypes[0] != QMetaType::Void && metaTypes[0] != QMetaType::UnknownType) {
930 QVariant arg(metaTypes[0], null);
931 outputArgs.append( arg );
932 params[0] = const_cast<void*>(outputArgs.at( outputArgs.count() - 1 ).constData());
934 for ( ; i < metaTypes.count(); ++i) {
935 QVariant arg(metaTypes[i], null);
936 outputArgs.append( arg );
937 params.append(const_cast<void*>(outputArgs.at( outputArgs.count() - 1 ).constData()));
945 // FIXME: save the old sender!
946 QDBusContextPrivate context(QDBusConnection(this), msg);
947 QDBusContextPrivate *old = QDBusContextPrivate::set(object, &context);
948 QDBusConnectionPrivate::setSender(this);
950 QPointer<QObject> ptr = object;
951 fail = object->qt_metacall(QMetaObject::InvokeMetaMethod,
952 slotIdx, params.data()) >= 0;
953 QDBusConnectionPrivate::setSender(0);
954 // the object might be deleted in the slot
956 QDBusContextPrivate::set(object, old);
959 // do we create a reply? Only if the caller is waiting for a reply and one hasn't been sent
961 if (msg.isReplyRequired() && !msg.isDelayedReply()) {
964 qDBusDebug() << this << "Automatically sending reply:" << outputArgs;
965 send(msg.createReply(outputArgs));
967 // generate internal error
968 qWarning("Internal error: Failed to deliver message");
969 send(msg.createErrorReply(QDBusError::InternalError,
970 QLatin1String("Failed to deliver message")));
977 extern bool qDBusInitThreads();
979 QDBusConnectionPrivate::QDBusConnectionPrivate(QObject *p)
980 : QObject(p), ref(1), capabilities(0), mode(InvalidMode), connection(0), server(0), busService(0),
981 watchAndTimeoutLock(QMutex::Recursive),
982 rootNode(QString(QLatin1Char('/')))
984 static const bool threads = q_dbus_threads_init_default();
985 static const int debugging = qgetenv("QDBUS_DEBUG").toInt();
986 ::isDebugging = debugging;
990 #ifdef QDBUS_THREAD_DEBUG
992 qdbusThreadDebug = qdbusDefaultThreadDebug;
995 QDBusMetaTypeId::init();
999 // prepopulate watchedServices:
1000 // we know that the owner of org.freedesktop.DBus is itself
1001 watchedServices.insert(dbusServiceString(), WatchedServiceData(dbusServiceString(), 1));
1003 // prepopulate matchRefCounts:
1004 // we know that org.freedesktop.DBus will never change owners
1005 matchRefCounts.insert("type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',arg0='org.freedesktop.DBus'", 1);
1008 QDBusConnectionPrivate::~QDBusConnectionPrivate()
1010 if (thread() && thread() != QThread::currentThread())
1011 qWarning("QDBusConnection(name=\"%s\")'s last reference in not in its creation thread! "
1012 "Timer and socket errors will follow and the program will probably crash",
1016 rootNode.children.clear(); // free resources
1017 qDeleteAll(cachedMetaObjects);
1020 q_dbus_server_unref(server);
1022 q_dbus_connection_unref(connection);
1028 void QDBusConnectionPrivate::deleteYourself()
1030 if (thread() && thread() != QThread::currentThread()) {
1031 // last reference dropped while not in the correct thread
1032 // ask the correct thread to delete
1034 // note: since we're posting an event to another thread, we
1035 // must consider deleteLater() to take effect immediately
1042 void QDBusConnectionPrivate::closeConnection()
1044 QDBusWriteLocker locker(CloseConnectionAction, this);
1045 ConnectionMode oldMode = mode;
1046 mode = InvalidMode; // prevent reentrancy
1047 baseService.clear();
1050 q_dbus_server_disconnect(server);
1052 if (oldMode == ClientMode || oldMode == PeerMode) {
1054 q_dbus_connection_close(connection);
1055 // send the "close" message
1056 while (q_dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS)
1060 qDBusDebug() << this << "Disconnected";
1063 void QDBusConnectionPrivate::checkThread()
1066 if (QCoreApplication::instance())
1067 moveToThread(QCoreApplication::instance()->thread());
1069 qWarning("The thread that had QDBusConnection('%s') has died and there is no main thread",
1074 bool QDBusConnectionPrivate::handleError(const QDBusErrorInternal &error)
1077 return false; // no error
1079 //lock.lockForWrite();
1085 void QDBusConnectionPrivate::timerEvent(QTimerEvent *e)
1088 QDBusWatchAndTimeoutLocker locker(TimerEventAction, this);
1089 DBusTimeout *timeout = timeouts.value(e->timerId(), 0);
1091 q_dbus_timeout_handle(timeout);
1097 void QDBusConnectionPrivate::customEvent(QEvent *e)
1099 Q_ASSERT(e->type() == QEvent::User);
1101 QDBusConnectionCallbackEvent *ev = static_cast<QDBusConnectionCallbackEvent *>(e);
1102 QDBusLockerBase::reportThreadAction(int(AddTimeoutAction) + int(ev->subtype),
1103 QDBusLockerBase::BeforeDeliver, this);
1104 switch (ev->subtype)
1106 case QDBusConnectionCallbackEvent::AddTimeout: {
1107 QDBusWatchAndTimeoutLocker locker(RealAddTimeoutAction, this);
1108 while (!timeoutsPendingAdd.isEmpty()) {
1109 QPair<DBusTimeout *, int> entry = timeoutsPendingAdd.takeFirst();
1110 qDBusRealAddTimeout(this, entry.first, entry.second);
1115 case QDBusConnectionCallbackEvent::KillTimer:
1116 killTimer(ev->timerId);
1119 case QDBusConnectionCallbackEvent::AddWatch:
1120 qDBusRealAddWatch(this, ev->watch, ev->extra, ev->fd);
1123 case QDBusConnectionCallbackEvent::ToggleWatch:
1124 qDBusRealToggleWatch(this, ev->watch, ev->fd);
1127 QDBusLockerBase::reportThreadAction(int(AddTimeoutAction) + int(ev->subtype),
1128 QDBusLockerBase::AfterDeliver, this);
1131 void QDBusConnectionPrivate::doDispatch()
1133 QDBusDispatchLocker locker(DoDispatchAction, this);
1134 if (mode == ClientMode || mode == PeerMode)
1135 while (q_dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS) ;
1138 void QDBusConnectionPrivate::socketRead(int fd)
1140 QVarLengthArray<DBusWatch *, 2> pendingWatches;
1143 QDBusWatchAndTimeoutLocker locker(SocketReadAction, this);
1144 WatcherHash::ConstIterator it = watchers.constFind(fd);
1145 while (it != watchers.constEnd() && it.key() == fd) {
1146 if (it->watch && it->read && it->read->isEnabled())
1147 pendingWatches.append(it.value().watch);
1152 for (int i = 0; i < pendingWatches.size(); ++i)
1153 if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_READABLE))
1154 qDebug("OUT OF MEM");
1158 void QDBusConnectionPrivate::socketWrite(int fd)
1160 QVarLengthArray<DBusWatch *, 2> pendingWatches;
1163 QDBusWatchAndTimeoutLocker locker(SocketWriteAction, this);
1164 WatcherHash::ConstIterator it = watchers.constFind(fd);
1165 while (it != watchers.constEnd() && it.key() == fd) {
1166 if (it->watch && it->write && it->write->isEnabled())
1167 pendingWatches.append(it.value().watch);
1172 for (int i = 0; i < pendingWatches.size(); ++i)
1173 if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_WRITABLE))
1174 qDebug("OUT OF MEM");
1177 void QDBusConnectionPrivate::objectDestroyed(QObject *obj)
1179 QDBusWriteLocker locker(ObjectDestroyedAction, this);
1180 huntAndDestroy(obj, rootNode);
1182 SignalHookHash::iterator sit = signalHooks.begin();
1183 while (sit != signalHooks.end()) {
1184 if (static_cast<QObject *>(sit.value().obj) == obj)
1185 sit = disconnectSignal(sit);
1190 obj->disconnect(this);
1193 void QDBusConnectionPrivate::relaySignal(QObject *obj, const QMetaObject *mo, int signalId,
1194 const QVariantList &args)
1196 QString interface = qDBusInterfaceFromMetaObject(mo);
1198 QMetaMethod mm = mo->method(signalId);
1199 QByteArray memberName = mm.name();
1201 // check if it's scriptable
1202 bool isScriptable = mm.attributes() & QMetaMethod::Scriptable;
1203 bool isAdaptor = false;
1204 for ( ; mo; mo = mo->superClass())
1205 if (mo == &QDBusAbstractAdaptor::staticMetaObject) {
1210 QDBusReadLocker locker(RelaySignalAction, this);
1211 QDBusMessage message = QDBusMessage::createSignal(QLatin1String("/"), interface,
1212 QLatin1String(memberName));
1213 QDBusMessagePrivate::setParametersValidated(message, true);
1214 message.setArguments(args);
1216 DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &error);
1218 qWarning("QDBusConnection: Could not emit signal %s.%s: %s", qPrintable(interface), memberName.constData(),
1219 qPrintable(error.message()));
1224 //qDBusDebug() << "Emitting signal" << message;
1225 //qDBusDebug() << "for paths:";
1226 q_dbus_message_set_no_reply(msg, true); // the reply would not be delivered to anything
1227 huntAndEmit(connection, msg, obj, rootNode, isScriptable, isAdaptor);
1228 q_dbus_message_unref(msg);
1231 void QDBusConnectionPrivate::serviceOwnerChangedNoLock(const QString &name,
1232 const QString &oldOwner, const QString &newOwner)
1235 // QDBusWriteLocker locker(UpdateSignalHookOwnerAction, this);
1236 WatchedServicesHash::Iterator it = watchedServices.find(name);
1237 if (it == watchedServices.end())
1239 if (oldOwner != it->owner)
1240 qWarning("QDBusConnection: name '%s' had owner '%s' but we thought it was '%s'",
1241 qPrintable(name), qPrintable(oldOwner), qPrintable(it->owner));
1243 qDBusDebug() << this << "Updating name" << name << "from" << oldOwner << "to" << newOwner;
1244 it->owner = newOwner;
1247 int QDBusConnectionPrivate::findSlot(QObject* obj, const QByteArray &normalizedName,
1248 QVector<int> ¶ms)
1250 int midx = obj->metaObject()->indexOfMethod(normalizedName);
1254 int inputCount = qDBusParametersForMethod(obj->metaObject()->method(midx), params);
1255 if ( inputCount == -1 || inputCount + 1 != params.count() )
1256 return -1; // failed to parse or invalid arguments or output arguments
1261 bool QDBusConnectionPrivate::prepareHook(QDBusConnectionPrivate::SignalHook &hook, QString &key,
1262 const QString &service,
1263 const QString &path, const QString &interface, const QString &name,
1264 const QStringList &argMatch,
1265 QObject *receiver, const char *signal, int minMIdx,
1266 bool buildSignature)
1268 QByteArray normalizedName = signal + 1;
1269 hook.midx = findSlot(receiver, signal + 1, hook.params);
1270 if (hook.midx == -1) {
1271 normalizedName = QMetaObject::normalizedSignature(signal + 1);
1272 hook.midx = findSlot(receiver, normalizedName, hook.params);
1274 if (hook.midx < minMIdx) {
1275 if (hook.midx == -1)
1280 hook.service = service;
1282 hook.obj = receiver;
1283 hook.argumentMatch = argMatch;
1285 // build the D-Bus signal name and signature
1286 // This should not happen for QDBusConnection::connect, use buildSignature here, since
1287 // QDBusConnection::connect passes false and everything else uses true
1288 QString mname = name;
1289 if (buildSignature && mname.isNull()) {
1290 normalizedName.truncate(normalizedName.indexOf('('));
1291 mname = QString::fromUtf8(normalizedName);
1294 key.reserve(interface.length() + 1 + mname.length());
1295 key += QLatin1Char(':');
1298 if (buildSignature) {
1299 hook.signature.clear();
1300 for (int i = 1; i < hook.params.count(); ++i)
1301 if (hook.params.at(i) != QDBusMetaTypeId::message)
1302 hook.signature += QLatin1String( QDBusMetaType::typeToSignature( hook.params.at(i) ) );
1305 hook.matchRule = buildMatchRule(service, path, interface, mname, argMatch, hook.signature);
1306 return true; // connect to this signal
1309 void QDBusConnectionPrivate::sendError(const QDBusMessage &msg, QDBusError::ErrorType code)
1311 if (code == QDBusError::UnknownMethod) {
1312 QString interfaceMsg;
1313 if (msg.interface().isEmpty())
1314 interfaceMsg = QLatin1String("any interface");
1316 interfaceMsg = QString::fromLatin1("interface '%1'").arg(msg.interface());
1318 send(msg.createErrorReply(code,
1319 QString::fromLatin1("No such method '%1' in %2 at object path '%3' "
1321 .arg(msg.member(), interfaceMsg, msg.path(), msg.signature())));
1322 } else if (code == QDBusError::UnknownInterface) {
1323 send(msg.createErrorReply(QDBusError::UnknownInterface,
1324 QString::fromLatin1("No such interface '%1' at object path '%2'")
1325 .arg(msg.interface(), msg.path())));
1326 } else if (code == QDBusError::UnknownObject) {
1327 send(msg.createErrorReply(QDBusError::UnknownObject,
1328 QString::fromLatin1("No such object path '%1'").arg(msg.path())));
1332 bool QDBusConnectionPrivate::activateInternalFilters(const ObjectTreeNode &node,
1333 const QDBusMessage &msg)
1335 // object may be null
1336 const QString interface = msg.interface();
1338 if (interface.isEmpty() || interface == QLatin1String(DBUS_INTERFACE_INTROSPECTABLE)) {
1339 if (msg.member() == QLatin1String("Introspect") && msg.signature().isEmpty()) {
1340 //qDebug() << "QDBusConnectionPrivate::activateInternalFilters introspect" << msg.d_ptr->msg;
1341 QDBusMessage reply = msg.createReply(qDBusIntrospectObject(node, msg.path()));
1346 if (!interface.isEmpty()) {
1347 sendError(msg, QDBusError::UnknownMethod);
1352 if (node.obj && (interface.isEmpty() ||
1353 interface == QLatin1String(DBUS_INTERFACE_PROPERTIES))) {
1354 //qDebug() << "QDBusConnectionPrivate::activateInternalFilters properties" << msg.d_ptr->msg;
1355 if (msg.member() == QLatin1String("Get") && msg.signature() == QLatin1String("ss")) {
1356 QDBusMessage reply = qDBusPropertyGet(node, msg);
1359 } else if (msg.member() == QLatin1String("Set") && msg.signature() == QLatin1String("ssv")) {
1360 QDBusMessage reply = qDBusPropertySet(node, msg);
1363 } else if (msg.member() == QLatin1String("GetAll") && msg.signature() == QLatin1String("s")) {
1364 QDBusMessage reply = qDBusPropertyGetAll(node, msg);
1369 if (!interface.isEmpty()) {
1370 sendError(msg, QDBusError::UnknownMethod);
1378 void QDBusConnectionPrivate::activateObject(ObjectTreeNode &node, const QDBusMessage &msg,
1381 // This is called by QDBusConnectionPrivate::handleObjectCall to place a call to a slot
1384 // The call is routed through the adaptor sub-objects if we have any
1386 // object may be null
1388 if (node.flags & QDBusConnectionPrivate::VirtualObject) {
1389 if (node.treeNode->handleMessage(msg, q(this))) {
1392 if (activateInternalFilters(node, msg))
1397 if (pathStartPos != msg.path().length()) {
1398 node.flags &= ~QDBusConnection::ExportAllSignals;
1399 node.obj = findChildObject(&node, msg.path(), pathStartPos);
1401 sendError(msg, QDBusError::UnknownObject);
1406 QDBusAdaptorConnector *connector;
1407 if (node.flags & QDBusConnection::ExportAdaptors &&
1408 (connector = qDBusFindAdaptorConnector(node.obj))) {
1409 int newflags = node.flags | QDBusConnection::ExportAllSlots;
1411 if (msg.interface().isEmpty()) {
1412 // place the call in all interfaces
1413 // let the first one that handles it to work
1414 QDBusAdaptorConnector::AdaptorMap::ConstIterator it =
1415 connector->adaptors.constBegin();
1416 QDBusAdaptorConnector::AdaptorMap::ConstIterator end =
1417 connector->adaptors.constEnd();
1419 for ( ; it != end; ++it)
1420 if (activateCall(it->adaptor, newflags, msg))
1423 // check if we have an interface matching the name that was asked:
1424 QDBusAdaptorConnector::AdaptorMap::ConstIterator it;
1425 it = std::lower_bound(connector->adaptors.constBegin(), connector->adaptors.constEnd(),
1427 if (it != connector->adaptors.constEnd() && msg.interface() == QLatin1String(it->interface)) {
1428 if (!activateCall(it->adaptor, newflags, msg))
1429 sendError(msg, QDBusError::UnknownMethod);
1435 // no adaptors matched or were exported
1436 // try our standard filters
1437 if (activateInternalFilters(node, msg))
1438 return; // internal filters have already run or an error has been sent
1440 // try the object itself:
1441 if (node.flags & (QDBusConnection::ExportScriptableSlots|QDBusConnection::ExportNonScriptableSlots) ||
1442 node.flags & (QDBusConnection::ExportScriptableInvokables|QDBusConnection::ExportNonScriptableInvokables)) {
1443 bool interfaceFound = true;
1444 if (!msg.interface().isEmpty())
1445 interfaceFound = qDBusInterfaceInObject(node.obj, msg.interface());
1447 if (interfaceFound) {
1448 if (!activateCall(node.obj, node.flags, msg))
1449 sendError(msg, QDBusError::UnknownMethod);
1454 // nothing matched, send an error code
1455 if (msg.interface().isEmpty())
1456 sendError(msg, QDBusError::UnknownMethod);
1458 sendError(msg, QDBusError::UnknownInterface);
1461 void QDBusConnectionPrivate::handleObjectCall(const QDBusMessage &msg)
1463 // if the msg is external, we were called from inside doDispatch
1464 // that means the dispatchLock mutex is locked
1465 // must not call out to user code in that case
1467 // however, if the message is internal, handleMessage was called
1468 // directly and no lock is in place. We can therefore call out to
1469 // user code, if necessary
1470 ObjectTreeNode result;
1472 QThread *objThread = 0;
1477 QDBusReadLocker locker(HandleObjectCallAction, this);
1478 if (!findObject(&rootNode, msg.path(), usedLength, result)) {
1479 // qDebug("Call failed: no object found at %s", qPrintable(msg.path()));
1480 sendError(msg, QDBusError::UnknownObject);
1485 // no object -> no threading issues
1486 // it's either going to be an error, or an internal filter
1487 activateObject(result, msg, usedLength);
1491 objThread = result.obj->thread();
1493 send(msg.createErrorReply(QDBusError::InternalError,
1494 QString::fromLatin1("Object '%1' (at path '%2')"
1495 " has no thread. Cannot deliver message.")
1496 .arg(result.obj->objectName(), msg.path())));
1500 if (!QDBusMessagePrivate::isLocal(msg)) {
1501 // external incoming message
1502 // post it and forget
1503 postEventToThread(HandleObjectCallPostEventAction, result.obj,
1504 new QDBusActivateObjectEvent(QDBusConnection(this), this, result,
1507 } else if (objThread != QThread::currentThread()) {
1508 // synchronize with other thread
1509 postEventToThread(HandleObjectCallPostEventAction, result.obj,
1510 new QDBusActivateObjectEvent(QDBusConnection(this), this, result,
1511 usedLength, msg, &sem));
1516 } // release the lock
1519 SEM_ACQUIRE(HandleObjectCallSemaphoreAction, sem);
1521 activateObject(result, msg, usedLength);
1524 QDBusActivateObjectEvent::~QDBusActivateObjectEvent()
1527 // we're being destroyed without delivering
1528 // it means the object was deleted between posting and delivering
1529 QDBusConnectionPrivate *that = QDBusConnectionPrivate::d(connection);
1530 that->sendError(message, QDBusError::UnknownObject);
1533 // semaphore releasing happens in ~QMetaCallEvent
1536 void QDBusActivateObjectEvent::placeMetaCall(QObject *)
1538 QDBusConnectionPrivate *that = QDBusConnectionPrivate::d(connection);
1540 QDBusLockerBase::reportThreadAction(HandleObjectCallPostEventAction,
1541 QDBusLockerBase::BeforeDeliver, that);
1542 that->activateObject(node, message, pathStartPos);
1543 QDBusLockerBase::reportThreadAction(HandleObjectCallPostEventAction,
1544 QDBusLockerBase::AfterDeliver, that);
1549 void QDBusConnectionPrivate::handleSignal(const QString &key, const QDBusMessage& msg)
1551 SignalHookHash::const_iterator it = signalHooks.constFind(key);
1552 SignalHookHash::const_iterator end = signalHooks.constEnd();
1553 //qDebug("looking for: %s", path.toLocal8Bit().constData());
1554 //qDBusDebug() << signalHooks.keys();
1555 for ( ; it != end && it.key() == key; ++it) {
1556 const SignalHook &hook = it.value();
1557 if (!hook.service.isEmpty()) {
1558 const QString owner =
1559 shouldWatchService(hook.service) ?
1560 watchedServices.value(hook.service).owner :
1562 if (owner != msg.service())
1565 if (!hook.path.isEmpty() && hook.path != msg.path())
1567 if (!hook.signature.isEmpty() && hook.signature != msg.signature())
1569 if (hook.signature.isEmpty() && !hook.signature.isNull() && !msg.signature().isEmpty())
1571 if (!hook.argumentMatch.isEmpty()) {
1572 const QVariantList arguments = msg.arguments();
1573 if (hook.argumentMatch.size() > arguments.size())
1576 bool matched = true;
1577 for (int i = 0; i < hook.argumentMatch.size(); ++i) {
1578 const QString ¶m = hook.argumentMatch.at(i);
1580 continue; // don't try to match against this
1581 if (param == arguments.at(i).toString())
1582 continue; // matched
1590 activateSignal(hook, msg);
1594 void QDBusConnectionPrivate::handleSignal(const QDBusMessage& msg)
1596 // We call handlesignal(QString, QDBusMessage) three times:
1597 // one with member:interface
1599 // one with :interface
1600 // This allows us to match signals with wildcards on member or interface
1603 QString key = msg.member();
1604 key.reserve(key.length() + 1 + msg.interface().length());
1605 key += QLatin1Char(':');
1606 key += msg.interface();
1608 QDBusReadLocker locker(HandleSignalAction, this);
1609 handleSignal(key, msg); // one try
1611 key.truncate(msg.member().length() + 1); // keep the ':'
1612 handleSignal(key, msg); // second try
1614 key = QLatin1Char(':');
1615 key += msg.interface();
1616 handleSignal(key, msg); // third try
1619 static dbus_int32_t server_slot = -1;
1621 void QDBusConnectionPrivate::setServer(DBusServer *s, const QDBusErrorInternal &error)
1631 dbus_bool_t data_allocated = q_dbus_server_allocate_data_slot(&server_slot);
1632 if (data_allocated && server_slot < 0)
1635 dbus_bool_t watch_functions_set = q_dbus_server_set_watch_functions(server,
1640 //qDebug() << "watch_functions_set" << watch_functions_set;
1641 Q_UNUSED(watch_functions_set);
1643 dbus_bool_t time_functions_set = q_dbus_server_set_timeout_functions(server,
1648 //qDebug() << "time_functions_set" << time_functions_set;
1649 Q_UNUSED(time_functions_set);
1651 q_dbus_server_set_new_connection_function(server, qDBusNewConnection, this, 0);
1653 dbus_bool_t data_set = q_dbus_server_set_data(server, server_slot, this, 0);
1654 //qDebug() << "data_set" << data_set;
1658 void QDBusConnectionPrivate::setPeer(DBusConnection *c, const QDBusErrorInternal &error)
1668 q_dbus_connection_set_exit_on_disconnect(connection, false);
1669 q_dbus_connection_set_watch_functions(connection,
1674 q_dbus_connection_set_timeout_functions(connection,
1679 q_dbus_connection_set_dispatch_status_function(connection, qDBusUpdateDispatchStatus, this, 0);
1680 q_dbus_connection_add_filter(connection,
1684 QMetaObject::invokeMethod(this, "doDispatch", Qt::QueuedConnection);
1687 static QDBusConnection::ConnectionCapabilities connectionCapabilies(DBusConnection *connection)
1689 QDBusConnection::ConnectionCapabilities result = 0;
1691 #if defined(QT_LINKED_LIBDBUS) && DBUS_VERSION < 0x010400
1692 // no capabilities are possible
1694 # if !defined(QT_LINKED_LIBDBUS)
1695 // run-time check if the next functions are available
1696 int major, minor, micro;
1697 q_dbus_get_version(&major, &minor, µ);
1698 if (major == 1 && minor < 4)
1702 #ifndef DBUS_TYPE_UNIX_FD
1703 # define DBUS_TYPE_UNIX_FD int('h')
1705 if (q_dbus_connection_can_send_type(connection, DBUS_TYPE_UNIX_FD))
1706 result |= QDBusConnection::UnixFileDescriptorPassing;
1712 void QDBusConnectionPrivate::setConnection(DBusConnection *dbc, const QDBusErrorInternal &error)
1722 const char *service = q_dbus_bus_get_unique_name(connection);
1724 baseService = QString::fromUtf8(service);
1725 capabilities = connectionCapabilies(connection);
1727 q_dbus_connection_set_exit_on_disconnect(connection, false);
1728 q_dbus_connection_set_watch_functions(connection, qDBusAddWatch, qDBusRemoveWatch,
1729 qDBusToggleWatch, this, 0);
1730 q_dbus_connection_set_timeout_functions(connection, qDBusAddTimeout, qDBusRemoveTimeout,
1731 qDBusToggleTimeout, this, 0);
1732 q_dbus_connection_set_dispatch_status_function(connection, qDBusUpdateDispatchStatus, this, 0);
1733 q_dbus_connection_add_filter(connection, qDBusSignalFilter, this, 0);
1735 // Initialize the hooks for the NameAcquired and NameLost signals
1736 // we don't use connectSignal here because we don't need the rules to be sent to the bus
1737 // the bus will always send us these two signals
1739 hook.service = dbusServiceString();
1740 hook.path.clear(); // no matching
1742 hook.params << QMetaType::Void << QVariant::String; // both functions take a QString as parameter and return void
1744 hook.midx = staticMetaObject.indexOfSlot("registerServiceNoLock(QString)");
1745 Q_ASSERT(hook.midx != -1);
1746 signalHooks.insert(QLatin1String("NameAcquired:" DBUS_INTERFACE_DBUS), hook);
1748 hook.midx = staticMetaObject.indexOfSlot("unregisterServiceNoLock(QString)");
1749 Q_ASSERT(hook.midx != -1);
1750 signalHooks.insert(QLatin1String("NameLost:" DBUS_INTERFACE_DBUS), hook);
1752 qDBusDebug() << this << ": connected successfully";
1754 // schedule a dispatch:
1755 QMetaObject::invokeMethod(this, "doDispatch", Qt::QueuedConnection);
1759 static void qDBusResultReceived(DBusPendingCall *pending, void *user_data)
1761 QDBusPendingCallPrivate *call = reinterpret_cast<QDBusPendingCallPrivate *>(user_data);
1762 Q_ASSERT(call->pending == pending);
1764 QDBusConnectionPrivate::processFinishedCall(call);
1768 void QDBusConnectionPrivate::waitForFinished(QDBusPendingCallPrivate *pcall)
1770 Q_ASSERT(pcall->pending);
1771 Q_ASSERT(!pcall->autoDelete);
1772 //Q_ASSERT(pcall->mutex.isLocked()); // there's no such function
1774 if (pcall->waitingForFinished) {
1775 // another thread is already waiting
1776 pcall->waitForFinishedCondition.wait(&pcall->mutex);
1778 pcall->waitingForFinished = true;
1779 pcall->mutex.unlock();
1782 QDBusDispatchLocker locker(PendingCallBlockAction, this);
1783 q_dbus_pending_call_block(pcall->pending);
1784 // QDBusConnectionPrivate::processFinishedCall() is called automatically
1786 pcall->mutex.lock();
1787 pcall->waitForFinishedCondition.wakeAll();
1791 static inline bool waitingForFinishedIsSet(QDBusPendingCallPrivate *call)
1793 const QMutexLocker locker(&call->mutex);
1794 return call->waitingForFinished;
1797 void QDBusConnectionPrivate::processFinishedCall(QDBusPendingCallPrivate *call)
1799 QDBusConnectionPrivate *connection = const_cast<QDBusConnectionPrivate *>(call->connection);
1801 QMutexLocker locker(&call->mutex);
1803 QDBusMessage &msg = call->replyMessage;
1804 if (call->pending) {
1805 // decode the message
1806 DBusMessage *reply = q_dbus_pending_call_steal_reply(call->pending);
1807 msg = QDBusMessagePrivate::fromDBusMessage(reply, connection->capabilities);
1808 q_dbus_message_unref(reply);
1810 qDBusDebug() << connection << "got message reply (async):" << msg;
1812 // Check if the reply has the expected signature
1813 call->checkReceivedSignature();
1815 if (!call->receiver.isNull() && call->methodIdx != -1 && msg.type() == QDBusMessage::ReplyMessage) {
1816 // Deliver the return values of a remote function call.
1818 // There is only one connection and it is specified by idx
1819 // The slot must have the same parameter types that the message does
1820 // The slot may have less parameters than the message
1821 // The slot may optionally have one final parameter that is QDBusMessage
1822 // The slot receives read-only copies of the message (i.e., pass by value or by const-ref)
1824 QDBusCallDeliveryEvent *e = prepareReply(connection, call->receiver, call->methodIdx,
1825 call->metaTypes, msg);
1827 connection->postEventToThread(MessageResultReceivedAction, call->receiver, e);
1829 qDBusDebug() << "Deliver failed!";
1833 q_dbus_pending_call_unref(call->pending);
1838 // Are there any watchers?
1839 if (call->watcherHelper)
1840 call->watcherHelper->emitSignals(msg, call->sentMessage);
1842 if (msg.type() == QDBusMessage::ErrorMessage)
1843 emit connection->callWithCallbackFailed(QDBusError(msg), call->sentMessage);
1845 if (call->autoDelete) {
1846 Q_ASSERT(!waitingForFinishedIsSet(call)); // can't wait on a call with autoDelete!
1851 int QDBusConnectionPrivate::send(const QDBusMessage& message)
1853 if (QDBusMessagePrivate::isLocal(message))
1854 return -1; // don't send; the reply will be retrieved by the caller
1855 // through the d_ptr->localReply link
1858 DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &error);
1860 if (message.type() == QDBusMessage::MethodCallMessage)
1861 qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s",
1862 qPrintable(message.service()), qPrintable(message.path()),
1863 qPrintable(message.interface()), qPrintable(message.member()),
1864 qPrintable(error.message()));
1865 else if (message.type() == QDBusMessage::SignalMessage)
1866 qWarning("QDBusConnection: error: could not send signal path \"%s\" interface \"%s\" member \"%s\": %s",
1867 qPrintable(message.path()), qPrintable(message.interface()),
1868 qPrintable(message.member()),
1869 qPrintable(error.message()));
1871 qWarning("QDBusConnection: error: could not send %s message to service \"%s\": %s",
1872 message.type() == QDBusMessage::ReplyMessage ? "reply" :
1873 message.type() == QDBusMessage::ErrorMessage ? "error" :
1874 "invalid", qPrintable(message.service()),
1875 qPrintable(error.message()));
1880 q_dbus_message_set_no_reply(msg, true); // the reply would not be delivered to anything
1882 qDBusDebug() << this << "sending message (no reply):" << message;
1884 bool isOk = q_dbus_connection_send(connection, msg, 0);
1887 serial = q_dbus_message_get_serial(msg);
1889 q_dbus_message_unref(msg);
1893 QDBusMessage QDBusConnectionPrivate::sendWithReply(const QDBusMessage &message,
1894 int sendMode, int timeout)
1897 if ((sendMode == QDBus::BlockWithGui || sendMode == QDBus::Block)
1898 && isServiceRegisteredByThread(message.service()))
1899 // special case for synchronous local calls
1900 return sendWithReplyLocal(message);
1902 if (!QCoreApplication::instance() || sendMode == QDBus::Block) {
1904 DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &err);
1906 qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s",
1907 qPrintable(message.service()), qPrintable(message.path()),
1908 qPrintable(message.interface()), qPrintable(message.member()),
1909 qPrintable(err.message()));
1911 return QDBusMessage::createError(err);
1914 qDBusDebug() << this << "sending message (blocking):" << message;
1915 QDBusErrorInternal error;
1916 DBusMessage *reply = q_dbus_connection_send_with_reply_and_block(connection, msg, timeout, error);
1918 q_dbus_message_unref(msg);
1921 lastError = err = error;
1922 return QDBusMessage::createError(err);
1925 QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(reply, capabilities);
1926 q_dbus_message_unref(reply);
1927 qDBusDebug() << this << "got message reply (blocking):" << amsg;
1930 } else { // use the event loop
1931 QDBusPendingCallPrivate *pcall = sendWithReplyAsync(message, timeout);
1934 if (pcall->replyMessage.type() == QDBusMessage::InvalidMessage) {
1935 pcall->watcherHelper = new QDBusPendingCallWatcherHelper;
1937 loop.connect(pcall->watcherHelper, SIGNAL(reply(QDBusMessage)), SLOT(quit()));
1938 loop.connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), SLOT(quit()));
1940 // enter the event loop and wait for a reply
1941 loop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents);
1944 QDBusMessage reply = pcall->replyMessage;
1945 lastError = QDBusError(reply); // set or clear error
1952 QDBusMessage QDBusConnectionPrivate::sendWithReplyLocal(const QDBusMessage &message)
1954 qDBusDebug() << this << "sending message via local-loop:" << message;
1956 QDBusMessage localCallMsg = QDBusMessagePrivate::makeLocal(*this, message);
1957 bool handled = handleMessage(localCallMsg);
1960 QString interface = message.interface();
1961 if (interface.isEmpty())
1962 interface = QLatin1String("<no-interface>");
1963 return QDBusMessage::createError(QDBusError::InternalError,
1964 QString::fromLatin1("Internal error trying to call %1.%2 at %3 (signature '%4'")
1965 .arg(interface, message.member(),
1966 message.path(), message.signature()));
1969 // if the message was handled, there might be a reply
1970 QDBusMessage localReplyMsg = QDBusMessagePrivate::makeLocalReply(*this, localCallMsg);
1971 if (localReplyMsg.type() == QDBusMessage::InvalidMessage) {
1972 qWarning("QDBusConnection: cannot call local method '%s' at object %s (with signature '%s') "
1973 "on blocking mode", qPrintable(message.member()), qPrintable(message.path()),
1974 qPrintable(message.signature()));
1975 return QDBusMessage::createError(
1976 QDBusError(QDBusError::InternalError,
1977 QLatin1String("local-loop message cannot have delayed replies")));
1981 qDBusDebug() << this << "got message via local-loop:" << localReplyMsg;
1982 return localReplyMsg;
1985 QDBusPendingCallPrivate *QDBusConnectionPrivate::sendWithReplyAsync(const QDBusMessage &message,
1988 if (isServiceRegisteredByThread(message.service())) {
1989 // special case for local calls
1990 QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate(message, this);
1991 pcall->replyMessage = sendWithReplyLocal(message);
1997 QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate(message, this);
1998 pcall->ref.store(0);
2001 DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &error);
2003 qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s",
2004 qPrintable(message.service()), qPrintable(message.path()),
2005 qPrintable(message.interface()), qPrintable(message.member()),
2006 qPrintable(error.message()));
2007 pcall->replyMessage = QDBusMessage::createError(error);
2012 qDBusDebug() << this << "sending message (async):" << message;
2013 DBusPendingCall *pending = 0;
2015 QDBusDispatchLocker locker(SendWithReplyAsyncAction, this);
2016 if (q_dbus_connection_send_with_reply(connection, msg, &pending, timeout)) {
2018 q_dbus_message_unref(msg);
2020 pcall->pending = pending;
2021 q_dbus_pending_call_set_notify(pending, qDBusResultReceived, pcall, 0);
2025 // we're probably disconnected at this point
2026 lastError = error = QDBusError(QDBusError::Disconnected, QLatin1String("Not connected to server"));
2029 lastError = error = QDBusError(QDBusError::NoMemory, QLatin1String("Out of memory"));
2032 q_dbus_message_unref(msg);
2033 pcall->replyMessage = QDBusMessage::createError(error);
2037 int QDBusConnectionPrivate::sendWithReplyAsync(const QDBusMessage &message, QObject *receiver,
2038 const char *returnMethod, const char *errorMethod,
2041 QDBusPendingCallPrivate *pcall = sendWithReplyAsync(message, timeout);
2044 // has it already finished with success (dispatched locally)?
2045 if (pcall->replyMessage.type() == QDBusMessage::ReplyMessage) {
2046 pcall->setReplyCallback(receiver, returnMethod);
2047 processFinishedCall(pcall);
2052 // either it hasn't finished or it has finished with error
2054 pcall->watcherHelper = new QDBusPendingCallWatcherHelper;
2055 connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), receiver, errorMethod,
2056 Qt::QueuedConnection);
2057 pcall->watcherHelper->moveToThread(thread());
2060 // has it already finished and is an error reply message?
2061 if (pcall->replyMessage.type() == QDBusMessage::ErrorMessage) {
2062 processFinishedCall(pcall);
2067 pcall->autoDelete = true;
2069 pcall->setReplyCallback(receiver, returnMethod);
2074 bool QDBusConnectionPrivate::connectSignal(const QString &service,
2075 const QString &path, const QString &interface, const QString &name,
2076 const QStringList &argumentMatch, const QString &signature,
2077 QObject *receiver, const char *slot)
2080 QDBusConnectionPrivate::SignalHook hook;
2082 QString name2 = name;
2086 hook.signature = signature;
2087 if (!prepareHook(hook, key, service, path, interface, name, argumentMatch, receiver, slot, 0, false))
2088 return false; // don't connect
2090 // avoid duplicating:
2091 QDBusConnectionPrivate::SignalHookHash::ConstIterator it = signalHooks.constFind(key);
2092 QDBusConnectionPrivate::SignalHookHash::ConstIterator end = signalHooks.constEnd();
2093 for ( ; it != end && it.key() == key; ++it) {
2094 const QDBusConnectionPrivate::SignalHook &entry = it.value();
2095 if (entry.service == hook.service &&
2096 entry.path == hook.path &&
2097 entry.signature == hook.signature &&
2098 entry.obj == hook.obj &&
2099 entry.midx == hook.midx &&
2100 entry.argumentMatch == hook.argumentMatch) {
2101 // no need to compare the parameters if it's the same slot
2102 return true; // already there
2106 connectSignal(key, hook);
2110 void QDBusConnectionPrivate::connectSignal(const QString &key, const SignalHook &hook)
2112 signalHooks.insertMulti(key, hook);
2113 connect(hook.obj, SIGNAL(destroyed(QObject*)), SLOT(objectDestroyed(QObject*)),
2114 Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
2116 MatchRefCountHash::iterator it = matchRefCounts.find(hook.matchRule);
2118 if (it != matchRefCounts.end()) { // Match already present
2119 it.value() = it.value() + 1;
2123 matchRefCounts.insert(hook.matchRule, 1);
2126 if (mode != QDBusConnectionPrivate::PeerMode) {
2127 qDBusDebug("Adding rule: %s", hook.matchRule.constData());
2128 q_dbus_bus_add_match(connection, hook.matchRule, NULL);
2130 // Successfully connected the signal
2131 // Do we need to watch for this name?
2132 if (shouldWatchService(hook.service)) {
2133 WatchedServicesHash::mapped_type &data = watchedServices[hook.service];
2134 if (++data.refcount == 1) {
2135 // we need to watch for this service changing
2136 connectSignal(dbusServiceString(), QString(), dbusInterfaceString(),
2137 QLatin1String("NameOwnerChanged"), QStringList() << hook.service, QString(),
2138 this, SLOT(serviceOwnerChangedNoLock(QString,QString,QString)));
2139 data.owner = getNameOwnerNoCache(hook.service);
2140 qDBusDebug() << this << "Watching service" << hook.service << "for owner changes (current owner:"
2141 << data.owner << ")";
2148 bool QDBusConnectionPrivate::disconnectSignal(const QString &service,
2149 const QString &path, const QString &interface, const QString &name,
2150 const QStringList &argumentMatch, const QString &signature,
2151 QObject *receiver, const char *slot)
2154 QDBusConnectionPrivate::SignalHook hook;
2156 QString name2 = name;
2160 hook.signature = signature;
2161 if (!prepareHook(hook, key, service, path, interface, name, argumentMatch, receiver, slot, 0, false))
2162 return false; // don't disconnect
2164 // avoid duplicating:
2165 QDBusConnectionPrivate::SignalHookHash::Iterator it = signalHooks.find(key);
2166 QDBusConnectionPrivate::SignalHookHash::Iterator end = signalHooks.end();
2167 for ( ; it != end && it.key() == key; ++it) {
2168 const QDBusConnectionPrivate::SignalHook &entry = it.value();
2169 if (entry.service == hook.service &&
2170 entry.path == hook.path &&
2171 entry.signature == hook.signature &&
2172 entry.obj == hook.obj &&
2173 entry.midx == hook.midx &&
2174 entry.argumentMatch == hook.argumentMatch) {
2175 // no need to compare the parameters if it's the same slot
2176 disconnectSignal(it);
2177 return true; // it was there
2181 // the slot was not found
2185 QDBusConnectionPrivate::SignalHookHash::Iterator
2186 QDBusConnectionPrivate::disconnectSignal(SignalHookHash::Iterator &it)
2188 const SignalHook &hook = it.value();
2191 MatchRefCountHash::iterator i = matchRefCounts.find(hook.matchRule);
2192 if (i == matchRefCounts.end()) {
2193 qWarning("QDBusConnectionPrivate::disconnectSignal: MatchRule not found in matchRefCounts!!");
2195 if (i.value() == 1) {
2197 matchRefCounts.erase(i);
2200 i.value() = i.value() - 1;
2204 // we don't care about errors here
2205 if (connection && erase) {
2206 if (mode != QDBusConnectionPrivate::PeerMode) {
2207 qDBusDebug("Removing rule: %s", hook.matchRule.constData());
2208 q_dbus_bus_remove_match(connection, hook.matchRule, NULL);
2210 // Successfully disconnected the signal
2211 // Were we watching for this name?
2212 WatchedServicesHash::Iterator sit = watchedServices.find(hook.service);
2213 if (sit != watchedServices.end()) {
2214 if (--sit.value().refcount == 0) {
2215 watchedServices.erase(sit);
2216 disconnectSignal(dbusServiceString(), QString(), dbusInterfaceString(),
2217 QLatin1String("NameOwnerChanged"), QStringList() << hook.service, QString(),
2218 this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
2225 return signalHooks.erase(it);
2228 void QDBusConnectionPrivate::registerObject(const ObjectTreeNode *node)
2230 connect(node->obj, SIGNAL(destroyed(QObject*)), SLOT(objectDestroyed(QObject*)),
2231 Qt::DirectConnection);
2233 if (node->flags & (QDBusConnection::ExportAdaptors
2234 | QDBusConnection::ExportScriptableSignals
2235 | QDBusConnection::ExportNonScriptableSignals)) {
2236 QDBusAdaptorConnector *connector = qDBusCreateAdaptorConnector(node->obj);
2238 if (node->flags & (QDBusConnection::ExportScriptableSignals
2239 | QDBusConnection::ExportNonScriptableSignals)) {
2240 connector->disconnectAllSignals(node->obj);
2241 connector->connectAllSignals(node->obj);
2244 // disconnect and reconnect to avoid duplicates
2245 connector->disconnect(SIGNAL(relaySignal(QObject*,const QMetaObject*,int,QVariantList)),
2246 this, SLOT(relaySignal(QObject*,const QMetaObject*,int,QVariantList)));
2247 connect(connector, SIGNAL(relaySignal(QObject*,const QMetaObject*,int,QVariantList)),
2248 this, SLOT(relaySignal(QObject*,const QMetaObject*,int,QVariantList)),
2249 Qt::DirectConnection);
2253 void QDBusConnectionPrivate::connectRelay(const QString &service,
2254 const QString &path, const QString &interface,
2255 QDBusAbstractInterface *receiver,
2256 const QMetaMethod &signal)
2258 // this function is called by QDBusAbstractInterface when one of its signals is connected
2259 // we set up a relay from D-Bus into it
2264 sig.append(QSIGNAL_CODE + '0');
2265 sig.append(signal.methodSignature());
2266 if (!prepareHook(hook, key, service, path, interface, QString(), QStringList(), receiver, sig,
2267 QDBusAbstractInterface::staticMetaObject.methodCount(), true))
2268 return; // don't connect
2270 // add it to our list:
2271 QDBusWriteLocker locker(ConnectRelayAction, this);
2272 SignalHookHash::ConstIterator it = signalHooks.constFind(key);
2273 SignalHookHash::ConstIterator end = signalHooks.constEnd();
2274 for ( ; it != end && it.key() == key; ++it) {
2275 const SignalHook &entry = it.value();
2276 if (entry.service == hook.service &&
2277 entry.path == hook.path &&
2278 entry.signature == hook.signature &&
2279 entry.obj == hook.obj &&
2280 entry.midx == hook.midx)
2281 return; // already there, no need to re-add
2284 connectSignal(key, hook);
2287 void QDBusConnectionPrivate::disconnectRelay(const QString &service,
2288 const QString &path, const QString &interface,
2289 QDBusAbstractInterface *receiver,
2290 const QMetaMethod &signal)
2292 // this function is called by QDBusAbstractInterface when one of its signals is disconnected
2293 // we remove relay from D-Bus into it
2298 sig.append(QSIGNAL_CODE + '0');
2299 sig.append(signal.methodSignature());
2300 if (!prepareHook(hook, key, service, path, interface, QString(), QStringList(), receiver, sig,
2301 QDBusAbstractInterface::staticMetaObject.methodCount(), true))
2302 return; // don't connect
2304 // remove it from our list:
2305 QDBusWriteLocker locker(DisconnectRelayAction, this);
2306 SignalHookHash::Iterator it = signalHooks.find(key);
2307 SignalHookHash::Iterator end = signalHooks.end();
2308 for ( ; it != end && it.key() == key; ++it) {
2309 const SignalHook &entry = it.value();
2310 if (entry.service == hook.service &&
2311 entry.path == hook.path &&
2312 entry.signature == hook.signature &&
2313 entry.obj == hook.obj &&
2314 entry.midx == hook.midx) {
2316 disconnectSignal(it);
2321 qWarning("QDBusConnectionPrivate::disconnectRelay called for a signal that was not found");
2324 QString QDBusConnectionPrivate::getNameOwner(const QString& serviceName)
2326 if (QDBusUtil::isValidUniqueConnectionName(serviceName))
2332 // acquire a read lock for the cache
2333 QReadLocker locker(&lock);
2334 WatchedServicesHash::ConstIterator it = watchedServices.constFind(serviceName);
2335 if (it != watchedServices.constEnd())
2340 return getNameOwnerNoCache(serviceName);
2343 QString QDBusConnectionPrivate::getNameOwnerNoCache(const QString &serviceName)
2345 QDBusMessage msg = QDBusMessage::createMethodCall(dbusServiceString(),
2346 QLatin1String(DBUS_PATH_DBUS), dbusInterfaceString(),
2347 QLatin1String("GetNameOwner"));
2348 QDBusMessagePrivate::setParametersValidated(msg, true);
2350 QDBusMessage reply = sendWithReply(msg, QDBus::Block);
2351 if (reply.type() == QDBusMessage::ReplyMessage)
2352 return reply.arguments().at(0).toString();
2357 QDBusConnectionPrivate::findMetaObject(const QString &service, const QString &path,
2358 const QString &interface, QDBusError &error)
2360 // service must be a unique connection name
2361 if (!interface.isEmpty()) {
2362 QDBusReadLocker locker(FindMetaObject1Action, this);
2363 QDBusMetaObject *mo = cachedMetaObjects.value(interface, 0);
2368 // introspect the target object
2369 QDBusMessage msg = QDBusMessage::createMethodCall(service, path,
2370 QLatin1String(DBUS_INTERFACE_INTROSPECTABLE),
2371 QLatin1String("Introspect"));
2372 QDBusMessagePrivate::setParametersValidated(msg, true);
2374 QDBusMessage reply = sendWithReply(msg, QDBus::Block);
2376 // it doesn't exist yet, we have to create it
2377 QDBusWriteLocker locker(FindMetaObject2Action, this);
2378 QDBusMetaObject *mo = 0;
2379 if (!interface.isEmpty())
2380 mo = cachedMetaObjects.value(interface, 0);
2382 // maybe it got created when we switched from read to write lock
2386 if (reply.type() == QDBusMessage::ReplyMessage) {
2387 if (reply.signature() == QLatin1String("s"))
2388 // fetch the XML description
2389 xml = reply.arguments().at(0).toString();
2391 error = QDBusError(reply);
2393 if (reply.type() != QDBusMessage::ErrorMessage || error.type() != QDBusError::UnknownMethod)
2397 // release the lock and return
2398 QDBusMetaObject *result = QDBusMetaObject::createMetaObject(interface, xml,
2399 cachedMetaObjects, error);
2404 void QDBusConnectionPrivate::registerService(const QString &serviceName)
2406 QDBusWriteLocker locker(RegisterServiceAction, this);
2407 registerServiceNoLock(serviceName);
2410 void QDBusConnectionPrivate::registerServiceNoLock(const QString &serviceName)
2412 serviceNames.append(serviceName);
2415 void QDBusConnectionPrivate::unregisterService(const QString &serviceName)
2417 QDBusWriteLocker locker(UnregisterServiceAction, this);
2418 unregisterServiceNoLock(serviceName);
2421 void QDBusConnectionPrivate::unregisterServiceNoLock(const QString &serviceName)
2423 serviceNames.removeAll(serviceName);
2426 bool QDBusConnectionPrivate::isServiceRegisteredByThread(const QString &serviceName) const
2428 if (!serviceName.isEmpty() && serviceName == baseService)
2430 QStringList copy = serviceNames;
2431 return copy.contains(serviceName);
2434 void QDBusConnectionPrivate::postEventToThread(int action, QObject *object, QEvent *ev)
2436 QDBusLockerBase::reportThreadAction(action, QDBusLockerBase::BeforePost, this);
2437 QCoreApplication::postEvent(object, ev);
2438 QDBusLockerBase::reportThreadAction(action, QDBusLockerBase::AfterPost, this);
2443 #endif // QT_NO_DBUS