1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtDBus module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <qcoreapplication.h>

    43 #include <qdebug.h>

    44 #include <qmetaobject.h>

    45 #include <qobject.h>

    46 #include <qsocketnotifier.h>

    47 #include <qstringlist.h>

    48 #include <qtimer.h>

    49 #include <qthread.h>

    50 

    51 #include "qdbusargument.h"

    52 #include "qdbusconnection_p.h"

    53 #include "qdbusinterface_p.h"

    54 #include "qdbusmessage.h"

    55 #include "qdbusmetatype.h"

    56 #include "qdbusmetatype_p.h"

    57 #include "qdbusabstractadaptor.h"

    58 #include "qdbusabstractadaptor_p.h"

    59 #include "qdbusutil_p.h"

    60 #include "qdbusmessage_p.h"

    61 #include "qdbuscontext_p.h"

    62 #include "qdbuspendingcall_p.h"

    63 #include "qdbusintegrator_p.h"

    64 

    65 #include "qdbusthreaddebug_p.h"

    66 

    67 QT_BEGIN_NAMESPACE

    68 

    69 static bool isDebugging;

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

    71 

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

    73 {

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

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

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

    77     dbg.nospace() << ')';

    78     return dbg.space();

    79 }

    80 

    81 #if QDBUS_THREAD_DEBUG

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

    83 {

    84     dbg.nospace() << "QDBusConnection("

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

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

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

    88                   << ", thread=";

    89     if (conn->thread() == QThread::currentThread())

    90         dbg.nospace() << "same thread";

    91     else

    92         dbg.nospace() << conn->thread();

    93     dbg.nospace() << ')';

    94     return dbg.space();

    95 }

    96 

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

    98 {

    99     qDBusDebug() << QThread::currentThread()

   100                  << "QtDBus threading action" << action

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

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

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

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

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

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

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

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

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

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

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

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

   113                      "condition unknown")

   114                  << "in connection" << conn;

   115 }

   116 Q_AUTOTEST_EXPORT qdbusThreadDebugFunc qdbusThreadDebug = 0;

   117 #endif

   118 

   119 typedef void (*QDBusSpyHook)(const QDBusMessage&);

   120 typedef QVarLengthArray<QDBusSpyHook, 4> QDBusSpyHookList;

   121 Q_GLOBAL_STATIC(QDBusSpyHookList, qDBusSpyHookList)

   122 

   123 extern "C" {

   124 

   125     // libdbus-1 callbacks

   126 

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

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

   129 {

   130     Q_ASSERT(timeout);

   131     Q_ASSERT(data);

   132 

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

   134 

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

   136 

   137     if (!q_dbus_timeout_get_enabled(timeout))

   138         return true;

   139 

   140     QDBusWatchAndTimeoutLocker locker(AddTimeoutAction, d);

   141     if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {

   142         // correct thread

   143         return qDBusRealAddTimeout(d, timeout, q_dbus_timeout_get_interval(timeout));

   144     } else {

   145         // wrong thread: sync back

   146         QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;

   147         ev->subtype = QDBusConnectionCallbackEvent::AddTimeout;

   148         d->timeoutsPendingAdd.append(qMakePair(timeout, q_dbus_timeout_get_interval(timeout)));

   149         d->postEventToThread(AddTimeoutAction, d, ev);

   150         return true;

   151     }

   152 }

   153 

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

   155 {

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

   157 

   158     int timerId = d->startTimer(ms);

   159     if (!timerId)

   160         return false;

   161 

   162     d->timeouts[timerId] = timeout;

   163     return true;

   164 }

   165 

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

   167 {

   168     Q_ASSERT(timeout);

   169     Q_ASSERT(data);

   170 

   171   //  qDebug("removeTimeout");

   172 

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

   174 

   175     QDBusWatchAndTimeoutLocker locker(RemoveTimeoutAction, d);

   176 

   177     // is it pending addition?

   178     QDBusConnectionPrivate::PendingTimeoutList::iterator pit = d->timeoutsPendingAdd.begin();

   179     while (pit != d->timeoutsPendingAdd.end()) {

   180         if (pit->first == timeout)

   181             pit = d->timeoutsPendingAdd.erase(pit);

   182         else

   183             ++pit;

   184     }

   185 

   186     // is it a running timer?

   187     bool correctThread = QCoreApplication::instance() && QThread::currentThread() == d->thread();

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

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

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

   191             if (correctThread) {

   192                 // correct thread

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

   194             } else {

   195                 // incorrect thread or no application, post an event for later

   196                 QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;

   197                 ev->subtype = QDBusConnectionCallbackEvent::KillTimer;

   198                 ev->timerId = it.key();

   199                 d->postEventToThread(KillTimerAction, d, ev);

   200             }

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

   202             break;

   203         } else {

   204             ++it;

   205         }

   206     }

   207 }

   208 

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

   210 {

   211     Q_ASSERT(timeout);

   212     Q_ASSERT(data);

   213 

   214     //qDebug("ToggleTimeout");

   215 

   216     qDBusRemoveTimeout(timeout, data);

   217     qDBusAddTimeout(timeout, data);

   218 }

   219 

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

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

   222 {

   223     Q_ASSERT(watch);

   224     Q_ASSERT(data);

   225 

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

   227 

   228     int flags = q_dbus_watch_get_flags(watch);

   229     int fd = q_dbus_watch_get_fd(watch);

   230 

   231     if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {

   232         return qDBusRealAddWatch(d, watch, flags, fd);

   233     } else {

   234         QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;

   235         ev->subtype = QDBusConnectionCallbackEvent::AddWatch;

   236         ev->watch = watch;

   237         ev->fd = fd;

   238         ev->extra = flags;

   239         d->postEventToThread(AddWatchAction, d, ev);

   240         return true;

   241     }

   242 }

   243 

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

   245 {

   246     QDBusConnectionPrivate::Watcher watcher;

   247 

   248     QDBusWatchAndTimeoutLocker locker(AddWatchAction, d);

   249     if (flags & DBUS_WATCH_READABLE) {

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

   251         watcher.watch = watch;

   252         if (QCoreApplication::instance()) {

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

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

   255             d->connect(watcher.read, SIGNAL(activated(int)), SLOT(socketRead(int)));

   256         }

   257     }

   258     if (flags & DBUS_WATCH_WRITABLE) {

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

   260         watcher.watch = watch;

   261         if (QCoreApplication::instance()) {

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

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

   264             d->connect(watcher.write, SIGNAL(activated(int)), SLOT(socketWrite(int)));

   265         }

   266     }

   267     d->watchers.insertMulti(fd, watcher);

   268 

   269     return true;

   270 }

   271 

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

   273 {

   274     Q_ASSERT(watch);

   275     Q_ASSERT(data);

   276 

   277     //qDebug("remove watch");

   278 

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

   280     int fd = q_dbus_watch_get_fd(watch);

   281 

   282     QDBusWatchAndTimeoutLocker locker(RemoveWatchAction, d);

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

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

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

   286             if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {

   287                 // correct thread, delete the socket notifiers

   288                 delete i.value().read;

   289                 delete i.value().write;

   290             } else {

   291                 // incorrect thread or no application, use delete later

   292                 if (i->read)

   293                     i->read->deleteLater();

   294                 if (i->write)

   295                     i->write->deleteLater();

   296             }

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

   298         } else {

   299             ++i;

   300         }

   301     }

   302 }

   303 

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

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

   306 {

   307     Q_ASSERT(watch);

   308     Q_ASSERT(data);

   309 

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

   311     int fd = q_dbus_watch_get_fd(watch);

   312 

   313     if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {

   314         qDBusRealToggleWatch(d, watch, fd);

   315     } else {

   316         QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;

   317         ev->subtype = QDBusConnectionCallbackEvent::ToggleWatch;

   318         ev->watch = watch;

   319         ev->fd = fd;

   320         d->postEventToThread(ToggleWatchAction, d, ev);

   321     }

   322 }

   323 

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

   325 {

   326     QDBusWatchAndTimeoutLocker locker(ToggleWatchAction, d);

   327 

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

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

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

   331             bool enabled = q_dbus_watch_get_enabled(watch);

   332             int flags = q_dbus_watch_get_flags(watch);

   333 

   334             //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);

   335 

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

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

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

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

   340             return;

   341         }

   342         ++i;

   343     }

   344 }

   345 

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

   347 {

   348     Q_ASSERT(connection);

   349     Q_UNUSED(connection);

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

   351 

   352     static int slotId; // 0 is QObject::deleteLater()

   353     if (!slotId) {

   354         // it's ok to do this: there's no race condition because the store is atomic

   355         // and we always set to the same value

   356         slotId = QDBusConnectionPrivate::staticMetaObject.indexOfSlot("doDispatch()");

   357     }

   358 

   359     //qDBusDebug() << "Updating dispatcher status" << slotId;

   360     if (new_status == DBUS_DISPATCH_DATA_REMAINS)

   361         QDBusConnectionPrivate::staticMetaObject.method(slotId).

   362             invoke(d, Qt::QueuedConnection);

   363 }

   364 

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

   366 {

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

   368     Q_ASSERT(server); Q_UNUSED(server);

   369     Q_ASSERT(connection);

   370     Q_ASSERT(data);

   371 

   372     // keep the connection alive

   373     q_dbus_connection_ref(connection);

   374     QDBusConnectionPrivate *d = new QDBusConnectionPrivate;

   375     

   376     // setConnection does the error handling for us

   377     QDBusErrorInternal error;

   378     d->setPeer(connection, error);

   379 

   380     QDBusConnection retval = QDBusConnectionPrivate::q(d);

   381     d->setBusService(retval);

   382 

   383     //d->name = QString::number(reinterpret_cast<int>(d));

   384     //d->setConnection(d->name, d); 

   385 

   386     // make QDBusServer emit the newConnection signal

   387     QDBusConnectionPrivate *server_d = static_cast<QDBusConnectionPrivate *>(data);

   388     server_d->serverConnection(retval);

   389 }

   390 

   391 } // extern "C"

   392 

   393 static QByteArray buildMatchRule(const QString &service, const QString & /*owner*/,

   394                                  const QString &objectPath, const QString &interface,

   395                                  const QString &member, const QString & /*signature*/)

   396 {

   397     QString result = QLatin1String("type='signal',");

   398     QString keyValue = QLatin1String("%1='%2',");

   399 

   400     if (!service.isEmpty())

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

   402     if (!objectPath.isEmpty())

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

   404     if (!interface.isEmpty())

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

   406     if (!member.isEmpty())

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

   408 

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

   410     return result.toLatin1();

   411 }

   412 

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

   414                        const QString &fullpath, int &usedLength,

   415                        QDBusConnectionPrivate::ObjectTreeNode &result)

   416 {

   417     int start = 0;

   418     int length = fullpath.length();

   419     if (fullpath.at(0) == QLatin1Char('/'))

   420         start = 1;

   421 

   422     // walk the object tree

   423     const QDBusConnectionPrivate::ObjectTreeNode *node = root;

   424     while (start < length && node && !(node->flags & QDBusConnection::ExportChildObjects)) {

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

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

   427         QStringRef pathComponent(&fullpath, start, end - start);

   428 

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

   430             qLowerBound(node->children.constBegin(), node->children.constEnd(), pathComponent);

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

   432             // match

   433             node = it;

   434         else

   435             node = 0;

   436 

   437         start = end + 1;

   438     }

   439 

   440     // found our object

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

   442     if (node) {

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

   444             result = *node;

   445         else

   446             // there really is no object here

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

   448             node = 0;

   449     }

   450     return node;

   451 }

   452 

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

   454                                 const QString &fullpath, int start)

   455 {

   456     int length = fullpath.length();

   457 

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

   459     const QDBusConnectionPrivate::ObjectTreeNode *node = root;

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

   461         QObject *obj = node->obj;

   462 

   463         while (obj) {

   464             if (start >= length)

   465                 // we're at the correct level

   466                 return obj;

   467 

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

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

   470             QStringRef pathComponent(&fullpath, start, pos - start);

   471 

   472             const QObjectList children = obj->children();

   473 

   474             // find a child with the proper name

   475             QObject *next = 0;

   476             QObjectList::ConstIterator it = children.constBegin();

   477             QObjectList::ConstIterator end = children.constEnd();

   478             for ( ; it != end; ++it)

   479                 if ((*it)->objectName() == pathComponent) {

   480                     next = *it;

   481                     break;

   482                 }

   483 

   484             if (!next)

   485                 break;

   486 

   487             obj = next;

   488             start = pos + 1;

   489         }

   490     }

   491 

   492     // object not found

   493     return 0;

   494 }

   495 

   496 extern QDBUS_EXPORT void qDBusAddSpyHook(QDBusSpyHook);

   497 void qDBusAddSpyHook(QDBusSpyHook hook)

   498 {

   499     qDBusSpyHookList()->append(hook);

   500 }

   501 

   502 extern "C" {

   503 static DBusHandlerResult

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

   505 {

   506     Q_ASSERT(data);

   507     Q_UNUSED(connection);

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

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

   510         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

   511 

   512     QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(message);

   513     qDBusDebug() << QThread::currentThread() << "got message:" << amsg;

   514 

   515     return d->handleMessage(amsg) ?

   516         DBUS_HANDLER_RESULT_HANDLED :

   517         DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

   518 }

   519 }

   520 

   521 bool QDBusConnectionPrivate::handleMessage(const QDBusMessage &amsg)

   522 {

   523     const QDBusSpyHookList *list = qDBusSpyHookList();

   524     for (int i = 0; i < list->size(); ++i) {

   525         qDBusDebug() << "calling the message spy hook";

   526         (*(*list)[i])(amsg);

   527     }

   528 

   529     switch (amsg.type()) {

   530     case QDBusMessage::SignalMessage:

   531         handleSignal(amsg);

   532         return true;

   533         break;

   534     case QDBusMessage::MethodCallMessage:

   535         handleObjectCall(amsg);

   536         return true;

   537     case QDBusMessage::ReplyMessage:

   538     case QDBusMessage::ErrorMessage:

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

   540     case QDBusMessage::InvalidMessage:

   541         Q_ASSERT_X(false, "QDBusConnection", "Invalid message found when processing");

   542         break;

   543     }

   544 

   545     return false;

   546 }

   547 

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

   549 {

   550     QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator it = haystack.children.begin();

   551     QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator end = haystack.children.end();

   552     for ( ; it != end; ++it)

   553         huntAndDestroy(needle, *it);

   554 

   555     if (needle == haystack.obj) {

   556         haystack.obj = 0;

   557         haystack.flags = 0;

   558     }

   559 }

   560 

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

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

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

   564 {

   565     QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it = haystack.children.constBegin();

   566     QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator end = haystack.children.constEnd();

   567     for ( ; it != end; ++it)

   568         huntAndEmit(connection, msg, needle, *it, isScriptable, isAdaptor, path + QLatin1Char('/') + it->name);

   569 

   570     if (needle == haystack.obj) {

   571         // is this a signal we should relay?

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

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

   574         else if (!isAdaptor) {

   575             int mask = isScriptable

   576                        ? QDBusConnection::ExportScriptableSignals

   577                        : QDBusConnection::ExportNonScriptableSignals;

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

   579                 return;         // signal was not exported

   580         }

   581 

   582         QByteArray p = path.toLatin1();

   583         if (p.isEmpty())

   584             p = "/";

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

   586         DBusMessage *msg2 = q_dbus_message_copy(msg);

   587         q_dbus_message_set_path(msg2, p);

   588         q_dbus_connection_send(connection, msg2, 0);

   589         q_dbus_message_unref(msg2);

   590     }

   591 }

   592 

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

   594                     const QString &signature_, QList<int>& metaTypes)

   595 {

   596     QByteArray msgSignature = signature_.toLatin1();

   597 

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

   599         QMetaMethod mm = mo->method(idx);

   600 

   601         // check access:

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

   603             continue;

   604 

   605         // check type:

   606         if (mm.methodType() != QMetaMethod::Slot)

   607             continue;

   608 

   609         // check name:

   610         QByteArray slotname = mm.signature();

   611         int paren = slotname.indexOf('(');

   612         if (paren != name.length() || !slotname.startsWith(name))

   613             continue;

   614 

   615         int returnType = qDBusNameToTypeId(mm.typeName());

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

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

   618 

   619         // consistency check:

   620         if (isAsync && returnType != QMetaType::Void)

   621             continue;

   622 

   623         int inputCount = qDBusParametersForMethod(mm, metaTypes);

   624         if (inputCount == -1)

   625             continue;           // problem parsing

   626 

   627         metaTypes[0] = returnType;

   628         bool hasMessage = false;

   629         if (inputCount > 0 &&

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

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

   632             hasMessage = true;

   633             --inputCount;

   634         }

   635 

   636         // try to match the parameters

   637         int i;

   638         QByteArray reconstructedSignature;

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

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

   641             if (!typeSignature)

   642                 break;          // invalid

   643 

   644             reconstructedSignature += typeSignature;

   645             if (!msgSignature.startsWith(reconstructedSignature))

   646                 break;

   647         }

   648 

   649         if (reconstructedSignature != msgSignature)

   650             continue;           // we didn't match them all

   651 

   652         if (hasMessage)

   653             ++i;

   654 

   655         // make sure that the output parameters have signatures too

   656         if (returnType != 0 && QDBusMetaType::typeToSignature(returnType) == 0)

   657             continue;

   658 

   659         bool ok = true;

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

   661             if (QDBusMetaType::typeToSignature(metaTypes.at(i)) == 0)

   662                 ok = false;

   663         if (!ok)

   664             continue;

   665 

   666         // consistency check:

   667         if (isAsync && metaTypes.count() > i + 1)

   668             continue;

   669 

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

   671             continue;           // not exported

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

   673             continue;           // not exported

   674 

   675         // if we got here, this slot matched

   676         return idx;

   677     }

   678 

   679     // no slot matched

   680     return -1;

   681 }

   682 

   683 QDBusCallDeliveryEvent* QDBusConnectionPrivate::prepareReply(QDBusConnectionPrivate *target,

   684                                                              QObject *object, int idx,

   685                                                              const QList<int> &metaTypes,

   686                                                              const QDBusMessage &msg)

   687 {

   688     Q_ASSERT(object);

   689     Q_UNUSED(object);

   690 

   691     int n = metaTypes.count() - 1;

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

   693         --n;

   694 

   695     // check that types match

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

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

   698             msg.arguments().at(i).userType() != qMetaTypeId<QDBusArgument>())

   699             return 0;           // no match

   700 

   701     // we can deliver

   702     // prepare for the call

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

   704 }

   705 

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

   707                                             const QDBusMessage &msg)

   708 {

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

   710     // that was received from D-Bus

   711     //

   712     // Signals are delivered to slots if the parameters match

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

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

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

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

   717     if (call)

   718         postEventToThread(ActivateSignalAction, hook.obj, call);

   719 }

   720 

   721 bool QDBusConnectionPrivate::activateCall(QObject* object, int flags, const QDBusMessage &msg)

   722 {

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

   724     // to a slot on the object.

   725     //

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

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

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

   729     //  - optionally has one more parameter of type QDBusMessage

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

   731     // the first type of QDBusMessage is delivered.

   732     //

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

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

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

   736     // QDBusMessage parameter, it cannot generate a reply.

   737     //

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

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

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

   741     // positions.

   742 

   743     static const char cachePropertyName[] = "_qdbus_slotCache";

   744 

   745     if (!object)

   746         return false;

   747 

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

   749                "QDBusConnection: internal threading error",

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

   751 

   752     QDBusSlotCache slotCache =

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

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

   755     if (!signature.isEmpty()) {

   756         cacheKey.reserve(cacheKey.length() + 1 + signature.length());

   757         cacheKey += QLatin1Char('.');

   758         cacheKey += signature;

   759     }

   760 

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

   762     while (cacheIt != slotCache.hash.constEnd() && cacheIt->flags != flags &&

   763            cacheIt.key() == cacheKey)

   764         ++cacheIt;

   765     if (cacheIt == slotCache.hash.constEnd() || cacheIt.key() != cacheKey)

   766     {

   767         // not cached, analyse the meta object

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

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

   770 

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

   772         QDBusSlotCache::Data slotData;

   773         slotData.flags = flags;

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

   775         if (slotData.slotIdx == -1) {

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

   777             // try with no parameters, but with a QDBusMessage

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

   779             if (slotData.metaTypes.count() != 2 ||

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

   781                 // not found

   782                 // save the negative lookup

   783                 slotData.slotIdx = -1;

   784                 slotData.metaTypes.clear();

   785                 slotCache.hash.insert(cacheKey, slotData);

   786                 object->setProperty(cachePropertyName, qVariantFromValue(slotCache));

   787                 return false;

   788             }

   789         }

   790 

   791         // save to the cache

   792         slotCache.hash.insert(cacheKey, slotData);

   793         object->setProperty(cachePropertyName, qVariantFromValue(slotCache));

   794 

   795         // found the slot to be called

   796         deliverCall(object, flags, msg, slotData.metaTypes, slotData.slotIdx);

   797         return true;

   798     } else if (cacheIt->slotIdx == -1) {

   799         // negative cache

   800         return false;

   801     } else {

   802         // use the cache

   803         deliverCall(object, flags, msg, cacheIt->metaTypes, cacheIt->slotIdx);

   804         return true;

   805     }

   806 }

   807 

   808 void QDBusConnectionPrivate::deliverCall(QObject *object, int /*flags*/, const QDBusMessage &msg,

   809                                          const QList<int> &metaTypes, int slotIdx)

   810 {

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

   812                "QDBusConnection: internal threading error",

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

   814 

   815     QVarLengthArray<void *, 10> params;

   816     params.reserve(metaTypes.count());

   817 

   818     QVariantList auxParameters;

   819     // let's create the parameter list

   820 

   821     // first one is the return type -- add it below

   822     params.append(0);

   823 

   824     // add the input parameters

   825     int i;

   826     int pCount = qMin(msg.arguments().count(), metaTypes.count() - 1);

   827     for (i = 1; i <= pCount; ++i) {

   828         int id = metaTypes[i];

   829         if (id == QDBusMetaTypeId::message)

   830             break;

   831 

   832         const QVariant &arg = msg.arguments().at(i - 1);

   833         if (arg.userType() == id)

   834             // no conversion needed

   835             params.append(const_cast<void *>(arg.constData()));

   836         else if (arg.userType() == qMetaTypeId<QDBusArgument>()) {

   837             // convert to what the function expects

   838             void *null = 0;

   839             auxParameters.append(QVariant(id, null));

   840 

   841             const QDBusArgument &in =

   842                 *reinterpret_cast<const QDBusArgument *>(arg.constData());

   843             QVariant &out = auxParameters[auxParameters.count() - 1];

   844 

   845             if (!QDBusMetaType::demarshall(in, out.userType(), out.data()))

   846                 qFatal("Internal error: demarshalling function for type '%s' (%d) failed!",

   847                        out.typeName(), out.userType());

   848 

   849             params.append(const_cast<void *>(out.constData()));

   850         } else {

   851             qFatal("Internal error: got invalid meta type %d (%s) "

   852                    "when trying to convert to meta type %d (%s)",

   853                    arg.userType(), QMetaType::typeName(arg.userType()),

   854                    id, QMetaType::typeName(id));

   855         }

   856     }

   857 

   858     bool takesMessage = false;

   859     if (metaTypes.count() > i && metaTypes[i] == QDBusMetaTypeId::message) {

   860         params.append(const_cast<void*>(static_cast<const void*>(&msg)));

   861         takesMessage = true;

   862         ++i;

   863     }

   864 

   865     // output arguments

   866     QVariantList outputArgs;

   867     void *null = 0;

   868     if (metaTypes[0] != QMetaType::Void) {

   869         QVariant arg(metaTypes[0], null);

   870         outputArgs.append( arg );

   871         params[0] = const_cast<void*>(outputArgs.at( outputArgs.count() - 1 ).constData());

   872     }

   873     for ( ; i < metaTypes.count(); ++i) {

   874         QVariant arg(metaTypes[i], null);

   875         outputArgs.append( arg );

   876         params.append(const_cast<void*>(outputArgs.at( outputArgs.count() - 1 ).constData()));

   877     }

   878 

   879     // make call:

   880     bool fail;

   881     if (!object) {

   882         fail = true;

   883     } else {

   884         // FIXME: save the old sender!

   885         QDBusContextPrivate context(QDBusConnection(this), msg);

   886         QDBusContextPrivate *old = QDBusContextPrivate::set(object, &context);

   887         QDBusConnectionPrivate::setSender(this);

   888 

   889         QPointer<QObject> ptr = object;

   890         fail = object->qt_metacall(QMetaObject::InvokeMetaMethod,

   891                                    slotIdx, params.data()) >= 0;

   892         QDBusConnectionPrivate::setSender(0);

   893 	// the object might be deleted in the slot

   894 	if (!ptr.isNull())

   895 	    QDBusContextPrivate::set(object, old);

   896     }

   897 

   898     // do we create a reply? Only if the caller is waiting for a reply and one hasn't been sent

   899     // yet.

   900     if (msg.isReplyRequired() && !msg.isDelayedReply()) {

   901         if (!fail) {

   902             // normal reply

   903             qDBusDebug() << QThread::currentThread() << "Automatically sending reply:" << outputArgs;

   904             send(msg.createReply(outputArgs));

   905         } else {

   906             // generate internal error

   907             qWarning("Internal error: Failed to deliver message");

   908             send(msg.createErrorReply(QDBusError::InternalError,

   909                                       QLatin1String("Failed to deliver message")));

   910         }

   911     }

   912 

   913     return;

   914 }

   915 

   916 extern bool qDBusInitThreads();

   917 

   918 QDBusConnectionPrivate::QDBusConnectionPrivate(QObject *p)

   919     : QObject(p), ref(1), mode(InvalidMode), connection(0), server(0), busService(0),

   920       watchAndTimeoutLock(QMutex::Recursive),

   921       rootNode(QString(QLatin1Char('/')))

   922 {

   923     static const bool threads = q_dbus_threads_init_default();

   924     static const int debugging = ::isDebugging = qgetenv("QDBUS_DEBUG").toInt();

   925     Q_UNUSED(threads)

   926     Q_UNUSED(debugging)

   927 

   928 #ifdef QDBUS_THREAD_DEBUG

   929     if (debugging > 1)

   930         qdbusThreadDebug = qdbusDefaultThreadDebug;

   931 #endif

   932 

   933     QDBusMetaTypeId::init();

   934 

   935     rootNode.flags = 0;

   936 

   937     connect(this, SIGNAL(serviceOwnerChanged(QString,QString,QString)),

   938             this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));

   939 }

   940 

   941 QDBusConnectionPrivate::~QDBusConnectionPrivate()

   942 {

   943     if (thread() && thread() != QThread::currentThread())

   944         qWarning("QDBusConnection(name=\"%s\")'s last reference in not in its creation thread! "

   945                  "Timer and socket errors will follow and the program will probably crash",

   946                  qPrintable(name));

   947 

   948     closeConnection();

   949     rootNode.children.clear();  // free resources

   950     qDeleteAll(cachedMetaObjects);

   951 

   952     if (server)

   953         q_dbus_server_unref(server);

   954     if (connection)

   955         q_dbus_connection_unref(connection);

   956 

   957     connection = 0;

   958     server = 0;

   959 }

   960 

   961 void QDBusConnectionPrivate::deleteYourself()

   962 {

   963     if (thread() && thread() != QThread::currentThread()) {

   964         // last reference dropped while not in the correct thread

   965         // ask the correct thread to delete

   966 

   967         // note: since we're posting an event to another thread, we

   968         // must consider deleteLater() to take effect immediately

   969         deleteLater();

   970     } else {

   971         delete this;

   972     }

   973 }

   974 

   975 void QDBusConnectionPrivate::closeConnection()

   976 {

   977     QDBusWriteLocker locker(CloseConnectionAction, this);

   978     ConnectionMode oldMode = mode;

   979     mode = InvalidMode; // prevent reentrancy

   980     baseService.clear();

   981 

   982     if (oldMode == ServerMode) {

   983         if (server) {

   984             q_dbus_server_disconnect(server);

   985         }

   986     } else if (oldMode == ClientMode || oldMode == PeerMode) {

   987         if (connection) {

   988             q_dbus_connection_close(connection);

   989             // send the "close" message

   990             while (q_dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS)

   991                 ;

   992         }

   993     }

   994 }

   995 

   996 void QDBusConnectionPrivate::checkThread()

   997 {

   998     if (!thread()) {

   999         if (QCoreApplication::instance())

  1000             moveToThread(QCoreApplication::instance()->thread());

  1001         else

  1002             qWarning("The thread that had QDBusConnection('%s') has died and there is no main thread",

  1003                      qPrintable(name));

  1004     }

  1005 }

  1006 

  1007 bool QDBusConnectionPrivate::handleError(const QDBusErrorInternal &error)

  1008 {

  1009     if (!error)

  1010         return false;           // no error

  1011 

  1012     //lock.lockForWrite();

  1013     lastError = error;

  1014     //lock.unlock();

  1015     return true;

  1016 }

  1017 

  1018 void QDBusConnectionPrivate::timerEvent(QTimerEvent *e)

  1019 {

  1020     {

  1021         QDBusWatchAndTimeoutLocker locker(TimerEventAction, this);

  1022         DBusTimeout *timeout = timeouts.value(e->timerId(), 0);

  1023         if (timeout)

  1024             q_dbus_timeout_handle(timeout);

  1025     }

  1026 

  1027     doDispatch();

  1028 }

  1029 

  1030 void QDBusConnectionPrivate::customEvent(QEvent *e)

  1031 {

  1032     Q_ASSERT(e->type() == QEvent::User);

  1033 

  1034     QDBusConnectionCallbackEvent *ev = static_cast<QDBusConnectionCallbackEvent *>(e);

  1035     QDBusLockerBase::reportThreadAction(int(AddTimeoutAction) + int(ev->subtype),

  1036                                         QDBusLockerBase::BeforeDeliver, this);

  1037     switch (ev->subtype)

  1038     {

  1039     case QDBusConnectionCallbackEvent::AddTimeout: {

  1040         QDBusWatchAndTimeoutLocker locker(RealAddTimeoutAction, this);

  1041         while (!timeoutsPendingAdd.isEmpty()) {

  1042             QPair<DBusTimeout *, int> entry = timeoutsPendingAdd.takeFirst();

  1043             qDBusRealAddTimeout(this, entry.first, entry.second);

  1044         }

  1045         break;

  1046     }

  1047 

  1048     case QDBusConnectionCallbackEvent::KillTimer:

  1049         killTimer(ev->timerId);

  1050         break;

  1051 

  1052     case QDBusConnectionCallbackEvent::AddWatch:

  1053         qDBusRealAddWatch(this, ev->watch, ev->extra, ev->fd);

  1054         break;

  1055 

  1056     case QDBusConnectionCallbackEvent::ToggleWatch:

  1057         qDBusRealToggleWatch(this, ev->watch, ev->fd);

  1058         break;

  1059     }

  1060     QDBusLockerBase::reportThreadAction(int(AddTimeoutAction) + int(ev->subtype),

  1061                                         QDBusLockerBase::AfterDeliver, this);

  1062 }

  1063 

  1064 void QDBusConnectionPrivate::doDispatch()

  1065 {

  1066     QDBusDispatchLocker locker(DoDispatchAction, this);

  1067     if (mode == ClientMode || mode == PeerMode)

  1068         while (q_dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS) ;

  1069 }

  1070 

  1071 void QDBusConnectionPrivate::socketRead(int fd)

  1072 {

  1073     QVarLengthArray<DBusWatch *, 2> pendingWatches;

  1074 

  1075     {

  1076         QDBusWatchAndTimeoutLocker locker(SocketReadAction, this);

  1077         WatcherHash::ConstIterator it = watchers.constFind(fd);

  1078         while (it != watchers.constEnd() && it.key() == fd) {

  1079             if (it->watch && it->read && it->read->isEnabled())

  1080                 pendingWatches.append(it.value().watch);

  1081             ++it;

  1082         }

  1083     }

  1084 

  1085     for (int i = 0; i < pendingWatches.size(); ++i)

  1086         if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_READABLE))

  1087             qDebug("OUT OF MEM");

  1088     doDispatch();

  1089 }

  1090 

  1091 void QDBusConnectionPrivate::socketWrite(int fd)

  1092 {

  1093     QVarLengthArray<DBusWatch *, 2> pendingWatches;

  1094 

  1095     {

  1096         QDBusWatchAndTimeoutLocker locker(SocketWriteAction, this);

  1097         WatcherHash::ConstIterator it = watchers.constFind(fd);

  1098         while (it != watchers.constEnd() && it.key() == fd) {

  1099             if (it->watch && it->write && it->write->isEnabled())

  1100                 pendingWatches.append(it.value().watch);

  1101             ++it;

  1102         }

  1103     }

  1104 

  1105     for (int i = 0; i < pendingWatches.size(); ++i)

  1106         if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_WRITABLE))

  1107             qDebug("OUT OF MEM");

  1108 }

  1109 

  1110 void QDBusConnectionPrivate::objectDestroyed(QObject *obj)

  1111 {

  1112     QDBusWriteLocker locker(ObjectDestroyedAction, this);

  1113     huntAndDestroy(obj, rootNode);

  1114 

  1115     SignalHookHash::iterator sit = signalHooks.begin();

  1116     while (sit != signalHooks.end()) {

  1117         if (static_cast<QObject *>(sit.value().obj) == obj)

  1118             sit = disconnectSignal(sit);

  1119         else

  1120             ++sit;

  1121     }

  1122 

  1123     obj->disconnect(this);

  1124 }

  1125 

  1126 void QDBusConnectionPrivate::relaySignal(QObject *obj, const QMetaObject *mo, int signalId,

  1127                                          const QVariantList &args)

  1128 {

  1129     QString interface = qDBusInterfaceFromMetaObject(mo);

  1130 

  1131     QMetaMethod mm = mo->method(signalId);

  1132     QByteArray memberName = mm.signature();

  1133     memberName.truncate(memberName.indexOf('('));

  1134