QDBusConnectionPrivate Class Reference

#include <qdbusconnection_p.h>

Inheritance diagram for QDBusConnectionPrivate:

Classes
struct	ObjectTreeNode
struct	SignalHook
struct	WatchedServiceData
struct	Watcher

Public Types
enum	ConnectionMode { InvalidMode, ServerMode, ClientMode, PeerMode }
typedef QHash< QByteArray, int >	MatchRefCountHash
typedef QHash< QString, QDBusMetaObject *>	MetaObjectHash
typedef QList< QPair< DBusTimeout *, int > >	PendingTimeoutList
typedef QMultiHash< QString, SignalHook >	SignalHookHash
typedef QHash< int, DBusTimeout * >	TimeoutHash
enum	TreeNodeType { Object = 0x0, VirtualObject = 0x01000000 }
typedef QHash< QString, WatchedServiceData >	WatchedServicesHash
typedef QMultiHash< int, Watcher >	WatcherHash

Public Slots
void	doDispatch ()
void	objectDestroyed (QObject *o)
void	relaySignal (QObject *obj, const QMetaObject *, int signalId, const QVariantList &args)
void	socketRead (int)
void	socketWrite (int)
Public Slots inherited from QObject
void	deleteLater ()
	Schedules this object for deletion. More...

Signals
void	callWithCallbackFailed (const QDBusError &error, const QDBusMessage &message)
void	newServerConnection (const QDBusConnection &connection)
void	serviceOwnerChanged (const QString &name, const QString &oldOwner, const QString &newOwner)
Signals inherited from QObject
void	destroyed (QObject *=0)
	This signal is emitted immediately before the object obj is destroyed, and can not be blocked. More...

Public Functions
void	closeConnection ()
void	connectRelay (const QString &service, const QString &path, const QString &interface, QDBusAbstractInterface *receiver, const char *signal)
bool	connectSignal (const QString &service, const QString &path, const QString &interface, const QString &name, const QStringList &argumentMatch, const QString &signature, QObject *receiver, const char *slot)
void	connectSignal (const QString &key, const SignalHook &hook)
void	deleteYourself ()
void	disconnectRelay (const QString &service, const QString &path, const QString &interface, QDBusAbstractInterface *receiver, const char *signal)
SignalHookHash::Iterator	disconnectSignal (SignalHookHash::Iterator &it)
bool	disconnectSignal (const QString &service, const QString &path, const QString &interface, const QString &name, const QStringList &argumentMatch, const QString &signature, QObject *receiver, const char *slot)
QDBusMetaObject *	findMetaObject (const QString &service, const QString &path, const QString &interface, QDBusError &error)
QString	getNameOwner (const QString &service)
bool	handleMessage (const QDBusMessage &msg)
void	postEventToThread (int action, QObject *target, QEvent *event)
	QDBusConnectionPrivate (QObject *parent=0)
void	registerObject (const ObjectTreeNode *node)
void	registerService (const QString &serviceName)
int	send (const QDBusMessage &message)
QDBusMessage	sendWithReply (const QDBusMessage &message, int mode, int timeout=-1)
QDBusPendingCallPrivate *	sendWithReplyAsync (const QDBusMessage &message, QObject *receiver, const char *returnMethod, const char *errorMethod, int timeout=-1)
QDBusMessage	sendWithReplyLocal (const QDBusMessage &message)
void	serverConnection (const QDBusConnection &connection)
void	setBusService (const QDBusConnection &connection)
void	setConnection (DBusConnection *connection, const QDBusErrorInternal &error)
void	setPeer (DBusConnection *connection, const QDBusErrorInternal &error)
void	setServer (DBusServer *server, const QDBusErrorInternal &error)
void	unregisterService (const QString &serviceName)
void	waitForFinished (QDBusPendingCallPrivate *pcall)
	~QDBusConnectionPrivate ()
Public Functions inherited from QObject
bool	blockSignals (bool b)
	If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). More...
const QObjectList &	children () const
	Returns a list of child objects. More...
bool	connect (const QObject *sender, const char *signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const
bool	disconnect (const char *signal=0, const QObject *receiver=0, const char *member=0)
bool	disconnect (const QObject *receiver, const char *member=0)
void	dumpObjectInfo ()
	Dumps information about signal connections, etc. More...
void	dumpObjectTree ()
	Dumps a tree of children to the debug output. More...
QList< QByteArray >	dynamicPropertyNames () const
	Returns the names of all properties that were dynamically added to the object using setProperty(). More...
virtual bool	event (QEvent *)
	This virtual function receives events to an object and should return true if the event e was recognized and processed. More...
virtual bool	eventFilter (QObject *, QEvent *)
	Filters events if this object has been installed as an event filter for the watched object. More...
template<typename T >
T	findChild (const QString &aName=QString()) const
	Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. More...
template<typename T >
QList< T >	findChildren (const QString &aName=QString()) const
	Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. More...
template<typename T >
QList< T >	findChildren (const QRegExp &re) const
bool	inherits (const char *classname) const
	Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false. More...
void	installEventFilter (QObject *)
	Installs an event filter filterObj on this object. More...
bool	isWidgetType () const
	Returns true if the object is a widget; otherwise returns false. More...
void	killTimer (int id)
	Kills the timer with timer identifier, id. More...
virtual const QMetaObject *	metaObject () const
	Returns a pointer to the meta-object of this object. More...
void	moveToThread (QThread *thread)
	Changes the thread affinity for this object and its children. More...
QString	objectName () const
QObject *	parent () const
	Returns a pointer to the parent object. More...
QVariant	property (const char *name) const
	Returns the value of the object's name property. More...
Q_INVOKABLE	QObject (QObject *parent=0)
	Constructs an object with parent object parent. More...
void	removeEventFilter (QObject *)
	Removes an event filter object obj from this object. More...
void	setObjectName (const QString &name)
void	setParent (QObject *)
	Makes the object a child of parent. More...
bool	setProperty (const char *name, const QVariant &value)
	Sets the value of the object's name property to value. More...
void	setUserData (uint id, QObjectUserData *data)
bool	signalsBlocked () const
	Returns true if signals are blocked; otherwise returns false. More...
int	startTimer (int interval)
	Starts a timer and returns a timer identifier, or returns zero if it could not start a timer. More...
QThread *	thread () const
	Returns the thread in which the object lives. More...
QObjectUserData *	userData (uint id) const
virtual	~QObject ()
	Destroys the object, deleting all its child objects. More...

Static Public Functions
static bool	checkReplyForDelivery (QDBusConnectionPrivate *target, QObject *object, int idx, const QList< int > &metaTypes, const QDBusMessage &msg)
static QDBusConnectionPrivate *	d (const QDBusConnection &q)
static int	findSlot (QObject *obj, const QByteArray &normalizedName, QList< int > &params)
static DBusHandlerResult	messageFilter (DBusConnection *, DBusMessage *, void *)
static bool	prepareHook (QDBusConnectionPrivate::SignalHook &hook, QString &key, const QString &service, const QString &path, const QString &interface, const QString &name, const QStringList &argMatch, QObject *receiver, const char *signal, int minMIdx, bool buildSignature)
static QDBusCallDeliveryEvent *	prepareReply (QDBusConnectionPrivate *target, QObject *object, int idx, const QList< int > &metaTypes, const QDBusMessage &msg)
static void	processFinishedCall (QDBusPendingCallPrivate *call)
static QDBusConnection	q (QDBusConnectionPrivate *connection)
static void	setSender (const QDBusConnectionPrivate *s)
Static Public Functions inherited from QObject
static bool	connect (const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
	Creates a connection of the given type from the signal in the sender object to the method in the receiver object. More...
static bool	connect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)
static bool	disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *member)
	Disconnects signal in object sender from method in object receiver. More...
static bool	disconnect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &member)
static uint	registerUserData ()
static QString	tr (const char *sourceText, const char *comment=0, int n=-1)
static QString	trUtf8 (const char *sourceText, const char *comment=0, int n=-1)

Public Variables
QString	baseService
QDBusConnectionInterface *	busService
MetaObjectHash	cachedMetaObjects
QMutex	callDeliveryMutex
QDBusCallDeliveryEvent *	callDeliveryState
QDBusConnection::ConnectionCapabilities	capabilities
DBusConnection *	connection
QMutex	dispatchLock
QDBusError	lastError
QReadWriteLock	lock
MatchRefCountHash	matchRefCounts
ConnectionMode	mode
QString	name
QAtomicInt	ref
ObjectTreeNode	rootNode
DBusServer *	server
QStringList	serverConnectionNames
QStringList	serviceNames
SignalHookHash	signalHooks
TimeoutHash	timeouts
PendingTimeoutList	timeoutsPendingAdd
QMutex	watchAndTimeoutLock
WatchedServicesHash	watchedServices
WatcherHash	watchers

Protected Functions
void	customEvent (QEvent *e)
	This event handler can be reimplemented in a subclass to receive custom events. More...
void	timerEvent (QTimerEvent *e)
	This event handler can be reimplemented in a subclass to receive timer events for the object. More...
Protected Functions inherited from QObject
virtual void	childEvent (QChildEvent *)
	This event handler can be reimplemented in a subclass to receive child events. More...
virtual void	connectNotify (const char *signal)
	This virtual function is called when something has been connected to signal in this object. More...
virtual void	disconnectNotify (const char *signal)
	This virtual function is called when something has been disconnected from signal in this object. More...
	QObject (QObjectPrivate &dd, QObject *parent=0)
int	receivers (const char *signal) const
	Returns the number of receivers connected to the signal. More...
QObject *	sender () const
	Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns 0. More...
int	senderSignalIndex () const

Private Slots
void	registerServiceNoLock (const QString &serviceName)
void	serviceOwnerChangedNoLock (const QString &name, const QString &oldOwner, const QString &newOwner)
void	unregisterServiceNoLock (const QString &serviceName)

Private Functions
bool	activateCall (QObject *object, int flags, const QDBusMessage &msg)
bool	activateInternalFilters (const ObjectTreeNode &node, const QDBusMessage &msg)
void	activateObject (ObjectTreeNode &node, const QDBusMessage &msg, int pathStartPos)
void	activateSignal (const SignalHook &hook, const QDBusMessage &msg)
void	checkThread ()
void	deliverCall (QObject *object, int flags, const QDBusMessage &msg, const QList< int > &metaTypes, int slotIdx)
QString	getNameOwnerNoCache (const QString &service)
bool	handleError (const QDBusErrorInternal &error)
void	handleObjectCall (const QDBusMessage &message)
void	handleSignal (const QString &key, const QDBusMessage &msg)
void	handleSignal (const QDBusMessage &msg)
bool	isServiceRegisteredByThread (const QString &serviceName) const
void	sendError (const QDBusMessage &msg, QDBusError::ErrorType code)

Friends
class	QDBusActivateObjectEvent
class	QDBusCallDeliveryEvent

Additional Inherited Members
Static Public Variables inherited from QObject
static const QMetaObject	staticMetaObject
	This variable stores the meta-object for the class. More...
Protected Variables inherited from QObject
QScopedPointer< QObjectData >	d_ptr
Static Protected Variables inherited from QObject
static const QMetaObject	staticQtMetaObject
Related Functions inherited from QObject
T	qFindChildqFindChildren (const QObject *obj, const QString &name)()
QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QString &name)()
QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QRegExp &regExp)()
T *	qobject_cast (QObject *object)
	QObjectList
void *	qt_find_obj_child (QObject *parent, const char *type, const QString &name)
	Returns a pointer to the object named name that inherits type and with a given parent. More...

Detailed Description

Definition at line 106 of file qdbusconnection_p.h.

Typedefs

MatchRefCountHash

typedef QHash<QByteArray, int> QDBusConnectionPrivate::MatchRefCountHash

Definition at line 168 of file qdbusconnection_p.h.

MetaObjectHash

typedef QHash<QString, QDBusMetaObject* > QDBusConnectionPrivate::MetaObjectHash

Definition at line 167 of file qdbusconnection_p.h.

PendingTimeoutList

typedef QList<QPair<DBusTimeout *, int> > QDBusConnectionPrivate::PendingTimeoutList

Definition at line 164 of file qdbusconnection_p.h.

SignalHookHash

typedef QMultiHash<QString, SignalHook> QDBusConnectionPrivate::SignalHookHash

Definition at line 166 of file qdbusconnection_p.h.

TimeoutHash

typedef QHash<int, DBusTimeout *> QDBusConnectionPrivate::TimeoutHash

Definition at line 163 of file qdbusconnection_p.h.

WatchedServicesHash

typedef QHash<QString, WatchedServiceData> QDBusConnectionPrivate::WatchedServicesHash

Definition at line 178 of file qdbusconnection_p.h.

WatcherHash

typedef QMultiHash<int, Watcher> QDBusConnectionPrivate::WatcherHash

Definition at line 162 of file qdbusconnection_p.h.

Enumerations

ConnectionMode

enum QDBusConnectionPrivate::ConnectionMode

Enumerator
InvalidMode
ServerMode
ClientMode
PeerMode

Definition at line 111 of file qdbusconnection_p.h.

{ InvalidMode, ServerMode, ClientMode, PeerMode }; // LocalMode

TreeNodeType

enum QDBusConnectionPrivate::TreeNodeType

Enumerator
Object
VirtualObject

Definition at line 132 of file qdbusconnection_p.h.

                      {
        Object = 0x0,
        VirtualObject = 0x01000000
    };

Constructors and Destructors

QDBusConnectionPrivate()

QDBusConnectionPrivate::QDBusConnectionPrivate ( QObject *  parent = 0 )

explicit

Definition at line 978 of file qdbusintegrator.cpp.

    : QObject(p), ref(1), capabilities(0), mode(InvalidMode), connection(0), server(0), busService(0),
      watchAndTimeoutLock(QMutex::Recursive),
      rootNode(QString(QLatin1Char('/')))
{
    static const bool threads = q_dbus_threads_init_default();
    static const int debugging = qgetenv("QDBUS_DEBUG").toInt();
    ::isDebugging = debugging;
    Q_UNUSED(threads)
    Q_UNUSED(debugging)

#ifdef QDBUS_THREAD_DEBUG
    if (debugging > 1)
        qdbusThreadDebug = qdbusDefaultThreadDebug;
#endif

    QDBusMetaTypeId::init();

    rootNode.flags = 0;

    // prepopulate watchedServices:
    // we know that the owner of org.freedesktop.DBus is itself
    watchedServices.insert(dbusServiceString(), WatchedServiceData(dbusServiceString(), 1));

    // prepopulate matchRefCounts:
    // we know that org.freedesktop.DBus will never change owners
    matchRefCounts.insert("type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',arg0='org.freedesktop.DBus'", 1);
}

~QDBusConnectionPrivate()

QDBusConnectionPrivate::~QDBusConnectionPrivate

(

)

Definition at line 1007 of file qdbusintegrator.cpp.

{
    if (thread() && thread() != QThread::currentThread())
        qWarning("QDBusConnection(name=\"%s\")'s last reference in not in its creation thread! "
                 "Timer and socket errors will follow and the program will probably crash",
                 qPrintable(name));

    closeConnection();
    rootNode.children.clear();  // free resources
    qDeleteAll(cachedMetaObjects);

    if (server)
        q_dbus_server_unref(server);
    if (connection)
        q_dbus_connection_unref(connection);

    connection = 0;
    server = 0;
}

Functions

activateCall()

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

private

Definition at line 780 of file qdbusintegrator.cpp.

Referenced by activateObject().

{
    // This is called by QDBusConnectionPrivate::handleObjectCall to place a call
    // to a slot on the object.
    //
    // The call is delivered to the first slot that matches the following conditions:
    //  - has the same name as the message's target member
    //  - ALL of the message's types are found in slot's parameter list
    //  - optionally has one more parameter of type QDBusMessage
    // If none match, then the slot of the same name as the message target and with
    // the first type of QDBusMessage is delivered.
    //
    // The D-Bus specification requires that all MethodCall messages be replied to, unless the
    // caller specifically waived this requirement. This means that we inspect if the user slot
    // generated a reply and, if it didn't, we will. Obviously, if the user slot doesn't take a
    // QDBusMessage parameter, it cannot generate a reply.
    //
    // When a return message is generated, the slot's return type, if any, will be placed
    // in the message's first position. If there are non-const reference parameters to the
    // slot, they must appear at the end and will be placed in the subsequent message
    // positions.

    static const char cachePropertyName[] = "_qdbus_slotCache";

    if (!object)
        return false;

#ifndef QT_NO_PROPERTIES
    Q_ASSERT_X(QThread::currentThread() == object->thread(),
               "QDBusConnection: internal threading error",
               "function called for an object that is in another thread!!");

    QDBusSlotCache slotCache =
        qvariant_cast<QDBusSlotCache>(object->property(cachePropertyName));
    QString cacheKey = msg.member(), signature = msg.signature();
    if (!signature.isEmpty()) {
        cacheKey.reserve(cacheKey.length() + 1 + signature.length());
        cacheKey += QLatin1Char('.');
        cacheKey += signature;
    }

    QDBusSlotCache::Hash::ConstIterator cacheIt = slotCache.hash.constFind(cacheKey);
    while (cacheIt != slotCache.hash.constEnd() && cacheIt->flags != flags &&
           cacheIt.key() == cacheKey)
        ++cacheIt;
    if (cacheIt == slotCache.hash.constEnd() || cacheIt.key() != cacheKey)
    {
        // not cached, analyze the meta object
        const QMetaObject *mo = object->metaObject();
        QByteArray memberName = msg.member().toUtf8();

        // find a slot that matches according to the rules above
        QDBusSlotCache::Data slotData;
        slotData.flags = flags;
        slotData.slotIdx = ::findSlot(mo, memberName, flags, msg.signature(), slotData.metaTypes);
        if (slotData.slotIdx == -1) {
            // ### this is where we want to add the connection as an arg too
            // try with no parameters, but with a QDBusMessage
            slotData.slotIdx = ::findSlot(mo, memberName, flags, QString(), slotData.metaTypes);
            if (slotData.metaTypes.count() != 2 ||
                slotData.metaTypes.at(1) != QDBusMetaTypeId::message) {
                // not found
                // save the negative lookup
                slotData.slotIdx = -1;
                slotData.metaTypes.clear();
                slotCache.hash.insert(cacheKey, slotData);
                object->setProperty(cachePropertyName, QVariant::fromValue(slotCache));
                return false;
            }
        }

        // save to the cache
        slotCache.hash.insert(cacheKey, slotData);
        object->setProperty(cachePropertyName, QVariant::fromValue(slotCache));

        // found the slot to be called
        deliverCall(object, flags, msg, slotData.metaTypes, slotData.slotIdx);
        return true;
    } else if (cacheIt->slotIdx == -1) {
        // negative cache
        return false;
    } else {
        // use the cache
        deliverCall(object, flags, msg, cacheIt->metaTypes, cacheIt->slotIdx);
        return true;
    }
#endif // QT_NO_PROPERTIES
    return false;
}

activateInternalFilters()

bool QDBusConnectionPrivate::activateInternalFilters ( const ObjectTreeNode &  node, const QDBusMessage &  msg  )

private

Definition at line 1331 of file qdbusintegrator.cpp.

Referenced by activateObject().

{
    // object may be null
    const QString interface = msg.interface();

    if (interface.isEmpty() || interface == QLatin1String(DBUS_INTERFACE_INTROSPECTABLE)) {
        if (msg.member() == QLatin1String("Introspect") && msg.signature().isEmpty()) {
            //qDebug() << "QDBusConnectionPrivate::activateInternalFilters introspect" << msg.d_ptr->msg;
            QDBusMessage reply = msg.createReply(qDBusIntrospectObject(node, msg.path()));
            send(reply);
            return true;
        }

        if (!interface.isEmpty()) {
            sendError(msg, QDBusError::UnknownMethod);
            return true;
        }
    }

    if (node.obj && (interface.isEmpty() ||
                     interface == QLatin1String(DBUS_INTERFACE_PROPERTIES))) {
        //qDebug() << "QDBusConnectionPrivate::activateInternalFilters properties" << msg.d_ptr->msg;
        if (msg.member() == QLatin1String("Get") && msg.signature() == QLatin1String("ss")) {
            QDBusMessage reply = qDBusPropertyGet(node, msg);
            send(reply);
            return true;
        } else if (msg.member() == QLatin1String("Set") && msg.signature() == QLatin1String("ssv")) {
            QDBusMessage reply = qDBusPropertySet(node, msg);
            send(reply);
            return true;
        } else if (msg.member() == QLatin1String("GetAll") && msg.signature() == QLatin1String("s")) {
            QDBusMessage reply = qDBusPropertyGetAll(node, msg);
            send(reply);
            return true;
        }

        if (!interface.isEmpty()) {
            sendError(msg, QDBusError::UnknownMethod);
            return true;
        }
    }

    return false;
}

activateObject()

void QDBusConnectionPrivate::activateObject ( ObjectTreeNode &  node, const QDBusMessage &  msg, int  pathStartPos  )

private

Definition at line 1377 of file qdbusintegrator.cpp.

Referenced by handleObjectCall(), and QDBusActivateObjectEvent::placeMetaCall().

{
    // This is called by QDBusConnectionPrivate::handleObjectCall to place a call to a slot
    // on the object.
    //
    // The call is routed through the adaptor sub-objects if we have any

    // object may be null

    if (node.flags & QDBusConnectionPrivate::VirtualObject) {
        if (node.treeNode->handleMessage(msg, q(this))) {
            return;
        } else {
            if (activateInternalFilters(node, msg))
                return;
        }
    }

    if (pathStartPos != msg.path().length()) {
        node.flags &= ~QDBusConnection::ExportAllSignals;
        node.obj = findChildObject(&node, msg.path(), pathStartPos);
        if (!node.obj) {
            sendError(msg, QDBusError::UnknownObject);
            return;
        }
    }

    QDBusAdaptorConnector *connector;
    if (node.flags & QDBusConnection::ExportAdaptors &&
        (connector = qDBusFindAdaptorConnector(node.obj))) {
        int newflags = node.flags | QDBusConnection::ExportAllSlots;

        if (msg.interface().isEmpty()) {
            // place the call in all interfaces
            // let the first one that handles it to work
            QDBusAdaptorConnector::AdaptorMap::ConstIterator it =
                connector->adaptors.constBegin();
            QDBusAdaptorConnector::AdaptorMap::ConstIterator end =
                connector->adaptors.constEnd();

            for ( ; it != end; ++it)
                if (activateCall(it->adaptor, newflags, msg))
                    return;
        } else {
            // check if we have an interface matching the name that was asked:
            QDBusAdaptorConnector::AdaptorMap::ConstIterator it;
            it = qLowerBound(connector->adaptors.constBegin(), connector->adaptors.constEnd(),
                             msg.interface());
            if (it != connector->adaptors.constEnd() && msg.interface() == QLatin1String(it->interface)) {
                if (!activateCall(it->adaptor, newflags, msg))
                    sendError(msg, QDBusError::UnknownMethod);
                return;
            }
        }
    }

    // no adaptors matched or were exported
    // try our standard filters
    if (activateInternalFilters(node, msg))
        return;                 // internal filters have already run or an error has been sent

    // try the object itself:
    if (node.flags & (QDBusConnection::ExportScriptableSlots|QDBusConnection::ExportNonScriptableSlots) ||
        node.flags & (QDBusConnection::ExportScriptableInvokables|QDBusConnection::ExportNonScriptableInvokables)) {
        bool interfaceFound = true;
        if (!msg.interface().isEmpty())
            interfaceFound = qDBusInterfaceInObject(node.obj, msg.interface());

        if (interfaceFound) {
            if (!activateCall(node.obj, node.flags, msg))
                sendError(msg, QDBusError::UnknownMethod);
            return;
        }
    }

    // nothing matched, send an error code
    if (msg.interface().isEmpty())
        sendError(msg, QDBusError::UnknownMethod);
    else
        sendError(msg, QDBusError::UnknownInterface);
}

activateSignal()

void QDBusConnectionPrivate::activateSignal ( const SignalHook &  hook, const QDBusMessage &  msg  )

private

Definition at line 759 of file qdbusintegrator.cpp.

Referenced by handleSignal().

{
    // This is called by QDBusConnectionPrivate::handleSignal to deliver a signal
    // that was received from D-Bus
    //
    // Signals are delivered to slots if the parameters match
    // Slots can have less parameters than there are on the message
    // Slots can optionally have one final parameter that is a QDBusMessage
    // Slots receive read-only copies of the message (i.e., pass by value or by const-ref)
    QDBusCallDeliveryEvent *call = prepareReply(this, hook.obj, hook.midx, hook.params, msg);
    if (call == DIRECT_DELIVERY) {
        // short-circuit delivery
        Q_ASSERT(this == hook.obj);
        deliverCall(this, 0, msg, hook.params, hook.midx);
        return;
    }
    if (call)
        postEventToThread(ActivateSignalAction, hook.obj, call);
}

callWithCallbackFailed

void QDBusConnectionPrivate::callWithCallbackFailed ( const QDBusError &  error, const QDBusMessage &  message  )

signal

Referenced by processFinishedCall().

checkReplyForDelivery()

static bool QDBusConnectionPrivate::checkReplyForDelivery ( QDBusConnectionPrivate *  target, QObject *  object, int  idx, const QList< int > &  metaTypes, const QDBusMessage &  msg  )

static

checkThread()

void QDBusConnectionPrivate::checkThread ( )

private

Definition at line 1061 of file qdbusintegrator.cpp.

Referenced by send(), sendWithReply(), and sendWithReplyAsync().

{
    if (!thread()) {
        if (QCoreApplication::instance())
            moveToThread(QCoreApplication::instance()->thread());
        else
            qWarning("The thread that had QDBusConnection('%s') has died and there is no main thread",
                     qPrintable(name));
    }
}

closeConnection()

void QDBusConnectionPrivate::closeConnection

(

)

Definition at line 1041 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionManager::~QDBusConnectionManager(), and ~QDBusConnectionPrivate().

{
    QDBusWriteLocker locker(CloseConnectionAction, this);
    ConnectionMode oldMode = mode;
    mode = InvalidMode; // prevent reentrancy
    baseService.clear();

    if (server)
        q_dbus_server_disconnect(server);

    if (oldMode == ClientMode || oldMode == PeerMode) {
        if (connection) {
            q_dbus_connection_close(connection);
            // send the "close" message
            while (q_dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS)
                ;
        }
    }
}

connectRelay()

void QDBusConnectionPrivate::connectRelay	(	const QString &	service,
		const QString &	path,
		const QString &	interface,
		QDBusAbstractInterface *	receiver,
		const char *	signal
	)

Definition at line 2271 of file qdbusintegrator.cpp.

Referenced by QDBusAbstractInterface::connectNotify().

{
    // this function is called by QDBusAbstractInterface when one of its signals is connected
    // we set up a relay from D-Bus into it
    SignalHook hook;
    QString key;

    if (!prepareHook(hook, key, service, path, interface, QString(), QStringList(), receiver, signal,
                     QDBusAbstractInterface::staticMetaObject.methodCount(), true))
        return;                 // don't connect

    // add it to our list:
    QDBusWriteLocker locker(ConnectRelayAction, this);
    SignalHookHash::ConstIterator it = signalHooks.find(key);
    SignalHookHash::ConstIterator end = signalHooks.constEnd();
    for ( ; it != end && it.key() == key; ++it) {
        const SignalHook &entry = it.value();
        if (entry.service == hook.service &&
            entry.path == hook.path &&
            entry.signature == hook.signature &&
            entry.obj == hook.obj &&
            entry.midx == hook.midx)
            return;             // already there, no need to re-add
    }

    connectSignal(key, hook);
}

connectSignal() [1/2]

bool QDBusConnectionPrivate::connectSignal	(	const QString &	service,
		const QString &	path,
		const QString &	interface,
		const QString &	name,
		const QStringList &	argumentMatch,
		const QString &	signature,
		QObject *	receiver,
		const char *	slot
	)

Definition at line 2075 of file qdbusintegrator.cpp.

Referenced by connectRelay(), and connectSignal().

{
    // check the slot
    QDBusConnectionPrivate::SignalHook hook;
    QString key;
    QString name2 = name;
    if (name2.isNull())
        name2.detach();

    hook.signature = signature;
    if (!prepareHook(hook, key, service, path, interface, name, argumentMatch, receiver, slot, 0, false))
        return false;           // don't connect

    // avoid duplicating:
    QDBusConnectionPrivate::SignalHookHash::ConstIterator it = signalHooks.find(key);
    QDBusConnectionPrivate::SignalHookHash::ConstIterator end = signalHooks.constEnd();
    for ( ; it != end && it.key() == key; ++it) {
        const QDBusConnectionPrivate::SignalHook &entry = it.value();
        if (entry.service == hook.service &&
            entry.path == hook.path &&
            entry.signature == hook.signature &&
            entry.obj == hook.obj &&
            entry.midx == hook.midx &&
            entry.argumentMatch == hook.argumentMatch) {
            // no need to compare the parameters if it's the same slot
            return true;        // already there
        }
    }

    connectSignal(key, hook);
    return true;
}

connectSignal() [2/2]

void QDBusConnectionPrivate::connectSignal	(	const QString &	key,
		const SignalHook &	hook
	)

Definition at line 2111 of file qdbusintegrator.cpp.

{
    signalHooks.insertMulti(key, hook);
    connect(hook.obj, SIGNAL(destroyed(QObject*)), SLOT(objectDestroyed(QObject*)),
            Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));

    MatchRefCountHash::iterator it = matchRefCounts.find(hook.matchRule);

    if (it != matchRefCounts.end()) { // Match already present
        it.value() = it.value() + 1;
        return;
    }

    matchRefCounts.insert(hook.matchRule, 1);

    if (connection) {
        if (mode != QDBusConnectionPrivate::PeerMode) {
            qDBusDebug("Adding rule: %s", hook.matchRule.constData());
            q_dbus_bus_add_match(connection, hook.matchRule, NULL);

            // Successfully connected the signal
            // Do we need to watch for this name?
            if (shouldWatchService(hook.service)) {
                WatchedServicesHash::mapped_type &data = watchedServices[hook.service];
                if (++data.refcount == 1) {
                    // we need to watch for this service changing
                    connectSignal(dbusServiceString(), QString(), dbusInterfaceString(),
                                  QLatin1String("NameOwnerChanged"), QStringList() << hook.service, QString(),
                                  this, SLOT(serviceOwnerChangedNoLock(QString,QString,QString)));
                    data.owner = getNameOwnerNoCache(hook.service);
                    qDBusDebug() << this << "Watching service" << hook.service << "for owner changes (current owner:"
                                 << data.owner << ")";
                }
            }
        }
    }
}

customEvent()

void QDBusConnectionPrivate::customEvent ( QEvent *  )

protectedvirtual

This event handler can be reimplemented in a subclass to receive custom events.

Custom events are user-defined events with a type value at least as large as the QEvent::User item of the QEvent::Type enum, and is typically a QEvent subclass. The event is passed in the event parameter.

See also

event(), QEvent

Reimplemented from QObject.

Definition at line 1095 of file qdbusintegrator.cpp.

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

    QDBusConnectionCallbackEvent *ev = static_cast<QDBusConnectionCallbackEvent *>(e);
    QDBusLockerBase::reportThreadAction(int(AddTimeoutAction) + int(ev->subtype),
                                        QDBusLockerBase::BeforeDeliver, this);
    switch (ev->subtype)
    {
    case QDBusConnectionCallbackEvent::AddTimeout: {
        QDBusWatchAndTimeoutLocker locker(RealAddTimeoutAction, this);
        while (!timeoutsPendingAdd.isEmpty()) {
            QPair<DBusTimeout *, int> entry = timeoutsPendingAdd.takeFirst();
            qDBusRealAddTimeout(this, entry.first, entry.second);
        }
        break;
    }

    case QDBusConnectionCallbackEvent::KillTimer:
        killTimer(ev->timerId);
        break;

    case QDBusConnectionCallbackEvent::AddWatch:
        qDBusRealAddWatch(this, ev->watch, ev->extra, ev->fd);
        break;

    case QDBusConnectionCallbackEvent::ToggleWatch:
        qDBusRealToggleWatch(this, ev->watch, ev->fd);
        break;
    }
    QDBusLockerBase::reportThreadAction(int(AddTimeoutAction) + int(ev->subtype),
                                        QDBusLockerBase::AfterDeliver, this);
}

d()

static QDBusConnectionPrivate* QDBusConnectionPrivate::d ( const QDBusConnection &  q )

inlinestatic

Definition at line 328 of file qdbusconnection_p.h.

Referenced by QDBusAbstractInterfacePrivate::connectionPrivate(), QDBusCallDeliveryEvent::placeMetaCall(), QDBusActivateObjectEvent::placeMetaCall(), QDBusDefaultConnection::QDBusDefaultConnection(), and QDBusActivateObjectEvent::~QDBusActivateObjectEvent().

{ return q.d; }

deleteYourself()

void QDBusConnectionPrivate::deleteYourself

(

)

Definition at line 1027 of file qdbusintegrator.cpp.

Referenced by QDBusConnectionManager::removeConnection(), and QDBusConnectionManager::~QDBusConnectionManager().

{
    if (thread() && thread() != QThread::currentThread()) {
        // last reference dropped while not in the correct thread
        // ask the correct thread to delete

        // note: since we're posting an event to another thread, we
        // must consider deleteLater() to take effect immediately
        deleteLater();
    } else {
        delete this;
    }
}

deliverCall()

void QDBusConnectionPrivate::deliverCall ( QObject *  object, int  flags, const QDBusMessage &  msg, const QList< int > &  metaTypes, int  slotIdx  )

private

Definition at line 870 of file qdbusintegrator.cpp.

Referenced by activateCall(), activateSignal(), and QDBusCallDeliveryEvent::placeMetaCall().

{
    Q_ASSERT_X(!object || QThread::currentThread() == object->thread(),
               "QDBusConnection: internal threading error",
               "function called for an object that is in another thread!!");

    QVarLengthArray<void *, 10> params;
    params.reserve(metaTypes.count());

    QVariantList auxParameters;
    // let's create the parameter list

    // first one is the return type -- add it below
    params.append(0);

    // add the input parameters
    int i;
    int pCount = qMin(msg.arguments().count(), metaTypes.count() - 1);
    for (i = 1; i <= pCount; ++i) {
        int id = metaTypes[i];
        if (id == QDBusMetaTypeId::message)
            break;

        const QVariant &arg = msg.arguments().at(i - 1);
        if (arg.userType() == id)
            // no conversion needed
            params.append(const_cast<void *>(arg.constData()));
        else if (arg.userType() == qMetaTypeId<QDBusArgument>()) {
            // convert to what the function expects
            void *null = 0;
            auxParameters.append(QVariant(id, null));

            const QDBusArgument &in =
                *reinterpret_cast<const QDBusArgument *>(arg.constData());
            QVariant &out = auxParameters[auxParameters.count() - 1];

            if (!QDBusMetaType::demarshall(in, out.userType(), out.data()))
                qFatal("Internal error: demarshalling function for type '%s' (%d) failed!",
                       out.typeName(), out.userType());

            params.append(const_cast<void *>(out.constData()));
        } else {
            qFatal("Internal error: got invalid meta type %d (%s) "
                   "when trying to convert to meta type %d (%s)",
                   arg.userType(), QMetaType::typeName(arg.userType()),
                   id, QMetaType::typeName(id));
        }
    }

    if (metaTypes.count() > i && metaTypes[i] == QDBusMetaTypeId::message) {
        params.append(const_cast<void*>(static_cast<const void*>(&msg)));
        ++i;
    }

    // output arguments
    QVariantList outputArgs;
    void *null = 0;
    if (metaTypes[0] != QMetaType::Void) {
        QVariant arg(metaTypes[0], null);
        outputArgs.append( arg );
        params[0] = const_cast<void*>(outputArgs.at( outputArgs.count() - 1 ).constData());
    }
    for ( ; i < metaTypes.count(); ++i) {
        QVariant arg(metaTypes[i], null);
        outputArgs.append( arg );
        params.append(const_cast<void*>(outputArgs.at( outputArgs.count() - 1 ).constData()));
    }

    // make call:
    bool fail;
    if (!object) {
        fail = true;
    } else {
        // FIXME: save the old sender!
        QDBusContextPrivate context(QDBusConnection(this), msg);
        QDBusContextPrivate *old = QDBusContextPrivate::set(object, &context);
        QDBusConnectionPrivate::setSender(this);

        QPointer<QObject> ptr = object;
        fail = object->qt_metacall(QMetaObject::InvokeMetaMethod,
                                   slotIdx, params.data()) >= 0;
        QDBusConnectionPrivate::setSender(0);
    // the object might be deleted in the slot
    if (!ptr.isNull())
        QDBusContextPrivate::set(object, old);
    }

    // do we create a reply? Only if the caller is waiting for a reply and one hasn't been sent
    // yet.
    if (msg.isReplyRequired() && !msg.isDelayedReply()) {
        if (!fail) {
            // normal reply
            qDBusDebug() << this << "Automatically sending reply:" << outputArgs;
            send(msg.createReply(outputArgs));
        } else {
            // generate internal error
            qWarning("Internal error: Failed to deliver message");
            send(msg.createErrorReply(QDBusError::InternalError,
                                      QLatin1String("Failed to deliver message")));
        }
    }

    return;
}

disconnectRelay()

void QDBusConnectionPrivate::disconnectRelay	(	const QString &	service,
		const QString &	path,
		const QString &	interface,
		QDBusAbstractInterface *	receiver,
		const char *	signal
	)

Definition at line 2302 of file qdbusintegrator.cpp.

Referenced by QDBusAbstractInterface::disconnectNotify().

{
    // this function is called by QDBusAbstractInterface when one of its signals is disconnected
    // we remove relay from D-Bus into it
    SignalHook hook;
    QString key;

    if (!prepareHook(hook, key, service, path, interface, QString(), QStringList(), receiver, signal,
                     QDBusAbstractInterface::staticMetaObject.methodCount(), true))
        return;                 // don't connect

    // remove it from our list:
    QDBusWriteLocker locker(DisconnectRelayAction, this);
    SignalHookHash::Iterator it = signalHooks.find(key);
    SignalHookHash::Iterator end = signalHooks.end();
    for ( ; it != end && it.key() == key; ++it) {
        const SignalHook &entry = it.value();
        if (entry.service == hook.service &&
            entry.path == hook.path &&
            entry.signature == hook.signature &&
            entry.obj == hook.obj &&
            entry.midx == hook.midx) {
            // found it
            disconnectSignal(it);
            return;
        }
    }

    qWarning("QDBusConnectionPrivate::disconnectRelay called for a signal that was not found");
}

disconnectSignal() [1/2]

QDBusConnectionPrivate::SignalHookHash::Iterator QDBusConnectionPrivate::disconnectSignal

(

SignalHookHash::Iterator &

it

)

Definition at line 2187 of file qdbusintegrator.cpp.

Referenced by disconnectRelay(), disconnectSignal(), and objectDestroyed().

{
    const SignalHook &hook = it.value();

    bool erase = false;
    MatchRefCountHash::iterator i = matchRefCounts.find(hook.matchRule);
    if (i == matchRefCounts.end()) {
        qWarning("QDBusConnectionPrivate::disconnectSignal: MatchRule not found in matchRefCounts!!");
    } else {
        if (i.value() == 1) {
            erase = true;
            matchRefCounts.erase(i);
        }
        else {
            i.value() = i.value() - 1;
        }
    }

    // we don't care about errors here
    if (connection && erase) {
        if (mode != QDBusConnectionPrivate::PeerMode) {
            qDBusDebug("Removing rule: %s", hook.matchRule.constData());
            q_dbus_bus_remove_match(connection, hook.matchRule, NULL);

            // Successfully disconnected the signal
            // Were we watching for this name?
            WatchedServicesHash::Iterator sit = watchedServices.find(hook.service);
            if (sit != watchedServices.end()) {
                if (--sit.value().refcount == 0) {
                    watchedServices.erase(sit);
                    disconnectSignal(dbusServiceString(), QString(), dbusInterfaceString(),
                                  QLatin1String("NameOwnerChanged"), QStringList() << hook.service, QString(),
                                  this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
                }
            }
        }

    }

    return signalHooks.erase(it);
}

disconnectSignal() [2/2]

bool QDBusConnectionPrivate::disconnectSignal	(	const QString &	service,
		const QString &	path,
		const QString &	interface,
		const QString &	name,
		const QStringList &	argumentMatch,
		const QString &	signature,
		QObject *	receiver,
		const char *	slot
	)

Definition at line 2149 of file qdbusintegrator.cpp.

{
    // check the slot
    QDBusConnectionPrivate::SignalHook hook;
    QString key;
    QString name2 = name;
    if (name2.isNull())
        name2.detach();

    hook.signature = signature;
    if (!prepareHook(hook, key, service, path, interface, name, argumentMatch, receiver, slot, 0, false))
        return false;           // don't disconnect

    // avoid duplicating:
    QDBusConnectionPrivate::SignalHookHash::Iterator it = signalHooks.find(key);
    QDBusConnectionPrivate::SignalHookHash::Iterator end = signalHooks.end();
    for ( ; it != end && it.key() == key; ++it) {
        const QDBusConnectionPrivate::SignalHook &entry = it.value();
        if (entry.service == hook.service &&
            entry.path == hook.path &&
            entry.signature == hook.signature &&
            entry.obj == hook.obj &&
            entry.midx == hook.midx &&
            entry.argumentMatch == hook.argumentMatch) {
            // no need to compare the parameters if it's the same slot
            disconnectSignal(it);
            return true;        // it was there
        }
    }

    // the slot was not found
    return false;
}

doDispatch

void QDBusConnectionPrivate::doDispatch ( )

slot

Definition at line 1129 of file qdbusintegrator.cpp.

Referenced by socketRead(), and timerEvent().

{
    QDBusDispatchLocker locker(DoDispatchAction, this);
    if (mode == ClientMode || mode == PeerMode)
        while (q_dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS) ;
}

findMetaObject()

QDBusMetaObject * QDBusConnectionPrivate::findMetaObject	(	const QString &	service,
		const QString &	path,
		const QString &	interface,
		QDBusError &	error
	)

Definition at line 2369 of file qdbusintegrator.cpp.

Referenced by QDBusInterfacePrivate::QDBusInterfacePrivate().

{
    // service must be a unique connection name
    if (!interface.isEmpty()) {
        QDBusReadLocker locker(FindMetaObject1Action, this);
        QDBusMetaObject *mo = cachedMetaObjects.value(interface, 0);
        if (mo)
            return mo;
    }

    // introspect the target object
    QDBusMessage msg = QDBusMessage::createMethodCall(service, path,
                                                QLatin1String(DBUS_INTERFACE_INTROSPECTABLE),
                                                QLatin1String("Introspect"));
    QDBusMessagePrivate::setParametersValidated(msg, true);

    QDBusMessage reply = sendWithReply(msg, QDBus::Block);

    // it doesn't exist yet, we have to create it
    QDBusWriteLocker locker(FindMetaObject2Action, this);
    QDBusMetaObject *mo = 0;
    if (!interface.isEmpty())
        mo = cachedMetaObjects.value(interface, 0);
    if (mo)
        // maybe it got created when we switched from read to write lock
        return mo;

    QString xml;
    if (reply.type() == QDBusMessage::ReplyMessage) {
        if (reply.signature() == QLatin1String("s"))
            // fetch the XML description
            xml = reply.arguments().at(0).toString();
    } else {
        error = reply;
        lastError = error;
        if (reply.type() != QDBusMessage::ErrorMessage || error.type() != QDBusError::UnknownMethod)
            return 0; // error
    }

    // release the lock and return
    QDBusMetaObject *result = QDBusMetaObject::createMetaObject(interface, xml,
                                                                cachedMetaObjects, error);
    lastError = error;
    return result;
}

findSlot()

int QDBusConnectionPrivate::findSlot ( QObject *  obj, const QByteArray &  normalizedName, QList< int > &  params  )

static

Definition at line 1246 of file qdbusintegrator.cpp.

Referenced by activateCall(), prepareHook(), and QDBusPendingCallPrivate::setReplyCallback().

{
    int midx = obj->metaObject()->indexOfMethod(normalizedName);
    if (midx == -1)
        return -1;

    int inputCount = qDBusParametersForMethod(obj->metaObject()->method(midx), params);
    if ( inputCount == -1 || inputCount + 1 != params.count() )
        return -1;              // failed to parse or invalid arguments or output arguments

    return midx;
}

getNameOwner()

QString QDBusConnectionPrivate::getNameOwner

(

const QString &

service

)

Definition at line 2336 of file qdbusintegrator.cpp.

Referenced by QDBusAbstractInterfacePrivate::QDBusAbstractInterfacePrivate().

{
    if (QDBusUtil::isValidUniqueConnectionName(serviceName))
        return serviceName;
    if (!connection)
        return QString();

    {
        // acquire a read lock for the cache
        QReadLocker locker(&lock);
        WatchedServicesHash::ConstIterator it = watchedServices.constFind(serviceName);
        if (it != watchedServices.constEnd())
            return it->owner;
    }

    // not cached
    return getNameOwnerNoCache(serviceName);
}

getNameOwnerNoCache()

QString QDBusConnectionPrivate::getNameOwnerNoCache ( const QString &  service )

private

Definition at line 2355 of file qdbusintegrator.cpp.

Referenced by connectSignal(), and getNameOwner().

{
    QDBusMessage msg = QDBusMessage::createMethodCall(dbusServiceString(),
            QLatin1String(DBUS_PATH_DBUS), dbusInterfaceString(),
            QLatin1String("GetNameOwner"));
    QDBusMessagePrivate::setParametersValidated(msg, true);
    msg << serviceName;
    QDBusMessage reply = sendWithReply(msg, QDBus::Block);
    if (reply.type() == QDBusMessage::ReplyMessage)
        return reply.arguments().at(0).toString();
    return QString();
}

handleError()

bool QDBusConnectionPrivate::handleError ( const QDBusErrorInternal &  error )

private

Definition at line 1072 of file qdbusintegrator.cpp.

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

{
    if (!error)
        return false;           // no error

    //lock.lockForWrite();
    lastError = error;
    //lock.unlock();
    return true;
}

handleMessage()

bool QDBusConnectionPrivate::handleMessage

(

const QDBusMessage &

msg

)

Definition at line 558 of file qdbusintegrator.cpp.

Referenced by qDBusSignalFilter(), and sendWithReplyLocal().

{
    const QDBusSpyHookList *list = qDBusSpyHookList();
    for (int i = 0; i < list->size(); ++i) {
        qDBusDebug() << "calling the message spy hook";
        (*(*list)[i])(amsg);
    }

    if (!ref)
        return false;

    switch (amsg.type()) {
    case QDBusMessage::SignalMessage:
        handleSignal(amsg);
        // if there are any other filters in this DBusConnection,
        // let them see the signal too
        return false;
    case QDBusMessage::MethodCallMessage:
        handleObjectCall(amsg);
        return true;
    case QDBusMessage::ReplyMessage:
    case QDBusMessage::ErrorMessage:
    case QDBusMessage::InvalidMessage:
        return false;           // we don't handle those here
    }

    return false;
}

handleObjectCall()

void QDBusConnectionPrivate::handleObjectCall ( const QDBusMessage &  message )

private

Definition at line 1460 of file qdbusintegrator.cpp.

Referenced by handleMessage().

{
    // if the msg is external, we were called from inside doDispatch
    // that means the dispatchLock mutex is locked
    // must not call out to user code in that case
    //
    // however, if the message is internal, handleMessage was called
    // directly and no lock is in place. We can therefore call out to
    // user code, if necessary
    ObjectTreeNode result;
    int usedLength;
    QThread *objThread = 0;
    QSemaphore sem;
    bool semWait;

    {
        QDBusReadLocker locker(HandleObjectCallAction, this);
        if (!findObject(&rootNode, msg.path(), usedLength, result)) {
            // qDebug("Call failed: no object found at %s", qPrintable(msg.path()));
            sendError(msg, QDBusError::UnknownObject);
            return;
        }

        if (!result.obj) {
            // no object -> no threading issues
            // it's either going to be an error, or an internal filter
            activateObject(result, msg, usedLength);
            return;
        }

        objThread = result.obj->thread();
        if (!objThread) {
            send(msg.createErrorReply(QDBusError::InternalError,
                                      QString::fromLatin1("Object '%1' (at path '%2')"
                                                          " has no thread. Cannot deliver message.")
                                      .arg(result.obj->objectName(), msg.path())));
            return;
        }

        if (!QDBusMessagePrivate::isLocal(msg)) {
            // external incoming message
            // post it and forget
            postEventToThread(HandleObjectCallPostEventAction, result.obj,
                              new QDBusActivateObjectEvent(QDBusConnection(this), this, result,
                                                           usedLength, msg));
            return;
        } else if (objThread != QThread::currentThread()) {
            // synchronize with other thread
            postEventToThread(HandleObjectCallPostEventAction, result.obj,
                              new QDBusActivateObjectEvent(QDBusConnection(this), this, result,
                                                           usedLength, msg, &sem));
            semWait = true;
        } else {
            semWait = false;
        }
    } // release the lock

    if (semWait)
        SEM_ACQUIRE(HandleObjectCallSemaphoreAction, sem);
    else
        activateObject(result, msg, usedLength);
}

handleSignal() [1/2]

void QDBusConnectionPrivate::handleSignal ( const QString &  key, const QDBusMessage &  msg  )

private

Definition at line 1548 of file qdbusintegrator.cpp.

Referenced by handleMessage(), and handleSignal().

{
    SignalHookHash::const_iterator it = signalHooks.find(key);
    SignalHookHash::const_iterator end = signalHooks.constEnd();
    //qDebug("looking for: %s", path.toLocal8Bit().constData());
    //qDBusDebug() << signalHooks.keys();
    for ( ; it != end && it.key() == key; ++it) {
        const SignalHook &hook = it.value();
        if (!hook.service.isEmpty()) {
            const QString owner =
                    shouldWatchService(hook.service) ?
                    watchedServices.value(hook.service).owner :
                    hook.service;
            if (owner != msg.service())
                continue;
        }
        if (!hook.path.isEmpty() && hook.path != msg.path())
            continue;
        if (!hook.signature.isEmpty() && hook.signature != msg.signature())
            continue;
        if (hook.signature.isEmpty() && !hook.signature.isNull() && !msg.signature().isEmpty())
            continue;
        if (!hook.argumentMatch.isEmpty()) {
            const QVariantList arguments = msg.arguments();
            if (hook.argumentMatch.size() > arguments.size())
                continue;

            bool matched = true;
            for (int i = 0; i < hook.argumentMatch.size(); ++i) {
                const QString &param = hook.argumentMatch.at(i);
                if (param.isNull())
                    continue;   // don't try to match against this
                if (param == arguments.at(i).toString())
                    continue;   // matched
                matched = false;
                break;
            }
            if (!matched)
                continue;
        }

        activateSignal(hook, msg);
    }
}

handleSignal() [2/2]

void QDBusConnectionPrivate::handleSignal ( const QDBusMessage &  msg )

private

Definition at line 1593 of file qdbusintegrator.cpp.

{
    // We call handlesignal(QString, QDBusMessage) three times:
    //  one with member:interface
    //  one with member:
    //  one with :interface
    // This allows us to match signals with wildcards on member or interface
    // (but not both)

    QString key = msg.member();
    key.reserve(key.length() + 1 + msg.interface().length());
    key += QLatin1Char(':');
    key += msg.interface();

    QDBusReadLocker locker(HandleSignalAction, this);
    handleSignal(key, msg);                  // one try

    key.truncate(msg.member().length() + 1); // keep the ':'
    handleSignal(key, msg);                  // second try

    key = QLatin1Char(':');
    key += msg.interface();
    handleSignal(key, msg);                  // third try
}

isServiceRegisteredByThread()

bool QDBusConnectionPrivate::isServiceRegisteredByThread ( const QString &  serviceName ) const

private

Definition at line 2438 of file qdbusintegrator.cpp.

Referenced by sendWithReply(), and sendWithReplyAsync().

{
    if (!serviceName.isEmpty() && serviceName == baseService)
        return true;
    QStringList copy = serviceNames;
    return copy.contains(serviceName);
}

messageFilter()

static DBusHandlerResult QDBusConnectionPrivate::messageFilter ( DBusConnection *  , DBusMessage *  , void *    )

static

newServerConnection

void QDBusConnectionPrivate::newServerConnection ( const QDBusConnection &  connection )

signal

objectDestroyed

void QDBusConnectionPrivate::objectDestroyed ( QObject *  o )

slot

Definition at line 1175 of file qdbusintegrator.cpp.

Referenced by connectSignal(), and registerObject().

{
    QDBusWriteLocker locker(ObjectDestroyedAction, this);
    huntAndDestroy(obj, rootNode);

    SignalHookHash::iterator sit = signalHooks.begin();
    while (sit != signalHooks.end()) {
        if (static_cast<QObject *>(sit.value().obj) == obj)
            sit = disconnectSignal(sit);
        else
            ++sit;
    }

    obj->disconnect(this);
}

postEventToThread()

void QDBusConnectionPrivate::postEventToThread	(	int	action,
		QObject *	target,
		QEvent *	event
	)

Definition at line 2446 of file qdbusintegrator.cpp.

Referenced by activateSignal(), handleObjectCall(), processFinishedCall(), qDBusAddTimeout(), qDBusAddWatch(), qDBusRemoveTimeout(), and qDBusToggleWatch().

{
    QDBusLockerBase::reportThreadAction(action, QDBusLockerBase::BeforePost, this);
    QCoreApplication::postEvent(object, ev);
    QDBusLockerBase::reportThreadAction(action, QDBusLockerBase::AfterPost, this);
}

prepareHook()

bool QDBusConnectionPrivate::prepareHook ( QDBusConnectionPrivate::SignalHook &  hook, QString &  key, const QString &  service, const QString &  path, const QString &  interface, const QString &  name, const QStringList &  argMatch, QObject *  receiver, const char *  signal, int  minMIdx, bool  buildSignature  )

static

Definition at line 1260 of file qdbusintegrator.cpp.

Referenced by connectRelay(), connectSignal(), disconnectRelay(), and disconnectSignal().

{
    QByteArray normalizedName = signal + 1;
    hook.midx = findSlot(receiver, signal + 1, hook.params);
    if (hook.midx == -1) {
        normalizedName = QMetaObject::normalizedSignature(signal + 1);
        hook.midx = findSlot(receiver, normalizedName, hook.params);
    }
    if (hook.midx < minMIdx) {
        if (hook.midx == -1)
        {}
        return false;
    }

    hook.service = service;
    hook.path = path;
    hook.obj = receiver;
    hook.argumentMatch = argMatch;

    // build the D-Bus signal name and signature
    // This should not happen for QDBusConnection::connect, use buildSignature here, since
    // QDBusConnection::connect passes false and everything else uses true
    QString mname = name;
    if (buildSignature && mname.isNull()) {
        normalizedName.truncate(normalizedName.indexOf('('));
        mname = QString::fromUtf8(normalizedName);
    }
    key = mname;
    key.reserve(interface.length() + 1 + mname.length());
    key += QLatin1Char(':');
    key += interface;

    if (buildSignature) {
        hook.signature.clear();
        for (int i = 1; i < hook.params.count(); ++i)
            if (hook.params.at(i) != QDBusMetaTypeId::message)
                hook.signature += QLatin1String( QDBusMetaType::typeToSignature( hook.params.at(i) ) );
    }

    hook.matchRule = buildMatchRule(service, path, interface, mname, argMatch, hook.signature);
    return true;                // connect to this signal
}

prepareReply()

QDBusCallDeliveryEvent * QDBusConnectionPrivate::prepareReply ( QDBusConnectionPrivate *  target, QObject *  object, int  idx, const QList< int > &  metaTypes, const QDBusMessage &  msg  )

static

Definition at line 731 of file qdbusintegrator.cpp.

Referenced by activateSignal(), and processFinishedCall().

{
    Q_ASSERT(object);
    Q_UNUSED(object);

    int n = metaTypes.count() - 1;
    if (metaTypes[n] == QDBusMetaTypeId::message)
        --n;

    if (msg.arguments().count() < n)
        return 0;               // too few arguments

    // check that types match
    for (int i = 0; i < n; ++i)
        if (metaTypes.at(i + 1) != msg.arguments().at(i).userType() &&
            msg.arguments().at(i).userType() != qMetaTypeId<QDBusArgument>())
            return 0;           // no match

    // we can deliver
    // prepare for the call
    if (target == object)
        return DIRECT_DELIVERY;
    return new QDBusCallDeliveryEvent(QDBusConnection(target), idx, target, msg, metaTypes);
}

processFinishedCall()

void QDBusConnectionPrivate::processFinishedCall ( QDBusPendingCallPrivate *  call )

static

Definition at line 1794 of file qdbusintegrator.cpp.

Referenced by qDBusResultReceived(), and sendWithReplyAsync().

{
    QDBusConnectionPrivate *connection = const_cast<QDBusConnectionPrivate *>(call->connection);

    QMutexLocker locker(&call->mutex);

    QDBusMessage &msg = call->replyMessage;
    if (call->pending) {
        // decode the message
        DBusMessage *reply = q_dbus_pending_call_steal_reply(call->pending);
        msg = QDBusMessagePrivate::fromDBusMessage(reply, connection->capabilities);
        q_dbus_message_unref(reply);
    }
    qDBusDebug() << connection << "got message reply (async):" << msg;

    // Check if the reply has the expected signature
    call->checkReceivedSignature();

    if (!call->receiver.isNull() && call->methodIdx != -1 && msg.type() == QDBusMessage::ReplyMessage) {
        // Deliver the return values of a remote function call.
        //
        // There is only one connection and it is specified by idx
        // The slot must have the same parameter types that the message does
        // The slot may have less parameters than the message
        // The slot may optionally have one final parameter that is QDBusMessage
        // The slot receives read-only copies of the message (i.e., pass by value or by const-ref)

        QDBusCallDeliveryEvent *e = prepareReply(connection, call->receiver, call->methodIdx,
                                                 call->metaTypes, msg);
        if (e)
            connection->postEventToThread(MessageResultReceivedAction, call->receiver, e);
        else
            qDBusDebug() << "Deliver failed!";
    }

    if (call->pending && !call->waitingForFinished) {
        q_dbus_pending_call_unref(call->pending);
        call->pending = 0;
    }

    locker.unlock();

    // Are there any watchers?
    if (call->watcherHelper)
        call->watcherHelper->emitSignals(msg, call->sentMessage);

    if (msg.type() == QDBusMessage::ErrorMessage)
        emit connection->callWithCallbackFailed(QDBusError(msg), call->sentMessage);

    if (!call->ref.deref())
        delete call;
}

q()

static QDBusConnection QDBusConnectionPrivate::q ( QDBusConnectionPrivate *  connection )

inlinestatic

Definition at line 329 of file qdbusconnection_p.h.

Referenced by activateObject(), and qDBusNewConnection().

{ return QDBusConnection(connection); }

registerObject()

void QDBusConnectionPrivate::registerObject

(

const ObjectTreeNode *

node

)

Definition at line 2242 of file qdbusintegrator.cpp.

{
    connect(node->obj, SIGNAL(destroyed(QObject*)), SLOT(objectDestroyed(QObject*)),
            Qt::DirectConnection);

    if (node->flags & (QDBusConnection::ExportAdaptors
                       | QDBusConnection::ExportScriptableSignals
                       | QDBusConnection::ExportNonScriptableSignals)) {
        QDBusAdaptorConnector *connector = qDBusCreateAdaptorConnector(node->obj);

        if (node->flags & (QDBusConnection::ExportScriptableSignals
                           | QDBusConnection::ExportNonScriptableSignals)) {
            connector->disconnectAllSignals(node->obj);
            connector->connectAllSignals(node->obj);
        }

        // disconnect and reconnect to avoid duplicates
        connector->disconnect(SIGNAL(relaySignal(QObject*,const QMetaObject*,int,QVariantList)),
                              this, SLOT(relaySignal(QObject*,const QMetaObject*,int,QVariantList)));
        connect(connector, SIGNAL(relaySignal(QObject*,const QMetaObject*,int,QVariantList)),
                this, SLOT(relaySignal(QObject*,const QMetaObject*,int,QVariantList)),
                Qt::DirectConnection);
    }

    static int counter = 0;
    if ((++counter % 20) == 0)
        cleanupDeletedNodes(rootNode);
}

registerService()

void QDBusConnectionPrivate::registerService

(

const QString &

serviceName

)

Definition at line 2416 of file qdbusintegrator.cpp.

{
    QDBusWriteLocker locker(RegisterServiceAction, this);
    registerServiceNoLock(serviceName);
}

registerServiceNoLock

void QDBusConnectionPrivate::registerServiceNoLock ( const QString &  serviceName )

privateslot

Definition at line 2422 of file qdbusintegrator.cpp.

Referenced by registerService().

{
    serviceNames.append(serviceName);
}

relaySignal

void QDBusConnectionPrivate::relaySignal ( QObject *  obj, const QMetaObject *  mo, int  signalId, const QVariantList &  args  )

slot

Definition at line 1191 of file qdbusintegrator.cpp.

Referenced by registerObject().

{
    QString interface = qDBusInterfaceFromMetaObject(mo);

    QMetaMethod mm = mo->method(signalId);
    QByteArray memberName = mm.signature();
    memberName.truncate(memberName.indexOf('('));

    // check if it's scriptable
    bool isScriptable = mm.attributes() & QMetaMethod::Scriptable;
    bool isAdaptor = false;
    for ( ; mo; mo = mo->superClass())
        if (mo == &QDBusAbstractAdaptor::staticMetaObject) {
            isAdaptor = true;
            break;
        }

    QDBusReadLocker locker(RelaySignalAction, this);
    QDBusMessage message = QDBusMessage::createSignal(QLatin1String("/"), interface,
                                                      QLatin1String(memberName));
    QDBusMessagePrivate::setParametersValidated(message, true);
    message.setArguments(args);
    QDBusError error;
    DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &error);
    if (!msg) {
        qWarning("QDBusConnection: Could not emit signal %s.%s: %s", qPrintable(interface), memberName.constData(),
                 qPrintable(error.message()));
        lastError = error;
        return;
    }

    //qDBusDebug() << "Emitting signal" << message;
    //qDBusDebug() << "for paths:";
    q_dbus_message_set_no_reply(msg, true); // the reply would not be delivered to anything
    huntAndEmit(connection, msg, obj, rootNode, isScriptable, isAdaptor);
    q_dbus_message_unref(msg);
}

send()

int QDBusConnectionPrivate::send

(

const QDBusMessage &

message

)

Definition at line 1847 of file qdbusintegrator.cpp.

Referenced by activateInternalFilters(), deliverCall(), handleObjectCall(), and sendError().

{
    if (QDBusMessagePrivate::isLocal(message))
        return -1;              // don't send; the reply will be retrieved by the caller
                                // through the d_ptr->localReply link

    QDBusError error;
    DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &error);
    if (!msg) {
        if (message.type() == QDBusMessage::MethodCallMessage)
            qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s",
                     qPrintable(message.service()), qPrintable(message.path()),
                     qPrintable(message.interface()), qPrintable(message.member()),
                     qPrintable(error.message()));
        else if (message.type() == QDBusMessage::SignalMessage)
            qWarning("QDBusConnection: error: could not send signal path \"%s\" interface \"%s\" member \"%s\": %s",
                     qPrintable(message.path()), qPrintable(message.interface()),
                     qPrintable(message.member()),
                     qPrintable(error.message()));
        else
            qWarning("QDBusConnection: error: could not send %s message to service \"%s\": %s",
                     message.type() == QDBusMessage::ReplyMessage ? "reply" :
                     message.type() == QDBusMessage::ErrorMessage ? "error" :
                     "invalid", qPrintable(message.service()),
                     qPrintable(error.message()));
        lastError = error;
        return 0;
    }

    q_dbus_message_set_no_reply(msg, true); // the reply would not be delivered to anything

    qDBusDebug() << this << "sending message (no reply):" << message;
    checkThread();
    bool isOk = q_dbus_connection_send(connection, msg, 0);
    int serial = 0;
    if (isOk)
        serial = q_dbus_message_get_serial(msg);

    q_dbus_message_unref(msg);
    return serial;
}

sendError()

void QDBusConnectionPrivate::sendError ( const QDBusMessage &  msg, QDBusError::ErrorType  code  )

private

Definition at line 1308 of file qdbusintegrator.cpp.

Referenced by activateInternalFilters(), activateObject(), handleObjectCall(), and QDBusActivateObjectEvent::~QDBusActivateObjectEvent().

{
    if (code == QDBusError::UnknownMethod) {
        QString interfaceMsg;
        if (msg.interface().isEmpty())
            interfaceMsg = QLatin1String("any interface");
        else
            interfaceMsg = QString::fromLatin1("interface '%1'").arg(msg.interface());

        send(msg.createErrorReply(code,
                                  QString::fromLatin1("No such method '%1' in %2 at object path '%3' "
                                                      "(signature '%4')")
                                  .arg(msg.member(), interfaceMsg, msg.path(), msg.signature())));
    } else if (code == QDBusError::UnknownInterface) {
        send(msg.createErrorReply(QDBusError::UnknownInterface,
                                  QString::fromLatin1("No such interface '%1' at object path '%2'")
                                  .arg(msg.interface(), msg.path())));
    } else if (code == QDBusError::UnknownObject) {
        send(msg.createErrorReply(QDBusError::UnknownObject,
                                  QString::fromLatin1("No such object path '%1'").arg(msg.path())));
    }
}

sendWithReply()

QDBusMessage QDBusConnectionPrivate::sendWithReply	(	const QDBusMessage &	message,
		int	mode,
		int	timeout = -1
	)

Definition at line 1889 of file qdbusintegrator.cpp.

Referenced by findMetaObject(), and getNameOwnerNoCache().

{
    checkThread();
    if ((sendMode == QDBus::BlockWithGui || sendMode == QDBus::Block)
         && isServiceRegisteredByThread(message.service()))
        // special case for synchronous local calls
        return sendWithReplyLocal(message);

    if (!QCoreApplication::instance() || sendMode == QDBus::Block) {
        QDBusError err;
        DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &err);
        if (!msg) {
            qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s",
                     qPrintable(message.service()), qPrintable(message.path()),
                     qPrintable(message.interface()), qPrintable(message.member()),
                     qPrintable(err.message()));
            lastError = err;
            return QDBusMessage::createError(err);
        }

        qDBusDebug() << this << "sending message (blocking):" << message;
        QDBusErrorInternal error;
        DBusMessage *reply = q_dbus_connection_send_with_reply_and_block(connection, msg, timeout, error);

        q_dbus_message_unref(msg);

        if (!!error) {
            lastError = err = error;
            return QDBusMessage::createError(err);
        }

        QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(reply, capabilities);
        q_dbus_message_unref(reply);
        qDBusDebug() << this << "got message reply (blocking):" << amsg;

        return amsg;
    } else { // use the event loop
        QDBusPendingCallPrivate *pcall = sendWithReplyAsync(message, 0, 0, 0, timeout);
        Q_ASSERT(pcall);

        if (pcall->replyMessage.type() == QDBusMessage::InvalidMessage) {
            pcall->watcherHelper = new QDBusPendingCallWatcherHelper;
            QEventLoop loop;
            loop.connect(pcall->watcherHelper, SIGNAL(reply(QDBusMessage)), SLOT(quit()));
            loop.connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), SLOT(quit()));

            // enter the event loop and wait for a reply
            loop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents);
        }

        QDBusMessage reply = pcall->replyMessage;
        lastError = reply;      // set or clear error

        bool r = pcall->ref.deref();
        Q_ASSERT(!r);
        Q_UNUSED(r);

        delete pcall;
        return reply;
    }
}

sendWithReplyAsync()

QDBusPendingCallPrivate * QDBusConnectionPrivate::sendWithReplyAsync	(	const QDBusMessage &	message,
		QObject *	receiver,
		const char *	returnMethod,
		const char *	errorMethod,
		int	timeout = -1
	)

Definition at line 1985 of file qdbusintegrator.cpp.

Referenced by sendWithReply().

{
    if (isServiceRegisteredByThread(message.service())) {
        // special case for local calls
        QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate(message, this);
        pcall->replyMessage = sendWithReplyLocal(message);
        if (receiver && returnMethod)
            pcall->setReplyCallback(receiver, returnMethod);

        if (errorMethod) {
            pcall->watcherHelper = new QDBusPendingCallWatcherHelper;
            connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), receiver, errorMethod,
                    Qt::QueuedConnection);
            pcall->watcherHelper->moveToThread(thread());
        }

        if ((receiver && returnMethod) || errorMethod) {
           // no one waiting, will delete pcall in processFinishedCall()
           pcall->ref = 1;
        } else {
           // set double ref to prevent race between processFinishedCall() and ref counting
           // by QDBusPendingCall::QExplicitlySharedDataPointer<QDBusPendingCallPrivate>
           pcall->ref = 2;
        }
        processFinishedCall(pcall);
        return pcall;
    }

    checkThread();
    QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate(message, this);
    if (receiver && returnMethod)
        pcall->setReplyCallback(receiver, returnMethod);

    if (errorMethod) {
        pcall->watcherHelper = new QDBusPendingCallWatcherHelper;
        connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), receiver, errorMethod,
                Qt::QueuedConnection);
        pcall->watcherHelper->moveToThread(thread());
    }

    if ((receiver && returnMethod) || errorMethod) {
       // no one waiting, will delete pcall in processFinishedCall()
       pcall->ref = 1;
    } else {
       // set double ref to prevent race between processFinishedCall() and ref counting
       // by QDBusPendingCall::QExplicitlySharedDataPointer<QDBusPendingCallPrivate>
       pcall->ref = 2;
    }

    QDBusError error;
    DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &error);
    if (!msg) {
        qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s",
                 qPrintable(message.service()), qPrintable(message.path()),
                 qPrintable(message.interface()), qPrintable(message.member()),
                 qPrintable(error.message()));
        pcall->replyMessage = QDBusMessage::createError(error);
        lastError = error;
        processFinishedCall(pcall);
        return pcall;
    }

    qDBusDebug() << this << "sending message (async):" << message;
    DBusPendingCall *pending = 0;

    QDBusDispatchLocker locker(SendWithReplyAsyncAction, this);
    if (q_dbus_connection_send_with_reply(connection, msg, &pending, timeout)) {
        if (pending) {
            q_dbus_message_unref(msg);

            pcall->pending = pending;
            q_dbus_pending_call_set_notify(pending, qDBusResultReceived, pcall, 0);

            return pcall;
        } else {
            // we're probably disconnected at this point
            lastError = error = QDBusError(QDBusError::Disconnected, QLatin1String("Not connected to server"));
        }
    } else {
        lastError = error = QDBusError(QDBusError::NoMemory, QLatin1String("Out of memory"));
    }

    q_dbus_message_unref(msg);
    pcall->replyMessage = QDBusMessage::createError(error);
    processFinishedCall(pcall);
    return pcall;
}

sendWithReplyLocal()

QDBusMessage QDBusConnectionPrivate::sendWithReplyLocal

(

const QDBusMessage &

message

)

Definition at line 1952 of file qdbusintegrator.cpp.

Referenced by sendWithReply(), and sendWithReplyAsync().

{
    qDBusDebug() << this << "sending message via local-loop:" << message;

    QDBusMessage localCallMsg = QDBusMessagePrivate::makeLocal(*this, message);
    bool handled = handleMessage(localCallMsg);

    if (!handled) {
        QString interface = message.interface();
        if (interface.isEmpty())
            interface = QLatin1String("<no-interface>");
        return QDBusMessage::createError(QDBusError::InternalError,
                                         QString::fromLatin1("Internal error trying to call %1.%2 at %3 (signature '%4'")
                                         .arg(interface, message.member(),
                                              message.path(), message.signature()));
    }

    // if the message was handled, there might be a reply
    QDBusMessage localReplyMsg = QDBusMessagePrivate::makeLocalReply(*this, localCallMsg);
    if (localReplyMsg.type() == QDBusMessage::InvalidMessage) {
        qWarning("QDBusConnection: cannot call local method '%s' at object %s (with signature '%s') "
                 "on blocking mode", qPrintable(message.member()), qPrintable(message.path()),
                 qPrintable(message.signature()));
        return QDBusMessage::createError(
            QDBusError(QDBusError::InternalError,
                       QLatin1String("local-loop message cannot have delayed replies")));
    }

    // there is a reply
    qDBusDebug() << this << "got message via local-loop:" << localReplyMsg;
    return localReplyMsg;
}

serverConnection()

void QDBusConnectionPrivate::serverConnection ( const QDBusConnection &  connection )

inline

Definition at line 225 of file qdbusconnection_p.h.

Referenced by qDBusNewConnection().

        { emit newServerConnection(connection); }

serviceOwnerChanged

void QDBusConnectionPrivate::serviceOwnerChanged ( const QString &  name, const QString &  oldOwner, const QString &  newOwner  )

signal

serviceOwnerChangedNoLock

void QDBusConnectionPrivate::serviceOwnerChangedNoLock ( const QString &  name, const QString &  oldOwner, const QString &  newOwner  )

privateslot

Definition at line 1230 of file qdbusintegrator.cpp.

Referenced by connectSignal().

{
    Q_UNUSED(oldOwner);
//    QDBusWriteLocker locker(UpdateSignalHookOwnerAction, this);
    WatchedServicesHash::Iterator it = watchedServices.find(name);
    if (it == watchedServices.end())
        return;
    if (oldOwner != it->owner)
        qWarning("QDBusConnection: name '%s' had owner '%s' but we thought it was '%s'",
                 qPrintable(name), qPrintable(oldOwner), qPrintable(it->owner));

    qDBusDebug() << this << "Updating name" << name << "from" << oldOwner << "to" << newOwner;
    it->owner = newOwner;
}

setBusService()

void QDBusConnectionPrivate::setBusService

(

const QDBusConnection &

connection

)

Warning

This function is not part of the public interface.

Definition at line 1229 of file qdbusconnection.cpp.

Referenced by QDBusConnection::connectToBus().

{
    busService = new QDBusConnectionInterface(connection, this);
    ref.deref(); // busService has increased the refcounting to us
                 // avoid cyclic refcounting

    QObject::connect(this, SIGNAL(callWithCallbackFailed(QDBusError,QDBusMessage)),
                     busService, SIGNAL(callWithCallbackFailed(QDBusError,QDBusMessage)),
                     Qt::QueuedConnection);
}

setConnection()

void QDBusConnectionPrivate::setConnection	(	DBusConnection *	connection,
		const QDBusErrorInternal &	error
	)

Definition at line 1710 of file qdbusintegrator.cpp.

Referenced by QDBusConnection::connectToBus().

{
    if (!dbc) {
        handleError(error);
        return;
    }

    connection = dbc;
    mode = ClientMode;

    const char *service = q_dbus_bus_get_unique_name(connection);
    Q_ASSERT(service);
    baseService = QString::fromUtf8(service);
    capabilities = connectionCapabilies(connection);

    q_dbus_connection_set_exit_on_disconnect(connection, false);
    q_dbus_connection_set_watch_functions(connection, qDBusAddWatch, qDBusRemoveWatch,
                                          qDBusToggleWatch, this, 0);
    q_dbus_connection_set_timeout_functions(connection, qDBusAddTimeout, qDBusRemoveTimeout,
                                            qDBusToggleTimeout, this, 0);
    q_dbus_connection_set_dispatch_status_function(connection, qDBusUpdateDispatchStatus, this, 0);
    q_dbus_connection_add_filter(connection, qDBusSignalFilter, this, 0);

    // Initialize the hooks for the NameAcquired and NameLost signals
    // we don't use connectSignal here because we don't need the rules to be sent to the bus
    // the bus will always send us these two signals
    SignalHook hook;
    hook.service = dbusServiceString();
    hook.path.clear(); // no matching
    hook.obj = this;
    hook.params << QMetaType::Void << QVariant::String; // both functions take a QString as parameter and return void

    hook.midx = staticMetaObject.indexOfSlot("registerServiceNoLock(QString)");
    Q_ASSERT(hook.midx != -1);
    signalHooks.insert(QLatin1String("NameAcquired:" DBUS_INTERFACE_DBUS), hook);

    hook.midx = staticMetaObject.indexOfSlot("unregisterServiceNoLock(QString)");
    Q_ASSERT(hook.midx != -1);
    signalHooks.insert(QLatin1String("NameLost:" DBUS_INTERFACE_DBUS), hook);

    qDBusDebug() << this << ": connected successfully";

    // schedule a dispatch:
    QMetaObject::invokeMethod(this, "doDispatch", Qt::QueuedConnection);
}

setPeer()

void QDBusConnectionPrivate::setPeer	(	DBusConnection *	connection,
		const QDBusErrorInternal &	error
	)

Definition at line 1657 of file qdbusintegrator.cpp.

Referenced by QDBusConnection::connectToPeer(), and qDBusNewConnection().

{
    if (!c) {
        handleError(error);
        return;
    }

    connection = c;
    mode = PeerMode;

    q_dbus_connection_set_exit_on_disconnect(connection, false);
    q_dbus_connection_set_watch_functions(connection,
                                        qDBusAddWatch,
                                        qDBusRemoveWatch,
                                        qDBusToggleWatch,
                                        this, 0);
    q_dbus_connection_set_timeout_functions(connection,
                                          qDBusAddTimeout,
                                          qDBusRemoveTimeout,
                                          qDBusToggleTimeout,
                                          this, 0);
    q_dbus_connection_set_dispatch_status_function(connection, qDBusUpdateDispatchStatus, this, 0);
    q_dbus_connection_add_filter(connection,
                               qDBusSignalFilter,
                               this, 0);

    QMetaObject::invokeMethod(this, "doDispatch", Qt::QueuedConnection);
}

setSender()

void QDBusConnectionPrivate::setSender ( const QDBusConnectionPrivate *  s )

static

Warning

This function is not part of the public interface.

Definition at line 1221 of file qdbusconnection.cpp.

Referenced by deliverCall().

{
    _q_manager()->setSender(s);
}

setServer()

void QDBusConnectionPrivate::setServer	(	DBusServer *	server,
		const QDBusErrorInternal &	error
	)

Definition at line 1620 of file qdbusintegrator.cpp.

Referenced by QDBusServer::QDBusServer().

{
    if (!s) {
        handleError(error);
        return;
    }

    server = s;
    mode = ServerMode;

    dbus_bool_t data_allocated = q_dbus_server_allocate_data_slot(&server_slot);
    if (data_allocated && server_slot < 0)
        return;

    dbus_bool_t watch_functions_set = q_dbus_server_set_watch_functions(server,
                                                                      qDBusAddWatch,
                                                                      qDBusRemoveWatch,
                                                                      qDBusToggleWatch,
                                                                      this, 0);
    //qDebug() << "watch_functions_set" << watch_functions_set;
    Q_UNUSED(watch_functions_set);

    dbus_bool_t time_functions_set = q_dbus_server_set_timeout_functions(server,
                                                                       qDBusAddTimeout,
                                                                       qDBusRemoveTimeout,
                                                                       qDBusToggleTimeout,
                                                                       this, 0);
    //qDebug() << "time_functions_set" << time_functions_set;
    Q_UNUSED(time_functions_set);

    q_dbus_server_set_new_connection_function(server, qDBusNewConnection, this, 0);

    dbus_bool_t data_set = q_dbus_server_set_data(server, server_slot, this, 0);
    //qDebug() << "data_set" << data_set;
    Q_UNUSED(data_set);
}

socketRead

void QDBusConnectionPrivate::socketRead ( int  fd )

slot

Definition at line 1136 of file qdbusintegrator.cpp.

{
    QVarLengthArray<DBusWatch *, 2> pendingWatches;

    {
        QDBusWatchAndTimeoutLocker locker(SocketReadAction, this);
        WatcherHash::ConstIterator it = watchers.constFind(fd);
        while (it != watchers.constEnd() && it.key() == fd) {
            if (it->watch && it->read && it->read->isEnabled())
                pendingWatches.append(it.value().watch);
            ++it;
        }
    }

    for (int i = 0; i < pendingWatches.size(); ++i)
        if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_READABLE))
            qDebug("OUT OF MEM");
    doDispatch();
}

socketWrite

void QDBusConnectionPrivate::socketWrite ( int  fd )

slot

Definition at line 1156 of file qdbusintegrator.cpp.

{
    QVarLengthArray<DBusWatch *, 2> pendingWatches;

    {
        QDBusWatchAndTimeoutLocker locker(SocketWriteAction, this);
        WatcherHash::ConstIterator it = watchers.constFind(fd);
        while (it != watchers.constEnd() && it.key() == fd) {
            if (it->watch && it->write && it->write->isEnabled())
                pendingWatches.append(it.value().watch);
            ++it;
        }
    }

    for (int i = 0; i < pendingWatches.size(); ++i)
        if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_WRITABLE))
            qDebug("OUT OF MEM");
}

timerEvent()

void QDBusConnectionPrivate::timerEvent ( QTimerEvent *  event )

protectedvirtual

This event handler can be reimplemented in a subclass to receive timer events for the object.

QTimer provides a higher-level interface to the timer functionality, and also more general information about timers. The timer event is passed in the event parameter.

See also

startTimer(), killTimer(), event()

Reimplemented from QObject.

Definition at line 1083 of file qdbusintegrator.cpp.

{
    {
        QDBusWatchAndTimeoutLocker locker(TimerEventAction, this);
        DBusTimeout *timeout = timeouts.value(e->timerId(), 0);
        if (timeout)
            q_dbus_timeout_handle(timeout);
    }

    doDispatch();
}

unregisterService()

void QDBusConnectionPrivate::unregisterService

(

const QString &

serviceName

)

Definition at line 2427 of file qdbusintegrator.cpp.

{
    QDBusWriteLocker locker(UnregisterServiceAction, this);
    unregisterServiceNoLock(serviceName);
}

unregisterServiceNoLock

void QDBusConnectionPrivate::unregisterServiceNoLock ( const QString &  serviceName )

privateslot

Definition at line 2433 of file qdbusintegrator.cpp.

Referenced by unregisterService().

{
    serviceNames.removeAll(serviceName);
}

waitForFinished()

void QDBusConnectionPrivate::waitForFinished

(

QDBusPendingCallPrivate *

pcall

)

Definition at line 1766 of file qdbusintegrator.cpp.

{
    Q_ASSERT(pcall->pending);
    //Q_ASSERT(pcall->mutex.isLocked()); // there's no such function

    if (pcall->waitingForFinished) {
        // another thread is already waiting
        pcall->waitForFinishedCondition.wait(&pcall->mutex);
    } else {
        pcall->waitingForFinished = true;
        pcall->mutex.unlock();

        {
            QDBusDispatchLocker locker(PendingCallBlockAction, this);
            q_dbus_pending_call_block(pcall->pending);
            // QDBusConnectionPrivate::processFinishedCall() is called automatically
        }
        pcall->mutex.lock();

        if (pcall->pending) {
            q_dbus_pending_call_unref(pcall->pending);
            pcall->pending = 0;
        }

        pcall->waitForFinishedCondition.wakeAll();
    }
}

Friends and Related Functions

QDBusActivateObjectEvent

friend class QDBusActivateObjectEvent

friend

Definition at line 333 of file qdbusconnection_p.h.

QDBusCallDeliveryEvent

friend class QDBusCallDeliveryEvent

friend

Definition at line 334 of file qdbusconnection_p.h.

Referenced by prepareReply().

Properties

baseService

QString QDBusConnectionPrivate::baseService

Definition at line 275 of file qdbusconnection_p.h.

Referenced by closeConnection(), isServiceRegisteredByThread(), QDBusMessagePrivate::makeLocal(), operator<<(), and setConnection().

busService

QDBusConnectionInterface* QDBusConnectionPrivate::busService

Definition at line 285 of file qdbusconnection_p.h.

cachedMetaObjects

MetaObjectHash QDBusConnectionPrivate::cachedMetaObjects

Definition at line 305 of file qdbusconnection_p.h.

Referenced by findMetaObject(), and ~QDBusConnectionPrivate().

callDeliveryMutex

QMutex QDBusConnectionPrivate::callDeliveryMutex

Definition at line 307 of file qdbusconnection_p.h.

callDeliveryState

QDBusCallDeliveryEvent* QDBusConnectionPrivate::callDeliveryState

Definition at line 308 of file qdbusconnection_p.h.

capabilities

QDBusConnection::ConnectionCapabilities QDBusConnectionPrivate::capabilities

Definition at line 273 of file qdbusconnection_p.h.

Referenced by QDBusMessagePrivate::makeLocal(), processFinishedCall(), qDBusSignalFilter(), relaySignal(), send(), sendWithReply(), sendWithReplyAsync(), and setConnection().

connection

DBusConnection* QDBusConnectionPrivate::connection

Definition at line 283 of file qdbusconnection_p.h.

dispatchLock

QMutex QDBusConnectionPrivate::dispatchLock

Definition at line 296 of file qdbusconnection_p.h.

lastError

QDBusError QDBusConnectionPrivate::lastError

Definition at line 298 of file qdbusconnection_p.h.

Referenced by findMetaObject(), handleError(), QDBusServer::lastError(), QDBusAbstractInterfacePrivate::QDBusAbstractInterfacePrivate(), relaySignal(), send(), sendWithReply(), and sendWithReplyAsync().

lock

QReadWriteLock QDBusConnectionPrivate::lock

Definition at line 297 of file qdbusconnection_p.h.

Referenced by getNameOwner().

matchRefCounts

MatchRefCountHash QDBusConnectionPrivate::matchRefCounts

Definition at line 303 of file qdbusconnection_p.h.

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

mode

ConnectionMode QDBusConnectionPrivate::mode

Definition at line 278 of file qdbusconnection_p.h.

Referenced by QDBusAbstractInterfacePrivate::canMakeCalls(), closeConnection(), connectSignal(), QDBusConnection::disconnectFromBus(), QDBusConnection::disconnectFromPeer(), disconnectSignal(), doDispatch(), qDBusSignalFilter(), setConnection(), setPeer(), and setServer().

name

QString QDBusConnectionPrivate::name

Definition at line 274 of file qdbusconnection_p.h.

Referenced by checkThread(), connectSignal(), disconnectSignal(), operator<<(), prepareHook(), qDBusNewConnection(), QDBusConnectionManager::setConnection(), QDBusConnectionManager::setSender(), and ~QDBusConnectionPrivate().

ref

QAtomicInt QDBusConnectionPrivate::ref

Definition at line 272 of file qdbusconnection_p.h.

Referenced by handleMessage(), QDBusConnection::operator=(), QDBusConnectionManager::removeConnection(), and QDBusConnectionManager::~QDBusConnectionManager().

rootNode

ObjectTreeNode QDBusConnectionPrivate::rootNode

Definition at line 304 of file qdbusconnection_p.h.

Referenced by handleObjectCall(), objectDestroyed(), QDBusConnectionPrivate(), registerObject(), relaySignal(), and ~QDBusConnectionPrivate().

server

DBusServer* QDBusConnectionPrivate::server

Definition at line 284 of file qdbusconnection_p.h.

Referenced by QDBusServer::address(), closeConnection(), QDBusServer::isConnected(), setServer(), and ~QDBusConnectionPrivate().

serverConnectionNames

QStringList QDBusConnectionPrivate::serverConnectionNames

Definition at line 276 of file qdbusconnection_p.h.

Referenced by qDBusNewConnection(), and QDBusServer::~QDBusServer().

serviceNames

QStringList QDBusConnectionPrivate::serviceNames

Definition at line 300 of file qdbusconnection_p.h.

Referenced by isServiceRegisteredByThread(), registerServiceNoLock(), and unregisterServiceNoLock().

signalHooks

SignalHookHash QDBusConnectionPrivate::signalHooks

Definition at line 302 of file qdbusconnection_p.h.

Referenced by connectRelay(), connectSignal(), disconnectRelay(), disconnectSignal(), handleSignal(), objectDestroyed(), and setConnection().

timeouts

TimeoutHash QDBusConnectionPrivate::timeouts

Definition at line 292 of file qdbusconnection_p.h.

Referenced by qDBusRealAddTimeout(), qDBusRemoveTimeout(), and timerEvent().

timeoutsPendingAdd

PendingTimeoutList QDBusConnectionPrivate::timeoutsPendingAdd

Definition at line 293 of file qdbusconnection_p.h.

Referenced by customEvent(), qDBusAddTimeout(), and qDBusRemoveTimeout().

watchAndTimeoutLock

QMutex QDBusConnectionPrivate::watchAndTimeoutLock

Definition at line 290 of file qdbusconnection_p.h.

watchedServices

WatchedServicesHash QDBusConnectionPrivate::watchedServices

Definition at line 301 of file qdbusconnection_p.h.

Referenced by connectSignal(), disconnectSignal(), getNameOwner(), handleSignal(), QDBusConnectionPrivate(), and serviceOwnerChangedNoLock().

watchers

WatcherHash QDBusConnectionPrivate::watchers

Definition at line 291 of file qdbusconnection_p.h.

Referenced by qDBusRealAddWatch(), qDBusRealToggleWatch(), qDBusRemoveWatch(), socketRead(), and socketWrite().

---

The documentation for this class was generated from the following files:

• /src/dbus/qdbusconnection_p.h
• /src/dbus/qdbusconnection.cpp
• /src/dbus/qdbusintegrator.cpp