diff options
Diffstat (limited to 'qt/src')
44 files changed, 10807 insertions, 0 deletions
diff --git a/qt/src/.cvsignore b/qt/src/.cvsignore new file mode 100644 index 00000000..f6454f28 --- /dev/null +++ b/qt/src/.cvsignore @@ -0,0 +1,11 @@ +.deps +.libs +Makefile +Makefile.in +*.lo +*.la +*.bb +*.bbg +*.da +*.gcov +*.moc diff --git a/qt/src/Makefile.am b/qt/src/Makefile.am new file mode 100644 index 00000000..41e3c5eb --- /dev/null +++ b/qt/src/Makefile.am @@ -0,0 +1,70 @@ +INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_QT_CFLAGS) -DDBUS_COMPILATION + +lib_LTLIBRARIES=libdbus-qt4-1.la + +dbusincludedir=$(includedir)/dbus-1.0/dbus +dbusinclude_HEADERS= \ + qdbusbus.h \ + qdbusmacros.h \ + qdbuserror.h \ + qdbusmessage.h \ + qdbusserver.h \ + qdbusconnection.h \ + qdbusabstractinterface.h \ + qdbusinterface.h \ + qdbusutil.h \ + qdbusabstractadaptor.h \ + qdbusreply.h \ + qdbustypehelper_p.h + +noinst_HEADERS= \ + qdbusabstractadaptor_p.h \ + qdbusabstractinterface_p.h \ + qdbusconnection_p.h \ + qdbusinterface_p.h \ + qdbusintrospection_p.h \ + qdbusmarshall_p.h \ + qdbusmessage_p.h \ + qdbusmetaobject_p.h \ + qdbustype_p.h \ + qdbusxmlparser_p.h + +MOCS = qdbusabstractadaptor.moc qdbusserver.moc qdbusconnection_p.moc qdbusconnection_p.moc qdbusabstractadaptor_p.moc qdbusbus.moc qdbusabstractinterface.moc +CLEANFILES = $(MOCS) +BUILT_SOURCES = $(MOCS) + +libdbus_qt4_1_la_SOURCES = \ + qdbusbus.cpp \ + qdbusconnection.cpp \ + qdbuserror.cpp \ + qdbusintegrator.cpp \ + qdbusmarshall.cpp \ + qdbusmessage.cpp \ + qdbusserver.cpp \ + qdbustype.cpp \ + qdbusabstractinterface.cpp \ + qdbusinterface.cpp \ + qdbusxmlparser.cpp \ + qdbusutil.cpp \ + qdbusintrospection.cpp \ + qdbusabstractadaptor.cpp \ + qdbusthread.cpp \ + qdbusinternalfilters.cpp \ + qdbusmetaobject.cpp \ + qdbusmisc.cpp \ + qdbusxmlgenerator.cpp + +qdbusabstractadaptor.lo: qdbusabstractadaptor.moc qdbusabstractadaptor_p.moc +qdbusabstractinterface.lo: qdbusabstractinterface.moc +qdbusbus.lo: qdbusbus.moc +qdbusserver.lo: qdbusserver.moc +qdbusintegrator.lo: qdbusconnection_p.moc + +libdbus_qt4_1_la_LIBADD= $(DBUS_QT_LIBS) $(top_builddir)/dbus/libdbus-1.la +libdbus_qt4_1_la_LDFLAGS= -version-info 1:0 -no-undefined +libdbus_qt4_1_la_CPPFLAGS= -DQDBUS_MAKEDLL + +EXTRA_DIST = qt-dbus.qdocconf + +%.moc: %.h + $(QT_MOC) $< > $@ diff --git a/qt/src/qdbus.h b/qt/src/qdbus.h new file mode 100644 index 00000000..60c35825 --- /dev/null +++ b/qt/src/qdbus.h @@ -0,0 +1,52 @@ +/* qdbus.h precompiled header + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef QDBUS_H +#define QDBUS_H + +#include <QtCore/qglobal.h> + +#if !defined(DBUS_COMPILATION) +# include <dbus/qdbusabstractadaptor.h> +# include <dbus/qdbusabstractinterface.h> +# include <dbus/qdbusbus.h> +# include <dbus/qdbusconnection.h> +# include <dbus/qdbuserror.h> +# include <dbus/qdbusinterface.h> +# include <dbus/qdbusmessage.h> +# include <dbus/qdbusreply.h> +# include <dbus/qdbusserver.h> +# include <dbus/qdbusutil.h> +#else +# include "qdbusabstractadaptor.h" +# include "qdbusabstractinterface.h" +# include "qdbusbus.h" +# include "qdbusconnection.h" +# include "qdbuserror.h" +# include "qdbusinterface.h" +# include "qdbusmessage.h" +# include "qdbusreply.h" +# include "qdbusserver.h" +# include "qdbusutil.h" +#endif + +#endif diff --git a/qt/src/qdbusabstractadaptor.cpp b/qt/src/qdbusabstractadaptor.cpp new file mode 100644 index 00000000..b7c41888 --- /dev/null +++ b/qt/src/qdbusabstractadaptor.cpp @@ -0,0 +1,336 @@ +/* -*- mode: C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusabstractadaptor.h" + +#include <QtCore/qmetaobject.h> +#include <QtCore/qtimer.h> + +#include "qdbusconnection.h" + +#include "qdbusconnection_p.h" // for qDBusParametersForMethod +#include "qdbusabstractadaptor_p.h" + +struct QDBusAdaptorInit +{ + QSignalSpyCallbackSet callbacks; + QDBusAdaptorInit() + { + extern void qt_register_signal_spy_callbacks(const QSignalSpyCallbackSet &callback_set); + callbacks.signal_begin_callback = QDBusAdaptorConnector::signalBeginCallback; + callbacks.signal_end_callback = QDBusAdaptorConnector::signalEndCallback; + callbacks.slot_begin_callback = 0; + callbacks.slot_end_callback = 0; + qt_register_signal_spy_callbacks(callbacks); + + //QDBusAdaptorConnector::id = QObject::registerUserData(); + } +}; + +Q_GLOBAL_STATIC(QDBusAdaptorInit, qAdaptorInit) + +QDBusAdaptorConnector *qDBusFindAdaptorConnector(QObject *obj) +{ + (void)qAdaptorInit(); + + if (!obj) + return 0; + QDBusAdaptorConnector *connector = qFindChild<QDBusAdaptorConnector *>(obj); + if (connector) + connector->polish(); + return connector; +} + +QDBusAdaptorConnector *qDBusFindAdaptorConnector(QDBusAbstractAdaptor *adaptor) +{ + return qDBusFindAdaptorConnector(adaptor->parent()); +} + +QDBusAdaptorConnector *qDBusCreateAdaptorConnector(QObject *obj) +{ + (void)qAdaptorInit(); + + QDBusAdaptorConnector *connector = qDBusFindAdaptorConnector(obj); + if (connector) + return connector; + return new QDBusAdaptorConnector(obj); +} + +QString QDBusAbstractAdaptorPrivate::retrieveIntrospectionXml(QDBusAbstractAdaptor *adaptor) +{ + return adaptor->d->xml; +} + +void QDBusAbstractAdaptorPrivate::saveIntrospectionXml(QDBusAbstractAdaptor *adaptor, + const QString &xml) +{ + adaptor->d->xml = xml; +} + +/*! + \page usingannotations.html + \title Using annotations in adaptors + + It is currently not possible to specify arbitrary annotations in adaptors. +*/ + +/*! + \class QDBusAbstractAdaptor + \brief Abstract adaptor for D-Bus adaptor classes. + + The QDBusAbstractAdaptor class is the starting point for all objects intending to provide + interfaces to the external world using D-Bus. This is accomplished by attaching a one or more + classes derived from QDBusAbstractAdaptor to a normal QObject and then registering that QObject + with QDBusConnection::registerObject. QDBusAbstractAdaptor objects are intended to be + light-weight wrappers, mostly just relaying calls into the real object (see object()) and the + signals from it. + + Each QDBusAbstractAdaptor-derived class should define the D-Bus interface it is implementing + using the Q_CLASSINFO macro in the class definition. + + QDBusAbstractAdaptor uses the standard QObject mechanism of signals, slots and properties to + determine what signals, methods and properties to export to the bus. Any signal emitted by + QDBusAbstractAdaptor-derived classes will be automatically be relayed through any D-Bus + connections the object is registered on. + + Classes derived from QDBusAbstractAdaptor must be created on the heap using the \a new operator + and must not be deleted by the user (they will be deleted automatically when the object they are + connected to is also deleted). + + \sa {usingadaptors.html}{Using adaptors}, QDBusConnection +*/ + +/*! + Constructs a QDBusAbstractAdaptor with \a parent as the object we refer to. +*/ +QDBusAbstractAdaptor::QDBusAbstractAdaptor(QObject* parent) + : QObject(parent), d(new QDBusAbstractAdaptorPrivate) +{ + QDBusAdaptorConnector *connector = qDBusCreateAdaptorConnector(parent); + + connector->waitingForPolish = true; + QTimer::singleShot(0, connector, SLOT(polish())); +} + +/*! + Destroys the adaptor. + + \warning Adaptors are destroyed automatically when the real object they refer to is + destroyed. Do not delete the adaptors yourself. +*/ +QDBusAbstractAdaptor::~QDBusAbstractAdaptor() +{ + delete d; +} + +/*! + Returns the QObject that we're the adaptor for. This is the same object that was passed as an + argument to the QDBusAbstractAdaptor constructor. +*/ +QObject* QDBusAbstractAdaptor::object() const +{ + return parent(); +} + +/*! + Toggles automatic signal relaying from the real object (see object()). + + Automatic signal relaying consists of signal-to-signal connection of the signals on the parent + that have the exact same method signatue in both classes. + + If \a enable is set to true, connect the signals; if set to false, disconnect all signals. +*/ +void QDBusAbstractAdaptor::setAutoRelaySignals(bool enable) +{ + const QMetaObject *us = metaObject(); + const QMetaObject *them = parent()->metaObject(); + for (int idx = staticMetaObject.methodCount(); idx < us->methodCount(); ++idx) { + QMetaMethod mm = us->method(idx); + + if (mm.methodType() != QMetaMethod::Signal) + continue; + + // try to connect/disconnect to a signal on the parent that has the same method signature + QByteArray sig = QMetaObject::normalizedSignature(mm.signature()); + if (them->indexOfSignal(sig) == -1) + continue; + sig.prepend(QSIGNAL_CODE + '0'); + parent()->disconnect(sig, this, sig); + if (enable) + connect(parent(), sig, sig); + } +} + +QDBusAdaptorConnector::QDBusAdaptorConnector(QObject *parent) + : QObject(parent), waitingForPolish(false), lastSignalIdx(0), argv(0) +{ +} + +QDBusAdaptorConnector::~QDBusAdaptorConnector() +{ +} + +void QDBusAdaptorConnector::addAdaptor(QDBusAbstractAdaptor *adaptor) +{ + // find the interface name + const QMetaObject *mo = adaptor->metaObject(); + while (mo != &QDBusAbstractAdaptor::staticMetaObject) { + int ciend = mo->classInfoCount(); + for (int i = mo->classInfoOffset(); i < ciend; ++i) { + QMetaClassInfo mci = mo->classInfo(i); + if (strcmp(mci.name(), QCLASSINFO_DBUS_INTERFACE) == 0 && *mci.value()) { + // find out if this interface exists first + QString interface = QString::fromUtf8(mci.value()); + AdaptorMap::Iterator it = qLowerBound(adaptors.begin(), adaptors.end(), interface); + if (it != adaptors.end() && it->interface == interface) { + // exists. Replace it (though it's probably the same) + it->adaptor = adaptor; + it->metaObject = mo; + } else { + // create a new one + AdaptorData entry; + entry.interface = interface; + entry.adaptor = adaptor; + entry.metaObject = mo; + adaptors << entry; + } + } + } + + mo = mo->superClass(); + } + + // connect the adaptor's signals to our relaySlot slot + mo = adaptor->metaObject(); + for (int i = QDBusAbstractAdaptor::staticMetaObject.methodCount(); + i < mo->methodCount(); ++i) { + QMetaMethod mm = mo->method(i); + + if (mm.methodType() != QMetaMethod::Signal) + continue; + + QByteArray sig = mm.signature(); + sig.prepend(QSIGNAL_CODE + '0'); + disconnect(adaptor, sig, this, SLOT(relaySlot())); + connect(adaptor, sig, this, SLOT(relaySlot())); + } +} + +void QDBusAdaptorConnector::polish() +{ + if (!waitingForPolish) + return; // avoid working multiple times if multiple adaptors were added + + waitingForPolish = false; + const QObjectList &objs = parent()->children(); + foreach (QObject *obj, objs) { + QDBusAbstractAdaptor *adaptor = qobject_cast<QDBusAbstractAdaptor *>(obj); + if (adaptor) + addAdaptor(adaptor); + } + + // sort the adaptor list + qSort(adaptors); +} + +void QDBusAdaptorConnector::relaySlot() +{ + relay(sender()); +} + +void QDBusAdaptorConnector::relay(QObject *sender) +{ + // we're being called because there is a signal being emitted that we must relay + Q_ASSERT(lastSignalIdx); + Q_ASSERT(argv); + Q_ASSERT(senderMetaObject); + + if (senderMetaObject != sender->metaObject()) { + qWarning("Inconsistency detected: QDBusAdaptorConnector::relay got called with unexpected sender object!"); + } else { + QMetaMethod mm = senderMetaObject->method(lastSignalIdx); + QObject *object = static_cast<QDBusAbstractAdaptor *>(sender)->parent(); + + // break down the parameter list + QList<int> types; + int inputCount = qDBusParametersForMethod(mm, types); + if (inputCount == -1) + // invalid signal signature + // qDBusParametersForMethod has already complained + return; + if (inputCount + 1 != types.count() || + types.at(inputCount) == QDBusConnectionPrivate::messageMetaType) { + // invalid signal signature + // qDBusParametersForMethod has not yet complained about this one + qWarning("Cannot relay signal %s::%s", senderMetaObject->className(), mm.signature()); + return; + } + + QByteArray signature = QMetaObject::normalizedSignature(mm.signature()); + signature.truncate(signature.indexOf('(')); // remove parameter decoration + + QVariantList args; + for (int i = 1; i < types.count(); ++i) + args << QVariant(types.at(i), argv[i]); + + // find all the interfaces this signal belongs to + for (const QMetaObject *mo = senderMetaObject; mo != &QDBusAbstractAdaptor::staticMetaObject; + mo = mo->superClass()) { + if (lastSignalIdx < mo->methodOffset()) + break; + + for (int i = mo->classInfoOffset(); i < mo->classInfoCount(); ++i) { + QMetaClassInfo mci = mo->classInfo(i); + if (qstrcmp(mci.name(), QCLASSINFO_DBUS_INTERFACE) == 0 && *mci.value()) + // now emit the signal with all the information + emit relaySignal(object, mci.value(), signature.constData(), args); + } + } + } +} + +void QDBusAdaptorConnector::signalBeginCallback(QObject *caller, int method_index, void **argv) +{ + QDBusAbstractAdaptor *adaptor = qobject_cast<QDBusAbstractAdaptor *>(caller); + if (adaptor) { + QDBusAdaptorConnector *data = qDBusFindAdaptorConnector(adaptor); + data->lastSignalIdx = method_index; + data->argv = argv; + data->senderMetaObject = caller->metaObject(); + data->polish(); // make sure it's polished + } +} + +void QDBusAdaptorConnector::signalEndCallback(QObject *caller, int) +{ + QDBusAbstractAdaptor *adaptor = qobject_cast<QDBusAbstractAdaptor *>(caller); + if (adaptor) { + QDBusAdaptorConnector *data = qDBusFindAdaptorConnector(adaptor); + data->lastSignalIdx = 0; + data->argv = 0; + data->senderMetaObject = 0; + } +} + +#include "qdbusabstractadaptor.moc" +#include "qdbusabstractadaptor_p.moc" diff --git a/qt/src/qdbusabstractadaptor.h b/qt/src/qdbusabstractadaptor.h new file mode 100644 index 00000000..16fbf5d9 --- /dev/null +++ b/qt/src/qdbusabstractadaptor.h @@ -0,0 +1,50 @@ +/* -*- mode: C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSABSTRACTADAPTOR_H +#define QDBUSABSTRACTADAPTOR_H + +#include <QtCore/qobject.h> +#include "qdbusmacros.h" + +class QDBusAbstractAdaptorPrivate; +class QDBUS_EXPORT QDBusAbstractAdaptor: public QObject +{ + Q_OBJECT +protected: + QDBusAbstractAdaptor(QObject *parent); + +public: + ~QDBusAbstractAdaptor(); + + Q_DECL_DEPRECATED QObject *object() const; + +protected: + void setAutoRelaySignals(bool enable); + +private: + friend class QDBusAbstractAdaptorPrivate; + QDBusAbstractAdaptorPrivate *d; +}; + +#endif diff --git a/qt/src/qdbusabstractadaptor_p.h b/qt/src/qdbusabstractadaptor_p.h new file mode 100644 index 00000000..71bfb582 --- /dev/null +++ b/qt/src/qdbusabstractadaptor_p.h @@ -0,0 +1,127 @@ +/* -*- mode: C++; set-fill-width: 100 -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the public API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef QDBUSABSTRACTADAPTORPRIVATE_H +#define QDBUSABSTRACTADAPTORPRIVATE_H + +#include <QtCore/qobject.h> +#include <QtCore/qmap.h> +#include <QtCore/qhash.h> +#include <QtCore/qreadwritelock.h> +#include <QtCore/qvariant.h> +#include <QtCore/qvector.h> + +#define QCLASSINFO_DBUS_INTERFACE "D-Bus Interface" +#define QCLASSINFO_DBUS_INTROSPECTION "D-Bus Introspection" + +class QDBusAbstractAdaptor; +class QDBusAdaptorConnector; +class QDBusAdaptorManager; +class QDBusConnectionPrivate; + +#if QT_VERSION < 0x040200 +/* mirrored in qobject_p.h, DON'T CHANGE without prior warning */ +struct QSignalSpyCallbackSet +{ + typedef void (*BeginCallback)(QObject *caller, int method_index, void **argv); + typedef void (*EndCallback)(QObject *caller, int method_index); + BeginCallback signal_begin_callback, + slot_begin_callback; + EndCallback signal_end_callback, + slot_end_callback; +}; +#else +# error Qt 4.2.0 is supposed to have a better solution! + CHOKE! +#endif // Qt 4.2.0 + +class QDBusAbstractAdaptorPrivate +{ +public: + QString xml; + + static QString retrieveIntrospectionXml(QDBusAbstractAdaptor *adaptor); + static void saveIntrospectionXml(QDBusAbstractAdaptor *adaptor, const QString &xml); +}; + +class QDBusAdaptorConnector: public QObject +{ + Q_OBJECT +public: // typedefs + struct AdaptorData + { + QString interface; + QDBusAbstractAdaptor *adaptor; + const QMetaObject *metaObject; + + inline bool operator<(const AdaptorData &other) const + { return interface < other.interface; } + inline bool operator<(const QString &other) const + { return interface < other; } + }; + typedef QVector<AdaptorData> AdaptorMap; + +public: // methods + explicit QDBusAdaptorConnector(QObject *parent); + ~QDBusAdaptorConnector(); + + void addAdaptor(QDBusAbstractAdaptor *adaptor); + void relay(QObject *sender); + +public slots: + void relaySlot(); + void polish(); + +signals: + void relaySignal(QObject *obj, const char *interface, const char *name, const QVariantList &args); + +public: // member variables + AdaptorMap adaptors; + bool waitingForPolish : 1; + + int lastSignalIdx; + void **argv; + const QMetaObject *senderMetaObject; + +public: // static members + static void signalBeginCallback(QObject *caller, int method_index, void **argv); + static void signalEndCallback(QObject *caller, int method_index); + //static int id; +}; + +extern QDBusAdaptorConnector *qDBusFindAdaptorConnector(QObject *object); +extern QDBusAdaptorConnector *qDBusCreateAdaptorConnector(QObject *object); + +#endif // QDBUSABSTRACTADAPTORPRIVATE_H diff --git a/qt/src/qdbusabstractinterface.cpp b/qt/src/qdbusabstractinterface.cpp new file mode 100644 index 00000000..2a6bcf04 --- /dev/null +++ b/qt/src/qdbusabstractinterface.cpp @@ -0,0 +1,389 @@ +/* -*- C++ -*- + * + * Copyright (C) 2005 Thiago Macieira <thiago@kde.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusabstractinterface.h" + +#include "qdbusabstractinterface_p.h" +#include "qdbusmetaobject_p.h" +#include "qdbusconnection_p.h" + +QVariant QDBusAbstractInterfacePrivate::property(const QMetaProperty &mp) const +{ + // try to read this property + QDBusMessage msg = QDBusMessage::methodCall(service, path, DBUS_INTERFACE_PROPERTIES, + QLatin1String("Get")); + msg << interface << QString::fromUtf8(mp.name()); + QDBusMessage reply = connp->sendWithReply(msg, QDBusConnection::NoUseEventLoop); + + if (reply.type() == QDBusMessage::ReplyMessage && reply.count() == 1 && + reply.signature() == QLatin1String("v")) { + QVariant value = QDBusTypeHelper<QVariant>::fromVariant(reply.at(0)); + + // make sure the type is right + if (qstrcmp(mp.typeName(), value.typeName()) == 0) { + if (mp.type() == QVariant::LastType) + // QVariant is special in this context + return QDBusTypeHelper<QVariant>::fromVariant(value); + + return value; + } + } + + // there was an error... + if (reply.type() == QDBusMessage::ErrorMessage) + lastError = reply; + else if (reply.signature() != QLatin1String("v")) { + QString errmsg = QLatin1String("Invalid signature `%1' in return from call to " + DBUS_INTERFACE_PROPERTIES); + lastError = QDBusError(QDBusError::InvalidSignature, errmsg.arg(reply.signature())); + } else { + QString errmsg = QLatin1String("Unexpected type `%1' when retrieving property " + "`%2 %3.%4'"); + lastError = QDBusError(QDBusError::InvalidSignature, + errmsg.arg(QLatin1String(reply.at(0).typeName()), + QLatin1String(mp.typeName()), + interface, QString::fromUtf8(mp.name()))); + } + + return QVariant(); +} + +void QDBusAbstractInterfacePrivate::setProperty(const QMetaProperty &mp, const QVariant &value) +{ + // send the value + QDBusMessage msg = QDBusMessage::methodCall(service, path, DBUS_INTERFACE_PROPERTIES, + QLatin1String("Set")); + msg.setSignature(QLatin1String("ssv")); + msg << interface << QString::fromUtf8(mp.name()) << value; + QDBusMessage reply = connp->sendWithReply(msg, QDBusConnection::NoUseEventLoop); + + if (reply.type() != QDBusMessage::ReplyMessage) + lastError = reply; +} + +/*! + \class QDBusAbstractInterface + \brief Base class for all D-Bus interfaces in the QtDBus binding, allowing access to remote interfaces. + + Generated-code classes also derive from QDBusAbstractInterface, all methods described here are also + valid for generated-code classes. In addition to those described here, generated-code classes + provide member functions for the remote methods, which allow for compile-time checking of the + correct parameters and return values, as well as property type-matching and signal + parameter-matching. + + \sa {dbusidl2cpp.html}{The dbusidl2cpp compiler}, QDBusInterface +*/ + +/*! + \enum QDBusAbstractInterface::CallMode + + Specifies how a call should be placed. The valid options are: + \value NoWaitForReply place the call but don't wait for the reply (the reply's contents + will be discarded) + \value NoUseEventLoop don't use an event loop to wait for a reply, but instead block on + network operations while waiting. This option means the + user-interface may not be updated for the duration of the call. + \value UseEventLoop use the Qt event loop to wait for a reply. This option means the + user-interface will update, but it also means other events may + happen, like signal delivery and other D-Bus method calls. + + When using UseEventLoop, applications must be prepared for reentrancy in any function. +*/ + +/*! + \internal +*/ +QDBusAbstractInterface::QDBusAbstractInterface(QDBusAbstractInterfacePrivate* d) +#if QT_VERSION < 0x040200 + : d_ptr(d) +{ + d_ptr->q_ptr = this; +} +#endif + +/*! + Releases this object's resources. +*/ +QDBusAbstractInterface::~QDBusAbstractInterface() +{ + delete d_ptr; +} + +/*! + Returns true if this is a valid reference to a remote object. It returns false if + there was an error during the creation of this interface (for instance, if the remote + application does not exist). + + Note: when dealing with remote objects, it is not always possible to determine if it + exists when creating a QDBusInterface or QDBusInterfacePtr object. +*/ +bool QDBusAbstractInterface::isValid() const +{ + return d_func()->isValid; +} + +/*! + Returns the connection this interface is assocated with. +*/ +QDBusConnection QDBusAbstractInterface::connection() const +{ + return d_func()->conn; +} + +/*! + Returns the name of the service this interface is associated with. +*/ +QString QDBusAbstractInterface::service() const +{ + return d_func()->service; +} + +/*! + Returns the object path that this interface is associated with. +*/ +QString QDBusAbstractInterface::path() const +{ + return d_func()->path; +} + +/*! + Returns the name of this interface. +*/ +QString QDBusAbstractInterface::interface() const +{ + return d_func()->interface; +} + +/*! + Returns the error the last operation produced, or an invalid error if the last operation did not + produce an error. +*/ +QDBusError QDBusAbstractInterface::lastError() const +{ + return d_func()->lastError; +} + +/*! + \threadsafe + Places a call to the remote method specified by \a method on this interface, using \a args as + arguments. This function returns the message that was received as a reply, which can be a normal + QDBusMessage::ReplyMessage (indicating success) or QDBusMessage::ErrorMessage (if the call + failed). The \a mode parameter specifies how this call should be placed. + + If the call succeeds, lastError() will be cleared; otherwise, it will contain the error this + call produced. + + Normally, you should place calls using call(). + + \warning If you use \c UseEventLoop, your code must be prepared to deal with any reentrancy: + other method calls and signals may be delivered before this function returns, as well + as other Qt queued signals and events. +*/ +QDBusMessage QDBusAbstractInterface::callWithArgs(const QString& method, const QList<QVariant>& args, + CallMode mode) +{ + Q_D(QDBusAbstractInterface); + + QString m = method, sig; + // split out the signature from the method + int pos = method.indexOf(QLatin1Char('.')); + if (pos != -1) { + m.truncate(pos); + sig = method.mid(pos + 1); + } + + if (mode == AutoDetect) { + // determine if this a sync or async call + mode = NoUseEventLoop; + const QMetaObject *mo = metaObject(); + QByteArray match = method.toLatin1() + '('; + + for (int i = staticMetaObject.methodCount(); i < mo->methodCount(); ++i) { + QMetaMethod mm = mo->method(i); + if (QByteArray(mm.signature()).startsWith(match)) { + // found a method with the same name as what we're looking for + // hopefully, nobody is overloading asynchronous and synchronous methods with + // the same name + + QList<QByteArray> tags = QByteArray(mm.tag()).split(' '); + if (tags.contains("async") || tags.contains("Q_ASYNC")) + mode = NoWaitForReply; + + break; + } + } + } + + QDBusMessage msg = QDBusMessage::methodCall(service(), path(), interface(), m); + msg.setSignature(sig); + msg.QList<QVariant>::operator=(args); + + QDBusMessage reply; + if (mode != NoWaitForReply) + reply = d->conn.sendWithReply(msg, mode == UseEventLoop ? + QDBusConnection::UseEventLoop : QDBusConnection::NoUseEventLoop); + else + d->conn.send(msg); + + d->lastError = reply; // will clear if reply isn't an error + + // ensure that there is at least one element + if (reply.isEmpty()) + reply << QVariant(); + + return reply; +} + +/*! + \overload + Places a call to the remote method specified by \a method on this interface, using \a args as + arguments. This function will return immediately after queueing the call. The reply from the + remote function or any errors emitted by it will be delivered to the \a slot slot on object \a + receiver. + + This function returns true if the queueing succeeded: it does not indicate that the call + succeeded. If it failed, the slot will be called with an error message. lastError() will not be + set under those circumstances. + + \sa QDBusError, QDBusMessage +*/ +bool QDBusAbstractInterface::callWithArgs(const QString &method, QObject *receiver, const char *slot, + const QList<QVariant> &args) +{ + Q_D(QDBusAbstractInterface); + + QString m = method, sig; + // split out the signature from the method + int pos = method.indexOf(QLatin1Char('.')); + if (pos != -1) { + m.truncate(pos); + sig = method.mid(pos + 1); + } + + QDBusMessage msg = QDBusMessage::methodCall(service(), path(), interface(), m); + msg.setSignature(sig); + msg.QList<QVariant>::operator=(args); + + d->lastError = 0; // clear + return d->conn.sendWithReplyAsync(msg, receiver, slot); +} + +/*! + \internal + Catch signal connections. +*/ +void QDBusAbstractInterface::connectNotify(const char *signal) +{ + // someone connecting to one of our signals + Q_D(QDBusAbstractInterface); + + d->connp->connectRelay(d->service, d->path, d->interface, this, signal); +} + +/*! + \internal + Catch signal disconnections. +*/ +void QDBusAbstractInterface::disconnectNotify(const char *signal) +{ + // someone disconnecting from one of our signals + Q_D(QDBusAbstractInterface); + + d->connp->disconnectRelay(d->service, d->path, d->interface, this, signal); +} + +/*! + \internal + Get the value of the property \a propname. +*/ +QVariant QDBusAbstractInterface::internalPropGet(const char *propname) const +{ + // assume this property exists and is readable + // we're only called from generated code anyways + + int idx = metaObject()->indexOfProperty(propname); + if (idx != -1) + return d_func()->property(metaObject()->property(idx)); + qWarning("QDBusAbstractInterface::internalPropGet called with unknown property '%s'", propname); + return QVariant(); // error +} + +/*! + \internal + Set the value of the property \a propname to \a value. +*/ +void QDBusAbstractInterface::internalPropSet(const char *propname, const QVariant &value) +{ + Q_D(QDBusAbstractInterface); + + // assume this property exists and is writeable + // we're only called from generated code anyways + + int idx = metaObject()->indexOfProperty(propname); + if (idx != -1) + d->setProperty(metaObject()->property(idx), value); + else + qWarning("QDBusAbstractInterface::internalPropGet called with unknown property '%s'", propname); +} + +/*! + \overload + \fn QDBusMessage QDBusAbstractInterface::call(const QString &method) + + Calls the method \a method on this interface and passes the parameters to this function to the + method. + + The parameters to \c call are passed on to the remote function via D-Bus as input + arguments. Output arguments are returned in the QDBusMessage reply. If the reply is an error + reply, lastError() will also be set to the contents of the error message. + + This function is implemented by actually 9 different function overloads called \c call, so you + can pass up to 8 parameters to your function call, which can be of any type accepted by QtDBus + (see the \l {allowedparameters.html}{allowed parameters} page for information on what types are + accepted). + + It can be used the following way: + + \code + QString value = retrieveValue(); + QDBusMessage reply; + + QDBusReply<int> api = interface->call(QLatin1String("GetAPIVersion")); + if (api >= 14) + reply = interface->call(QLatin1String("ProcessWorkUnicode"), value); + else + reply = interface->call(QLatin1String("ProcessWork"), QLatin1String("UTF-8"), value.toUtf8()); + \endcode + + This example illustrates function calling with 0, 1 and 2 parameters and illustrates different + parameter types passed in each (the first call to \c "ProcessWorkUnicode" will contain one + Unicode string, the second call to \c "ProcessWork" will contain one string and one byte array). + + \warning This function reenters the Qt event loop in order to wait for the reply, excluding user + input. During the wait, it may deliver signals and other method calls to your + application. Therefore, it must be prepared to handle a reentrancy whenever a call is + placed with call(). +*/ + +#include "qdbusabstractinterface.moc" diff --git a/qt/src/qdbusabstractinterface.h b/qt/src/qdbusabstractinterface.h new file mode 100644 index 00000000..aa6d00d7 --- /dev/null +++ b/qt/src/qdbusabstractinterface.h @@ -0,0 +1,257 @@ +/* -*- C++ -*- + * + * Copyright (C) 2005 Thiago Macieira <thiago@kde.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSABSTRACTINTERFACE_H +#define QDBUSABSTRACTINTERFACE_H + +#include <QtCore/qstring.h> +#include <QtCore/qvariant.h> +#include <QtCore/qlist.h> +#include <QtCore/qobject.h> + +#include "qdbusmessage.h" +#include "qdbustypehelper_p.h" + +class QDBusConnection; +class QDBusError; + +class QDBusAbstractInterfacePrivate; +class QDBUS_EXPORT QDBusAbstractInterface: public QObject +{ + Q_OBJECT + +public: + enum CallMode { + NoWaitForReply, + UseEventLoop, + NoUseEventLoop, + AutoDetect + }; + +public: + virtual ~QDBusAbstractInterface(); + bool isValid() const; + + QDBusConnection connection() const; + + QString service() const; + QString path() const; + QString interface() const; + + QDBusError lastError() const; + + QDBusMessage callWithArgs(const QString &method, const QList<QVariant> &args = QList<QVariant>(), + CallMode mode = AutoDetect); + bool callWithArgs(const QString &method, QObject *receiver, const char *slot, + const QList<QVariant> &args = QList<QVariant>()); + + inline QDBusMessage call(const QString &m) + { + return callWithArgs(m); + } + + inline QDBusMessage call(CallMode mode, const QString &m) + { + return callWithArgs(m, QList<QVariant>(), mode); + } + +#ifndef Q_QDOC +private: + template<typename T> inline QVariant qvfv(const T &t) + { return QDBusTypeHelper<T>::toVariant(t); } + +public: + template<typename T1> + inline QDBusMessage call(const QString &m, const T1 &t1) + { + QList<QVariant> args; + args << qvfv(t1); + return callWithArgs(m, args); + } + + template<typename T1, typename T2> + inline QDBusMessage call(const QString &m, const T1 &t1, const T2 &t2) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2); + return callWithArgs(m, args); + } + + template<typename T1, typename T2, typename T3> + inline QDBusMessage call(const QString &m, const T1 &t1, const T2 &t2, const T3 &t3) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3); + return callWithArgs(m, args); + } + + template<typename T1, typename T2, typename T3, typename T4> + inline QDBusMessage call(const QString &m, const T1 &t1, const T2 &t2, const T3 &t3, + const T4 &t4) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3) + << qvfv(t4); + return callWithArgs(m, args); + } + + template<typename T1, typename T2, typename T3, typename T4, typename T5> + inline QDBusMessage call(const QString &m, const T1 &t1, const T2 &t2, const T3 &t3, + const T4 &t4, const T5 &t5) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3) + << qvfv(t4) << qvfv(t5); + return callWithArgs(m, args); + } + + template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> + inline QDBusMessage call(const QString &m, const T1 &t1, const T2 &t2, const T3 &t3, + const T4 &t4, const T5 &t5, const T6 &t6) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3) + << qvfv(t4) << qvfv(t5) << qvfv(t6); + return callWithArgs(m, args); + } + + template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> + inline QDBusMessage call(const QString &m, const T1 &t1, const T2 &t2, const T3 &t3, + const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3) + << qvfv(t4) << qvfv(t5) << qvfv(t6) + << qvfv(t7); + return callWithArgs(m, args); + } + + template<typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8> + inline QDBusMessage call(const QString &m, const T1 &t1, const T2 &t2, const T3 &t3, + const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3) + << qvfv(t4) << qvfv(t5) << qvfv(t6) + << qvfv(t7) << qvfv(t8); + return callWithArgs(m, args); + } + + template<typename T1> + inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1) + { + QList<QVariant> args; + args << qvfv(t1); + return callWithArgs(m, args, mode); + } + + template<typename T1, typename T2> + inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2); + return callWithArgs(m, args, mode); + } + + template<typename T1, typename T2, typename T3> + inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2, + const T3 &t3) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3); + return callWithArgs(m, args, mode); + } + + template<typename T1, typename T2, typename T3, typename T4> + inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2, + const T3 &t3, const T4 &t4) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3) + << qvfv(t4); + return callWithArgs(m, args, mode); + } + + template<typename T1, typename T2, typename T3, typename T4, typename T5> + inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2, + const T3 &t3, const T4 &t4, const T5 &t5) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3) + << qvfv(t4) << qvfv(t5); + return callWithArgs(m, args, mode); + } + + template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> + inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2, + const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3) + << qvfv(t4) << qvfv(t5) << qvfv(t6); + return callWithArgs(m, args, mode); + } + + template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> + inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2, + const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3) + << qvfv(t4) << qvfv(t5) << qvfv(t6) + << qvfv(t7); + return callWithArgs(m, args, mode); + } + + template<typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8> + inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2, + const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, + const T8 &t8) + { + QList<QVariant> args; + args << qvfv(t1) << qvfv(t2) << qvfv(t3) + << qvfv(t4) << qvfv(t5) << qvfv(t6) + << qvfv(t7) << qvfv(t8); + return callWithArgs(m, args, mode); + } +#endif + +protected: + QDBusAbstractInterface(QDBusAbstractInterfacePrivate *); + void connectNotify(const char *signal); + void disconnectNotify(const char *signal); + QVariant internalPropGet(const char *propname) const; + void internalPropSet(const char *propname, const QVariant &value); + +private: + friend class QDBusInterface; + QDBusAbstractInterfacePrivate *d_ptr; // remove for Qt 4.2.0 + + Q_DECLARE_PRIVATE(QDBusAbstractInterface) + Q_DISABLE_COPY(QDBusAbstractInterface) +}; + +#endif diff --git a/qt/src/qdbusabstractinterface_p.h b/qt/src/qdbusabstractinterface_p.h new file mode 100644 index 00000000..43807071 --- /dev/null +++ b/qt/src/qdbusabstractinterface_p.h @@ -0,0 +1,72 @@ +/* + * + * Copyright (C) 2006 Thiago José Macieira <thiago@kde.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the public API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef QDBUSABSTRACTINTERFACEPRIVATE_H +#define QDBUSABSTRACTINTERFACEPRIVATE_H + +#include "qdbusabstractinterface.h" +#include "qdbusconnection.h" +#include "qdbuserror.h" + +#define ANNOTATION_NO_WAIT "org.freedesktop.DBus.Method.NoReply" + +class QDBusAbstractInterfacePrivate//: public QObjectPrivate +{ +public: + Q_DECLARE_PUBLIC(QDBusAbstractInterface) + + QDBusAbstractInterface *q_ptr; // remove in Qt 4.2 + QDBusConnection conn; + QDBusConnectionPrivate *connp; + QString service; + QString path; + QString interface; + mutable QDBusError lastError; + bool isValid; + + inline QDBusAbstractInterfacePrivate(const QDBusConnection& con, QDBusConnectionPrivate *conp, + const QString &serv, const QString &p, const QString &iface) + : conn(con), connp(conp), service(serv), path(p), interface(iface), isValid(true) + { } + virtual ~QDBusAbstractInterfacePrivate() { } + + // these functions do not check if the property is valid + QVariant property(const QMetaProperty &mp) const; + void setProperty(const QMetaProperty &mp, const QVariant &value); +}; + + +#endif diff --git a/qt/src/qdbusbus.cpp b/qt/src/qdbusbus.cpp new file mode 100644 index 00000000..02c231eb --- /dev/null +++ b/qt/src/qdbusbus.cpp @@ -0,0 +1,302 @@ +/* -*- C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +/* + * This file was generated by dbusidl2cpp version 0.3 + * when processing input file - + * + * dbusidl2cpp is Copyright (C) 2006 Trolltech AS. All rights reserved. + * + * This file has been hand-edited! Be careful when re-generating it! + * + */ + +#include "qdbusbus.h" + +#include <QtCore/QByteArray> +#include <QtCore/QList> +#include <QtCore/QMap> +#include <QtCore/QString> +#include <QtCore/QStringList> +#include <QtCore/QVariant> + +/* + * Implementation of interface class QDBusBusService + */ + +/*! + \class QDBusBusService + \brief Provides access to the D-Bus bus daemon service. + +*/ + +/*! + \enum QDBusBusService::RequestNameOption + + Flags for requesting a name on the bus. + + \value AllowReplacingName Allow another application requesting the same name to take the name + from this application. + \value ReplaceExistingName If another application already has the name and allows replacing, + take the name and assign it to us. + \value DoNotQueueName Without this flag, if an application requests a name that is already + owned and does not allow replacing, it will be queued until the + name is given up. If this flag is given, no queueing will be + performed and the requestName() call will simply fail. +*/ + +/*! + \enum QDBusBusService::RequestNameReply + + The possible return values from requestName(): + + \value PrimaryOwnerReply The caller is now the primary owner of the name. + \value InQueueReply The caller is in queue for the name, but does not own it. + \value NameExistsReply The name exists and could not be replaced, or the caller did + specify DoNotQueueName. + \value AlreadyOwnerReply The caller tried to request a name that it already owns. +*/ + +/*! + \enum QDBusBusService::ReleaseNameReply + + The possible return values from releaseName(): + + \value NameReleasedReply The caller released his claim on the name. + \value NameNonExistentReply The caller tried to release a name that did not exist. + \value NotOwnerReply The caller tried to release a name that it did not own or was not in + queue for. +*/ + +/*! + \enum QDBusBusService::StartServiceReply + + The possible return values from startServiceByName(): + + \value Success The service was successfully started. + \value AlreadyRunning The service was already running. +*/ + +/*! + \internal +*/ +const char *QDBusBusService::staticInterfaceName() +{ return "org.freedesktop.DBus"; } + + +/*! + \internal +*/ +QDBusBusService::QDBusBusService(QDBusAbstractInterfacePrivate *p) + : QDBusAbstractInterface(p) +{ + connect(this, SIGNAL(NameAcquired(QString)), this, SIGNAL(nameAcquired(QString))); + connect(this, SIGNAL(NameLost(QString)), this, SIGNAL(nameLost(QString))); + connect(this, SIGNAL(NameOwnerChanged(QString,QString,QString)), + this, SIGNAL(nameOwnerChanged(QString,QString,QString))); +} + +/*! + \internal +*/ +QDBusBusService::~QDBusBusService() +{ +} + +/*! + \fn QDBusBusService::hello() + \internal + Sends a "Hello" request to the bus service. You do not want to call this. +*/ +QDBusReply<QString> QDBusBusService::Hello() +{ + return call(QLatin1String("Hello")); +} + +/*! + \fn QDBusBusService::nameOwner(const QString &name) + Returns the unique connection name of the primary owner of the name \a name. If the requested + name doesn't have an owner, returns a org.freedesktop.DBus.Error.NameHasNoOwner error. +*/ +QDBusReply<QString> QDBusBusService::GetNameOwner(const QString &name) +{ + return call(QLatin1String("GetNameOwner.s"), name); +} + +/*! + \fn QDBusBusService::listNames() + Lists all names currently existing on the bus. +*/ +QDBusReply<QStringList> QDBusBusService::ListNames() +{ + return call(QLatin1String("ListNames")); +} + +/*! + \fn QDBusBusService::listQueuedOwners(const QString &service) + Returns a list of all unique connection names in queue for the service name \a service. +*/ +QDBusReply<QStringList> QDBusBusService::ListQueuedOwners(const QString &service) +{ + return call(QLatin1String("ListQueuedOwners.s"), service); +} + +/*! + \fn QDBusBusService::nameHasOwner(const QString &service) + Returns true if the service name \a service has an owner. +*/ +QDBusReply<bool> QDBusBusService::NameHasOwner(const QString &service) +{ + return call(QLatin1String("NameHasOwner.s"), service); +} + +/*! + \fn QDBusBusService::addMatch(const QString &rule) + Adds the rule \a rule for requesting messages from the bus. + + \sa removeMatch() +*/ +QDBusReply<void> QDBusBusService::AddMatch(const QString &rule) +{ + return call(QLatin1String("AddMatch.s"), rule); +} + +/*! + \fn QDBusBusService::removeMatch(const QString &rule) + Removes the rule \a rule, that had previously been added with addMatch(). +*/ +QDBusReply<void> QDBusBusService::RemoveMatch(const QString &rule) +{ + return call(QLatin1String("RemoveMatch.s"), rule); +} + +/*! + \fn QDBusBusService::connectionSELinuxSecurityContext(const QString &service) + Returns the SELinux security context of the process currently holding the bus service \a + service. +*/ +QDBusReply<QByteArray> QDBusBusService::GetConnectionSELinuxSecurityContext(const QString &service) +{ + return call(QLatin1String("GetConnectionSELinuxSecurityContext.s"), service); +} + +/*! + \fn QDBusBusService::connectionUnixProcessID(const QString &service) + Returns the Unix Process ID (PID) for the process currently holding the bus service \a service. +*/ +QDBusReply<uint> QDBusBusService::GetConnectionUnixProcessID(const QString &service) +{ + return call(QLatin1String("GetConnectionUnixProcessID.s"), service); +} + +/*! + \fn QDBusBusService::connectionUnixUser(const QString &service) + Returns the Unix User ID (UID) for the process currently holding the bus service \a service. +*/ +QDBusReply<uint> QDBusBusService::GetConnectionUnixUser(const QString &service) +{ + return call(QLatin1String("GetConnectionUnixUser.s"), service); +} + +/*! + \fn QDBusBusService::reloadConfig() + Asks the D-Bus server daemon to reload its configuration. +*/ +QDBusReply<void> QDBusBusService::ReloadConfig() +{ + return call(QLatin1String("ReloadConfig")); +} + +inline QDBUS_EXPORT int qDBusMetaTypeId(QDBusBusService::StartServiceReply *) +{ return QVariant::Int; } + +/*! + \fn QDBusBusService::startServiceByName(const QString &name, uint flags) + Requests that the bus start the service given by the name \a name. + + The \a flags parameter is currently not used. +*/ +QDBusReply<QDBusBusService::StartServiceReply> +QDBusBusService::StartServiceByName(const QString &name, uint flags) +{ + return call(QLatin1String("StartServiceByName.su"), name, flags); +} + +inline QDBUS_EXPORT int qDBusMetaTypeId(QDBusBusService::RequestNameReply *) +{ return QVariant::Int; } + +/*! + \fn QDBusBusService::requestName(const QString &service, RequestNameOptions flags) + Requests the bus service name \a service from the bus. The \a flags parameter specifies how the + bus server daemon should act when the same name is requested by two different applications. + + \sa releaseName() +*/ +QDBusReply<QDBusBusService::RequestNameReply> +QDBusBusService::RequestName(const QString &service, RequestNameOptions flags) +{ + return call(QLatin1String("RequestName.su"), service, uint(int(flags))); +} + +inline QDBUS_EXPORT int qDBusMetaTypeId(QDBusBusService::ReleaseNameReply *) +{ return QVariant::Int; } + +/*! + \fn QDBusBusService::releaseName(const QString &service) + Releases the claim on the bus service name \a service, that had been previously requested with + requestName(). If this application had ownership of the name, it will be released for other + applications to claim. If it only had the name queued, it gives up its position in the queue. +*/ +QDBusReply<QDBusBusService::ReleaseNameReply> +QDBusBusService::ReleaseName(const QString &service) +{ + return call(QLatin1String("ReleaseName.s"), service); +} + +// signals +/*! + \fn QDBusBusService::nameAcquired(const QString &service) + + This signal is emitted by the D-Bus bus server when the bus service name (unique connection name + or well-known service name) given by \a service is acquired by this application. + + Name acquisition happens after the application requested a name using requestName(). +*/ + +/*! + \fn QDBusBusService::nameLost(const QString &service) + + This signal is emitted by the D-Bus bus server when the application loses ownership of the bus + service name given by \a service. +*/ + +/*! + \fn QDBusBusService::nameOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner) + + This signal is emitted by the D-Bus bus server whenever a name ownership change happens in the + bus, including apparition and disparition of names. + + This signal means the application \a oldOwner lost ownership of bus name \a name to application + \a newOwner. If \a oldOwner is an empty string, it means the name \a name has just been created; + if \a newOwner is empty, the name \a name has no current owner. +*/ + +#include "qdbusbus.moc" diff --git a/qt/src/qdbusbus.h b/qt/src/qdbusbus.h new file mode 100644 index 00000000..22606852 --- /dev/null +++ b/qt/src/qdbusbus.h @@ -0,0 +1,158 @@ +/* -*- C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +/* + * This file was generated by dbusidl2cpp version 0.3 + * when processing input file - + * + * dbusidl2cpp is Copyright (C) 2006 Trolltech AS. All rights reserved. + * + * This file has been hand-edited! Be careful when re-generating it! + * + */ + +#ifndef QDBUSBUS_H +#define QDBUSBUS_H + +#include <QtCore/qstringlist.h> + +#include "qdbusabstractinterface.h" +#include "qdbusreply.h" + +class QDBusConnection; +class QString; +class QByteArray; + +/* + * Proxy class for interface org.freedesktop.DBus + */ +class QDBUS_EXPORT QDBusBusService: public QDBusAbstractInterface +{ + Q_OBJECT + friend class QDBusConnection; + static inline const char *staticInterfaceName(); + + explicit QDBusBusService(QDBusAbstractInterfacePrivate *p); + + ~QDBusBusService(); + +public: + // taken out of http://dbus.freedesktop.org/doc/dbus-specification.html + // update if the standard updates + enum RequestNameOption { + AllowReplacingName = 0x1, + ReplaceExistingName = 0x2, + DoNotQueueName = 0x4 + }; + Q_DECLARE_FLAGS(RequestNameOptions, RequestNameOption) + + enum RequestNameReply { + PrimaryOwnerReply = 1, + InQueueReply = 2, + NameExistsReply = 3, + AlreadyOwnerReply = 4 + }; + + enum ReleaseNameReply { + NameReleasedReply = 1, + NameNonExistentReply = 2, + NotOwnerReply = 3 + }; + + enum StartServiceReply { + Success = 1, + AlreadyRunning = 2 + }; + +#ifndef Q_QDOC + // D-Bus names +public: // METHODS + QDBusReply<QString> Hello(); + QDBusReply<void> ReloadConfig(); + + QDBusReply<QStringList> ListNames(); + + QDBusReply<bool> NameHasOwner(const QString &service); + QDBusReply<QString> GetNameOwner(const QString &name); + QDBusReply<ReleaseNameReply> ReleaseName(const QString &service); + QDBusReply<RequestNameReply> RequestName(const QString &service, RequestNameOptions flags); + QDBusReply<QStringList> ListQueuedOwners(const QString &service); + + QDBusReply<void> AddMatch(const QString &rule); + QDBusReply<void> RemoveMatch(const QString &rule); + + QDBusReply<QByteArray> GetConnectionSELinuxSecurityContext(const QString &service); + QDBusReply<uint> GetConnectionUnixProcessID(const QString &service); + QDBusReply<uint> GetConnectionUnixUser(const QString &service); + + QDBusReply<StartServiceReply> StartServiceByName(const QString &name, uint flags); + +signals: // SIGNALS + void NameAcquired(const QString &service); + void NameLost(const QString &service); + void NameOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner); +#endif + + // Qt-style naming +public slots: + QDBusReply<QString> hello() + { return Hello(); } + QDBusReply<void> reloadConfig() + { return ReloadConfig(); } + + QDBusReply<QStringList> listNames() + { return ListNames(); } + + QDBusReply<bool> nameHasOwner(const QString &service) + { return NameHasOwner(service); } + QDBusReply<QString> nameOwner(const QString &name) + { return GetNameOwner(name); } + QDBusReply<ReleaseNameReply> releaseName(const QString &service) + { return ReleaseName(service); } + QDBusReply<RequestNameReply> requestName(const QString &service, RequestNameOptions flags) + { return RequestName(service, flags); } + QDBusReply<QStringList> listQueuedOwners(const QString &service) + { return ListQueuedOwners(service); } + + QDBusReply<void> addMatch(const QString &rule) + { return AddMatch(rule); } + QDBusReply<void> removeMatch(const QString &rule) + { return RemoveMatch(rule); } + + QDBusReply<QByteArray> connectionSELinuxSecurityContext(const QString &service) + { return GetConnectionSELinuxSecurityContext(service); } + QDBusReply<uint> connectionUnixProcessID(const QString &service) + { return GetConnectionUnixProcessID(service); } + QDBusReply<uint> connectionUnixUser(const QString &service) + { return GetConnectionUnixUser(service); } + + QDBusReply<StartServiceReply> startServiceByName(const QString &name, uint flags) + { return StartServiceByName(name, flags); } + +signals: + void nameAcquired(const QString &service); + void nameLost(const QString &service); + void nameOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner); +}; + +Q_DECLARE_OPERATORS_FOR_FLAGS(QDBusBusService::RequestNameOptions) + +#endif diff --git a/qt/src/qdbusconnection.cpp b/qt/src/qdbusconnection.cpp new file mode 100644 index 00000000..6cd733cb --- /dev/null +++ b/qt/src/qdbusconnection.cpp @@ -0,0 +1,753 @@ +/* qdbusconnection.cpp + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <qdebug.h> +#include <qcoreapplication.h> +#include <qstringlist.h> + +#include "qdbusbus.h" +#include "qdbusconnection.h" +#include "qdbuserror.h" +#include "qdbusmessage.h" +#include "qdbusconnection_p.h" +#include "qdbusinterface_p.h" +#include "qdbusutil.h" + +class QDBusConnectionManager +{ +public: + QDBusConnectionManager() {} + ~QDBusConnectionManager(); + void bindToApplication(); + QDBusConnectionPrivate *connection(const QString &name) const; + void removeConnection(const QString &name); + void setConnection(const QString &name, QDBusConnectionPrivate *c); + +private: + mutable QMutex mutex; + QHash<QString, QDBusConnectionPrivate *> connectionHash; +}; + +Q_GLOBAL_STATIC(QDBusConnectionManager, manager) + +QDBusConnectionPrivate *QDBusConnectionManager::connection(const QString &name) const +{ + QMutexLocker locker(&mutex); + return connectionHash.value(name, 0); +} + +void QDBusConnectionManager::removeConnection(const QString &name) +{ + QMutexLocker locker(&mutex); + + QDBusConnectionPrivate *d = 0; + d = connectionHash.take(name); + if (d && !d->ref.deref()) + delete d; +} + +QDBusConnectionManager::~QDBusConnectionManager() +{ + for (QHash<QString, QDBusConnectionPrivate *>::const_iterator it = connectionHash.constBegin(); + it != connectionHash.constEnd(); ++it) { + delete it.value(); + } + connectionHash.clear(); +} + +void QDBusConnectionManager::bindToApplication() +{ + QMutexLocker locker(&mutex); + for (QHash<QString, QDBusConnectionPrivate *>::const_iterator it = connectionHash.constBegin(); + it != connectionHash.constEnd(); ++it) { + (*it)->bindToApplication(); + } +} + +QDBUS_EXPORT void qDBusBindToApplication(); +void qDBusBindToApplication() +{ + manager()->bindToApplication(); +} + +void QDBusConnectionManager::setConnection(const QString &name, QDBusConnectionPrivate *c) +{ + connectionHash[name] = c; + c->name = name; +} + +/*! + \fn QDBusConnection QDBus::sessionBus() + \relates QDBusConnection + + Returns a QDBusConnection object opened with the session bus. The object reference returned + by this function is valid until the QCoreApplication's destructor is run, when the + connection will be closed and the object, deleted. +*/ +/*! + \fn QDBusConnection QDBus::systemBus() + \relates QDBusConnection + + Returns a QDBusConnection object opened with the system bus. The object reference returned + by this function is valid until the QCoreApplication's destructor is run, when the + connection will be closed and the object, deleted. +*/ + +/*! + \class QDBusConnection + \brief A connection to the D-Bus bus daemon. + + This class is the initial point in a D-Bus session. Using it, you can get access to remote + objects, interfaces; connect remote signals to your object's slots; register objects, etc. + + D-Bus connections are created using the QDBusConnection::addConnection() function, which opens a + connection to the server daemon and does the initial handshaking, associating that connection + with a name. Further attempts to connect using the same name will return the same + connection. + + The connection is then torn down using the QDBusConnection::closeConnection() function. + + As a convenience for the two most common connection types, the QDBus::sessionBus() and + QDBus::systemBus() functions return open connections to the session server daemon and the system + server daemon, respectively. Those connections are opened when first used and are closed when + the QCoreApplication destructor is run. + + D-Bus also supports peer-to-peer connections, without the need for a bus server daemon. Using + this facility, two applications can talk to each other and exchange messages. This can be + achieved by passing an address to QDBusConnection::addConnection() + function, which was opened by another D-Bus application using QDBusServer. +*/ + +/*! + \enum QDBusConnection::BusType + Specifies the type of the bus connection. The valid bus types are: + + \value SessionBus the session bus, associated with the running desktop session + \value SystemBus the system bus, used to communicate with system-wide processes + \value ActivationBus the activation bus, whose purpose I have no idea... + + On the Session Bus, one can find other applications by the same user that are sharing the same + desktop session (hence the name). On the System Bus, however, processes shared for the whole + system are usually found. +*/ + +/*! + \enum QDBusConnection::WaitMode + Specifies the call waiting mode. + + \value UseEventLoop use the Qt Event Loop to wait for the reply + \value NoUseEventLoop don't use the event loop + + The \c UseEventLoop option allows for the application to continue to update its UI while the + call is performed, but it also opens up the possibility for reentrancy: socket notifiers may + fire, signals may be delivered and other D-Bus calls may be processed. The \c NoUseEventLoop + does not use the event loop, thus being safe from those problems, but it may block the + application for a noticeable period of time, in case the remote application fails to respond. + + Also note that calls that go back to the local application can only be placed in \c UseEventLoop + mode. +*/ + +/*! + \enum QDBusConnection::RegisterOption + Specifies the options for registering objects with the connection. The possible values are: + + \value ExportAdaptors export the contents of adaptors found in this object + + \value ExportSlots export this object's scriptable slots + \value ExportSignals export this object's scriptable signals + \value ExportProperties export this object's scriptable properties + \value ExportContents shorthand form for ExportSlots | ExportSignals | + ExportProperties + + \value ExportAllSlots export all of this object's slots, including + non-scriptable ones + \value ExportAllSignals export all of this object's signals, including + non-scriptable ones + \value ExportAllProperties export all of this object's properties, including + non-scriptable ones + \value ExportAllContents export all of this object's slots, signals and + properties, including non-scriptable ones + + \value ExportChildObjects export this object's child objects + + \warning It is currently not possible to export signals from objects. If you pass the flag + ExportSignals or ExportAllSignals, the registerObject() function will print a warning. + + \sa registerObject(), QDBusAbstractAdaptor, {usingadaptors.html}{Using adaptors} +*/ + +/*! + \enum QDBusConnection::UnregisterMode + The mode for unregistering an object path: + + \value UnregisterNode unregister this node only: do not unregister child objects + \value UnregisterTree unregister this node and all its sub-tree + + Note, however, if this object was registered with the ExportChildObjects option, UnregisterNode + will unregister the child objects too. +*/ + +/*! + Creates a QDBusConnection object attached to the connection with name \a name. + + This does not open the connection. You have to call QDBusConnection::addConnection to open it. +*/ +QDBusConnection::QDBusConnection(const QString &name) +{ + d = manager()->connection(name); + if (d) + d->ref.ref(); +} + +/*! + Creates a copy of the \a other connection. +*/ +QDBusConnection::QDBusConnection(const QDBusConnection &other) +{ + d = other.d; + if (d) + d->ref.ref(); +} + +/*! + Disposes of this object. This does not close the connection: you have to call + QDBusConnection::closeConnection to do that. +*/ +QDBusConnection::~QDBusConnection() +{ + if (d && !d->ref.deref()) + delete d; +} + +/*! + Creates a copy of the connection \a other in this object. The connection this object referenced + before the copy is not spontaneously disconnected. See QDBusConnection::closeConnection for more + information. +*/ +QDBusConnection &QDBusConnection::operator=(const QDBusConnection &other) +{ + if (other.d) + other.d->ref.ref(); + QDBusConnectionPrivate *old = static_cast<QDBusConnectionPrivate *>( + q_atomic_set_ptr(&d, other.d)); + if (old && !old->ref.deref()) + delete old; + + return *this; +} + +/*! + Opens a connection of type \a type to one of the known busses and associate with it the + connection name \a name. Returns a QDBusConnection object associated with that connection. +*/ +QDBusConnection QDBusConnection::addConnection(BusType type, const QString &name) +{ +// Q_ASSERT_X(QCoreApplication::instance(), "QDBusConnection::addConnection", +// "Cannot create connection without a Q[Core]Application instance"); + + QDBusConnectionPrivate *d = manager()->connection(name); + if (d || name.isEmpty()) + return QDBusConnection(name); + + d = new QDBusConnectionPrivate; + DBusConnection *c = 0; + switch (type) { + case SystemBus: + c = dbus_bus_get_private(DBUS_BUS_SYSTEM, &d->error); + break; + case SessionBus: + c = dbus_bus_get_private(DBUS_BUS_SESSION, &d->error); + break; + case ActivationBus: + c = dbus_bus_get_private(DBUS_BUS_STARTER, &d->error); + break; + } + d->setConnection(c); //setConnection does the error handling for us + + manager()->setConnection(name, d); + + QDBusConnection retval(name); + + // create the bus service + QDBusAbstractInterfacePrivate *p; + p = retval.findInterface_helper(QLatin1String(DBUS_SERVICE_DBUS), + QLatin1String(DBUS_PATH_DBUS), + QLatin1String(DBUS_INTERFACE_DBUS)); + if (p) { + d->busService = new QDBusBusService(p); + d->busService->setParent(d); // auto-deletion + d->ref.deref(); // busService has a increased the refcounting to us + } + + return retval; +} + +/*! + Opens a peer-to-peer connection on address \a address and associate with it the + connection name \a name. Returns a QDBusConnection object associated with that connection. +*/ +QDBusConnection QDBusConnection::addConnection(const QString &address, + const QString &name) +{ +// Q_ASSERT_X(QCoreApplication::instance(), "QDBusConnection::addConnection", +// "Cannot create connection without a Q[Core]Application instance"); + + QDBusConnectionPrivate *d = manager()->connection(name); + if (d || name.isEmpty()) + return QDBusConnection(name); + + d = new QDBusConnectionPrivate; + // setConnection does the error handling for us + d->setConnection(dbus_connection_open(address.toUtf8().constData(), &d->error)); + + manager()->setConnection(name, d); + + QDBusConnection retval(name); + + // create the bus service + QDBusAbstractInterfacePrivate *p; + p = retval.findInterface_helper(QLatin1String(DBUS_SERVICE_DBUS), + QLatin1String(DBUS_PATH_DBUS), + QLatin1String(DBUS_INTERFACE_DBUS)); + if (p) { + d->busService = new QDBusBusService(p); + d->busService->setParent(d); // auto-deletion + d->ref.deref(); // busService has a increased the refcounting to us + } + + return retval; +} + +/*! + Closes the connection of name \a name. + + Note that if there are still QDBusConnection objects associated with the same connection, the + connection will not be closed until all references are dropped. However, no further references + can be created using the QDBusConnection::QDBusConnection constructor. +*/ +void QDBusConnection::closeConnection(const QString &name) +{ + manager()->removeConnection(name); +} + +/*! + Sends the \a message over this connection, without waiting for a reply. This is suitable for + errors, signals, and return values as well as calls whose return values are not necessary. + + Returns true if the message was queued successfully, false otherwise. +*/ +bool QDBusConnection::send(const QDBusMessage &message) const +{ + if (!d || !d->connection) + return false; + return d->send(message) != 0; +} + +/*! + Sends the \a message over this connection and returns immediately after queueing it. When the + reply is received, the slot \a method is called in the object \a receiver. This function is + suitable for method calls only. + + This function guarantees that the slot will be called exactly once with the reply, as long as + the parameter types match. If they don't, the reply cannot be delivered. + + Returns the identification of the message that was sent or 0 if nothing was sent. +*/ +int QDBusConnection::sendWithReplyAsync(const QDBusMessage &message, QObject *receiver, + const char *method) const +{ + if (!d || !d->connection) + return 0; + + return d->sendWithReplyAsync(message, receiver, method); +} + +/*! + Sends the \a message over this connection and blocks, waiting for a reply. This function is + suitable for method calls only. It returns the reply message as its return value, which will be + either of type QDBusMessage::ReplyMessage or QDBusMessage::ErrorMessage. + + See the QDBusInterface::call function for a more friendly way of placing calls. + + \warning If \a mode is \c UseEventLoop, this function will reenter the Qt event loop in order to + wait for the reply. During the wait, it may deliver signals and other method calls to + your application. Therefore, it must be prepared to handle a reentrancy whenever a call + is placed with sendWithReply. +*/ +QDBusMessage QDBusConnection::sendWithReply(const QDBusMessage &message, WaitMode mode) const +{ + if (!d || !d->connection) + return QDBusMessage(); + return d->sendWithReply(message, mode); +} + +/*! + Connects the signal specified by the \a service, \a path, \a interface and \a name parameters to + the slot \a slot in object \a receiver. The arguments \a service and \a path can be empty, + denoting a connection to any signal of the \a interface - \a name pair, from any remote + application. + + Returns true if the connection was successful. + + \warning The signal will only be delivered to the slot if the parameters match. This verification + can be done only when the signal is received, not at connection time. +*/ +bool QDBusConnection::connect(const QString &service, const QString &path, const QString& interface, + const QString &name, QObject *receiver, const char *slot) +{ + return connect(service, path, interface, name, QString(), receiver, slot); +} + +/*! + \overload + Connects the signal to the slot \a slot in object \a receiver. Unlike the other + QDBusConnection::connect overload, this function allows one to specify the parameter signature + to be connected using the \a signature variable. The function will then verify that this + signature can be delivered to the slot specified by \a slot and return false otherwise. +*/ +bool QDBusConnection::connect(const QString &service, const QString &path, const QString& interface, + const QString &name, const QString &signature, + QObject *receiver, const char *slot) +{ + if (!receiver || !slot || !d || !d->connection || !QDBusUtil::isValidInterfaceName(interface)) + return false; + + QString source; + if (!service.isEmpty()) { + source = d->getNameOwner(service); + if (source.isEmpty()) + return false; + } + + // check the slot + QDBusConnectionPrivate::SignalHook hook; + QString key; + hook.signature = signature; + if (!d->prepareHook(hook, key, source, path, interface, name, receiver, slot, 0, false)) + return false; // don't connect + + // avoid duplicating: + QWriteLocker locker(&d->lock); + QDBusConnectionPrivate::SignalHookHash::ConstIterator it = d->signalHooks.find(key); + for ( ; it != d->signalHooks.end() && it.key() == key; ++it) { + const QDBusConnectionPrivate::SignalHook &entry = it.value(); + if (entry.sender == hook.sender && + entry.path == hook.path && + entry.signature == hook.signature && + entry.obj == hook.obj && + entry.midx == hook.midx) { + // no need to compare the parameters if it's the same slot + return true; // already there + } + } + + + d->connectSignal(key, hook); + return true; +} + +/*! + Registers the object \a object at path \a path and returns true if the registration was + successful. The \a options parameter specifies how much of the object \a object will be exposed + through D-Bus. + + This function does not replace existing objects: if there is already an object registered at + path \a path, this function will return false. Use unregisterObject() to unregister it first. + + You cannot register an object as a child object of an object that was registered with + QDBusConnection::ExportChildObjects. +*/ +bool QDBusConnection::registerObject(const QString &path, QObject *object, RegisterOptions options) +{ + if (!d || !d->connection || !object || !options || !QDBusUtil::isValidObjectPath(path)) + return false; + + if (options & ExportSignals) { + qWarning("Cannot export signals from objects. Use an adaptor for that purpose."); + return false; + } + + QStringList pathComponents = path.split(QLatin1Char('/')); + if (pathComponents.last().isEmpty()) + pathComponents.removeLast(); + QWriteLocker locker(&d->lock); + + // lower-bound search for where this object should enter in the tree + QDBusConnectionPrivate::ObjectTreeNode *node = &d->rootNode; + int i = 1; + while (node) { + if (pathComponents.count() == i) { + // this node exists + // consider it free if there's no object here and the user is not trying to + // replace the object sub-tree + if ((options & ExportChildObjects && !node->children.isEmpty()) || node->obj) + return false; + + // we can add the object here + node->obj = object; + node->flags = options; + + d->registerObject(node); + qDebug("REGISTERED FOR %s", path.toLocal8Bit().constData()); + return true; + } + + // find the position where we'd insert the node + QVector<QDBusConnectionPrivate::ObjectTreeNode::Data>::Iterator it = + qLowerBound(node->children.begin(), node->children.end(), pathComponents.at(i)); + if (it != node->children.constEnd() && it->name == pathComponents.at(i)) { + // match: this node exists + node = it->node; + + // are we allowed to go deeper? + if (node->flags & ExportChildObjects) { + // we're not + qDebug("Cannot register object at %s because %s exports its own child objects", + qPrintable(path), qPrintable(pathComponents.at(i))); + return false; + } + } else { + // add entry + QDBusConnectionPrivate::ObjectTreeNode::Data entry; + entry.name = pathComponents.at(i); + entry.node = new QDBusConnectionPrivate::ObjectTreeNode; + node->children.insert(it, entry); + + node = entry.node; + } + + // iterate + ++i; + } + + Q_ASSERT_X(false, "QDBusConnection::registerObject", "The impossible happened"); + return false; +} + +/*! + Unregisters an object that was registered with the registerObject() at the object path given by + \a path and, if \a mode is QDBusConnection::UnregisterTree, all of its sub-objects too. + + Note that you cannot unregister objects that were not registered with registerObject(). +*/ +void QDBusConnection::unregisterObject(const QString &path, UnregisterMode mode) +{ + if (!d || !d->connection || !QDBusUtil::isValidObjectPath(path)) + return; + + QStringList pathComponents = path.split(QLatin1Char('/')); + QWriteLocker locker(&d->lock); + QDBusConnectionPrivate::ObjectTreeNode *node = &d->rootNode; + int i = 1; + + // find the object + while (node) { + if (pathComponents.count() == i) { + // found it + node->obj = 0; + node->flags = 0; + + if (mode == UnregisterTree) { + // clear the sub-tree as well + node->clear(); // can't disconnect the objects because we really don't know if they can + // be found somewhere else in the path too + } + + return; + } + + QVector<QDBusConnectionPrivate::ObjectTreeNode::Data>::ConstIterator it = + qLowerBound(node->children.constBegin(), node->children.constEnd(), pathComponents.at(i)); + if (it == node->children.constEnd() || it->name != pathComponents.at(i)) + break; // node not found + + node = it->node; + ++i; + } +} + +/*! + Returns a dynamic QDBusInterface associated with the interface \a interface on object at path \a + path on service \a service. + + This function creates a new object. It is your resposibility to ensure it is properly deleted + (you can use all normal QObject deletion mechanisms, including the QObject::deleteLater() slot + and QObject::setParent()). + + If the searching for this interface on the remote object failed, this function returns 0. +*/ +QDBusInterface *QDBusConnection::findInterface(const QString& service, const QString& path, + const QString& interface) +{ + if (!d) + return 0; + + QDBusInterfacePrivate *p = d->findInterface(service, path, interface); + QDBusInterface *retval = new QDBusInterface(p); + retval->setParent(d); + return retval; +} + +/*! + \fn QDBusConnection::findInterface(const QString &service, const QString &path) + Returns an interface of type \c Interface associated with the object on path \a path at service + \a service. + + \c Interface must be a class generated by \l {dbusidl2cpp.html}. + + This function creates a new object. It is your resposibility to ensure it is properly deleted + (you can use all normal QObject deletion mechanisms, including the QObject::deleteLater() slot + and QObject::setParent()). +*/ + +/*! + Returns a QDBusBusService object that represents the D-Bus bus service on this connection. + + This function returns 0 for peer-to-peer connections. +*/ +QDBusBusService *QDBusConnection::busService() const +{ + if (!d) + return 0; + return d->busService; +} + +QDBusAbstractInterfacePrivate * +QDBusConnection::findInterface_helper(const QString &service, const QString &path, + const QString &interface) +{ + if (!d) + return 0; + if (!interface.isEmpty() && !QDBusUtil::isValidInterfaceName(interface)) + return 0; + + QString owner; + if (!service.isEmpty()) { + if (!QDBusUtil::isValidObjectPath(path)) + return 0; + + // check if it's there first -- FIXME: add binding mode + owner = d->getNameOwner(service); + if (owner.isEmpty()) + return 0; + } else if (!path.isEmpty()) + return 0; + + return new QDBusAbstractInterfacePrivate(*this, d, owner, path, interface); +} + +/*! + Returns true if this QDBusConnection object is connected. + + If it isn't connected, calling QDBusConnection::addConnection on the same connection name + will not make be connected. You need to call the QDBusConnection constructor again. +*/ +bool QDBusConnection::isConnected( ) const +{ + return d && d->connection && dbus_connection_get_is_connected(d->connection); +} + +/*! + Returns the last error that happened in this connection. + + This function is provided for low-level code. If you're using QDBusInterface::call, error codes are + reported by its return value. + + \sa QDBusInterface, QDBusMessage +*/ +QDBusError QDBusConnection::lastError() const +{ + return d ? d->lastError : QDBusError(); +} + +/*! + Returns the unique connection name for this connection, if this QDBusConnection object is + connected, or an empty QString otherwise. + + A Unique Connection Name is a string in the form ":x.xxx" (where x are decimal digits) that is + assigned by the D-Bus server daemon upon connection. It uniquely identifies this client in the + bus. + + This function returns an empty QString for peer-to-peer connections. +*/ +QString QDBusConnection::baseService() const +{ + return d && d->connection ? + QString::fromUtf8(dbus_bus_get_unique_name(d->connection)) + : QString(); +} + +Q_GLOBAL_STATIC(QMutex, defaultBussesMutex) +static const char sessionBusName[] = "qt_default_session_bus"; +static const char systemBusName[] = "qt_default_system_bus"; +static QDBusConnection *sessionBus = 0; +static QDBusConnection *systemBus = 0; + +static void closeConnections() +{ + QMutexLocker locker(defaultBussesMutex()); + delete sessionBus; + delete systemBus; + QDBusConnection::closeConnection(QLatin1String(sessionBusName)); + QDBusConnection::closeConnection(QLatin1String(systemBusName)); + sessionBus = systemBus = 0; +} + +static QDBusConnection *openConnection(QDBusConnection::BusType type) +{ + QMutexLocker locker(defaultBussesMutex()); + qAddPostRoutine(closeConnections); + + if (type == QDBusConnection::SystemBus) { + if (systemBus) + // maybe it got created before we locked the mutex + return systemBus; + systemBus = new QDBusConnection(QDBusConnection::addConnection(QDBusConnection::SystemBus, + QLatin1String(systemBusName))); + return systemBus; + } else { + if (sessionBus) + // maybe it got created before we locked the mutex + return sessionBus; + sessionBus = new QDBusConnection(QDBusConnection::addConnection(QDBusConnection::SessionBus, + QLatin1String(sessionBusName))); + return sessionBus; + } +} + +namespace QDBus { + QDBusConnection &sessionBus() + { + if (::sessionBus) return *::sessionBus; + return *openConnection(QDBusConnection::SessionBus); + } + + QDBusConnection &systemBus() + { + if (::systemBus) return *::systemBus; + return *openConnection(QDBusConnection::SystemBus); + } +} + diff --git a/qt/src/qdbusconnection.h b/qt/src/qdbusconnection.h new file mode 100644 index 00000000..c1c420a6 --- /dev/null +++ b/qt/src/qdbusconnection.h @@ -0,0 +1,124 @@ +/* qdbusconnection.h QDBusConnection object + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSCONNECTION_H +#define QDBUSCONNECTION_H + +#include "qdbusmacros.h" +#include <QtCore/qstring.h> + +class QDBusAbstractInterfacePrivate; +class QDBusInterface; +class QDBusError; +class QDBusMessage; +class QDBusBusService; +class QObject; + +class QDBusConnectionPrivate; +class QDBUS_EXPORT QDBusConnection +{ +public: + enum BusType { SessionBus, SystemBus, ActivationBus }; + enum WaitMode { UseEventLoop, NoUseEventLoop }; + enum RegisterOption { + ExportAdaptors = 0x01, + + ExportSlots = 0x10, + ExportSignals = 0x20, + ExportProperties = 0x40, + ExportContents = 0xf0, + + ExportAllSlots = 0x110, + ExportAllSignals = 0x220, + ExportAllProperties = 0x440, + ExportAllContents = 0xff0, + + ExportChildObjects = 0x1000 + }; + enum UnregisterMode { + UnregisterNode, + UnregisterTree + }; + + Q_DECLARE_FLAGS(RegisterOptions, RegisterOption) + + QDBusConnection(const QString &name); + QDBusConnection(const QDBusConnection &other); + ~QDBusConnection(); + + QDBusConnection &operator=(const QDBusConnection &other); + + bool isConnected() const; + QString baseService() const; + QDBusError lastError() const; + + bool send(const QDBusMessage &message) const; + QDBusMessage sendWithReply(const QDBusMessage &message, WaitMode mode = NoUseEventLoop) const; + int sendWithReplyAsync(const QDBusMessage &message, QObject *receiver, + const char *slot) const; + + bool connect(const QString &service, const QString &path, const QString &interface, + const QString &name, QObject *receiver, const char *slot); + bool connect(const QString &service, const QString &path, const QString &interface, + const QString &name, const QString& signature, + QObject *receiver, const char *slot); + + bool registerObject(const QString &path, QObject *object, + RegisterOptions options = ExportAdaptors); + void unregisterObject(const QString &path, UnregisterMode mode = UnregisterNode); + + template<class Interface> + inline Interface *findInterface(const QString &service, const QString &path); + QDBusInterface *findInterface(const QString& service, const QString& path, + const QString& interface = QString()); + + QDBusBusService *busService() const; + + static QDBusConnection addConnection(BusType type, const QString &name); + static QDBusConnection addConnection(const QString &address, const QString &name); + static void closeConnection(const QString &name); + +private: + QDBusAbstractInterfacePrivate *findInterface_helper(const QString &, const QString &, + const QString&); + QDBusConnectionPrivate *d; +}; + +template<class Interface> +inline Interface *QDBusConnection::findInterface(const QString &service, const QString &path) +{ + register QDBusAbstractInterfacePrivate *d; + d = findInterface_helper(service, path, Interface::staticInterfaceName()); + if (d) + return new Interface(d); + return 0; +} + +namespace QDBus { + QDBUS_EXPORT QDBusConnection &sessionBus(); + QDBUS_EXPORT QDBusConnection &systemBus(); +} + +Q_DECLARE_OPERATORS_FOR_FLAGS(QDBusConnection::RegisterOptions) +#endif diff --git a/qt/src/qdbusconnection_p.h b/qt/src/qdbusconnection_p.h new file mode 100644 index 00000000..bab0b65d --- /dev/null +++ b/qt/src/qdbusconnection_p.h @@ -0,0 +1,245 @@ +/* qdbusconnection_p.h QDBusConnection private object + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the public API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef QDBUSCONNECTION_P_H +#define QDBUSCONNECTION_P_H + +#include "qdbuserror.h" + +#include <QtCore/qatomic.h> +#include <QtCore/qeventloop.h> +#include <QtCore/qhash.h> +#include <QtCore/qmutex.h> +#include <QtCore/qobject.h> +#include <QtCore/qpointer.h> +#include <QtCore/qreadwritelock.h> +#include <QtCore/qvarlengtharray.h> +#include <QtCore/qvector.h> + +#include <dbus/dbus.h> + +#include "qdbusmessage.h" + +class QDBusMessage; +class QSocketNotifier; +class QTimerEvent; +class QDBusObjectPrivate; +class CallDeliveryEvent; +class QMetaMethod; +class QDBusInterfacePrivate; +struct QDBusMetaObject; +class QDBusAbstractInterface; +class QDBusBusService; + +class QDBusConnectionPrivate: public QObject +{ + Q_OBJECT +public: + // structs and enums + enum ConnectionMode { InvalidMode, ServerMode, ClientMode }; + + struct Watcher + { + Watcher(): watch(0), read(0), write(0) {} + DBusWatch *watch; + QSocketNotifier *read; + QSocketNotifier *write; + }; + + struct SignalHook + { + inline SignalHook() : obj(0), midx(-1) { } + QString sender, path, signature; + QObject* obj; + int midx; + QList<int> params; + }; + + struct ObjectTreeNode + { + struct Data + { + QString name; + ObjectTreeNode *node; + + inline bool operator<(const QString &other) const + { return name < other; } + }; + + inline ObjectTreeNode() : obj(0), flags(0) { } + inline ~ObjectTreeNode() { clear(); } + inline void clear() + { + foreach (const Data &entry, children) { + entry.node->clear(); + delete entry.node; + } + children.clear(); + } + + QObject* obj; + int flags; + QVector<Data> children; + }; + +public: + // typedefs + typedef QMultiHash<int, Watcher> WatcherHash; + typedef QHash<int, DBusTimeout *> TimeoutHash; + typedef QMultiHash<QString, SignalHook> SignalHookHash; + typedef QHash<QString, QDBusMetaObject* > MetaObjectHash; + +public: + // public methods + QDBusConnectionPrivate(QObject *parent = 0); + ~QDBusConnectionPrivate(); + + void bindToApplication(); + + void setConnection(DBusConnection *connection); + void setServer(DBusServer *server); + void closeConnection(); + void timerEvent(QTimerEvent *e); + + QString getNameOwner(const QString &service); + + int send(const QDBusMessage &message) const; + QDBusMessage sendWithReply(const QDBusMessage &message, int mode); + int sendWithReplyAsync(const QDBusMessage &message, QObject *receiver, + const char *method); + void connectSignal(const QString &key, const SignalHook &hook); + void registerObject(const ObjectTreeNode *node); + void connectRelay(const QString &service, const QString &path, const QString &interface, + QDBusAbstractInterface *receiver, const char *signal); + void disconnectRelay(const QString &service, const QString &path, const QString &interface, + QDBusAbstractInterface *receiver, const char *signal); + + bool handleSignal(const QString &key, const QDBusMessage &msg); + bool handleSignal(const QDBusMessage &msg); + bool handleObjectCall(const QDBusMessage &message); + bool handleError(); + + bool activateSignal(const SignalHook& hook, const QDBusMessage &msg); + bool activateCall(QObject* object, int flags, const QDBusMessage &msg); + bool activateObject(const ObjectTreeNode *node, const QDBusMessage &msg); + bool activateInternalFilters(const ObjectTreeNode *node, const QDBusMessage &msg); + + void postCallDeliveryEvent(CallDeliveryEvent *data); + CallDeliveryEvent *postedCallDeliveryEvent(); + void deliverCall(const CallDeliveryEvent &data) const; + + QDBusInterfacePrivate *findInterface(const QString &service, const QString &path, + const QString &interface); + +protected: + virtual void customEvent(QEvent *event); + +private: + QDBusMetaObject *findMetaObject(const QString &service, const QString &path, + const QString &interface); + +public slots: + // public slots + void doDispatch(); + void socketRead(int); + void socketWrite(int); + void objectDestroyed(QObject *o); + void relaySignal(QObject *obj, const char *interface, const char *name, const QVariantList &args); + +public: + // public member variables + QString name; // this connection's name + + DBusError error; + QDBusError lastError; + + QAtomic ref; + QReadWriteLock lock; + ConnectionMode mode; + DBusConnection *connection; + DBusServer *server; + QDBusBusService *busService; + + WatcherHash watchers; + TimeoutHash timeouts; + SignalHookHash signalHooks; + QList<DBusTimeout *> pendingTimeouts; + + ObjectTreeNode rootNode; + MetaObjectHash cachedMetaObjects; + + QMutex callDeliveryMutex; + CallDeliveryEvent *callDeliveryState; // protected by the callDeliveryMutex mutex + +public: + // static methods + static int messageMetaType; + static int registerMessageMetaType(); + static int findSlot(QObject *obj, const QByteArray &normalizedName, QList<int>& params); + static bool prepareHook(QDBusConnectionPrivate::SignalHook &hook, QString &key, + const QString &service, const QString &path, + const QString &interface, const QString &name, + QObject *receiver, const char *signal, int minMIdx, + bool buildSignature); + static DBusHandlerResult messageFilter(DBusConnection *, DBusMessage *, void *); + static void messageResultReceived(DBusPendingCall *, void *); +}; + +class QDBusReplyWaiter: public QEventLoop +{ + Q_OBJECT +public: + QDBusMessage replyMsg; + +public slots: + void reply(const QDBusMessage &msg); +}; + +// in qdbusmisc.cpp +extern int qDBusParametersForMethod(const QMetaMethod &mm, QList<int>& metaTypes); +extern int qDBusNameToTypeId(const char *name); +extern bool qDBusCheckAsyncTag(const char *tag); + +// in qdbusinternalfilters.cpp +extern QString qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode *node); +extern void qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode *node, + const QDBusMessage &msg); +extern void qDBusPropertyGet(const QDBusConnectionPrivate::ObjectTreeNode *node, + const QDBusMessage &msg); +extern void qDBusPropertySet(const QDBusConnectionPrivate::ObjectTreeNode *node, + const QDBusMessage &msg); + +#endif diff --git a/qt/src/qdbuserror.cpp b/qt/src/qdbuserror.cpp new file mode 100644 index 00000000..d5cd6758 --- /dev/null +++ b/qt/src/qdbuserror.cpp @@ -0,0 +1,244 @@ +/* qdbuserror.h QDBusError object + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbuserror.h" + +#include <qdebug.h> +#include <qvarlengtharray.h> + +#include <dbus/dbus.h> +#include "qdbusmessage.h" + +struct ErrorMessageMapping +{ + ErrorMessageMapping(); + QVarLengthArray<const char*, QDBusError::qKnownErrorsMax> messages; + + inline const char *get(QDBusError::KnownErrors code) const + { + if (code <= QDBusError::Other || code > QDBusError::qKnownErrorsMax) + return messages[int(QDBusError::Other) - 1]; + return messages[int(code) - 1]; + } + + inline QDBusError::KnownErrors get(const char *name) const + { + if (!name || !*name) + return QDBusError::NoError; + for (int i = QDBusError::Other; i <= QDBusError::qKnownErrorsMax; ++i) + if (strcmp(name, messages[i - 1]) == 0) + return QDBusError::KnownErrors(i); + return QDBusError::Other; + } +}; + +static const char errorMessages_string[] = + // in the same order as KnownErrors! + "other\0" // Other -- shouldn't happen + DBUS_ERROR_FAILED "\0" // Failed + DBUS_ERROR_NO_MEMORY "\0" // NoMemory + DBUS_ERROR_SERVICE_UNKNOWN "\0" // ServiceUnknown + DBUS_ERROR_NO_REPLY "\0" // NoReply + DBUS_ERROR_BAD_ADDRESS "\0" // BadAddress + DBUS_ERROR_NOT_SUPPORTED "\0" // NotSupported + DBUS_ERROR_LIMITS_EXCEEDED "\0" // LimitsExceeded + DBUS_ERROR_ACCESS_DENIED "\0" // AccessDenied + DBUS_ERROR_NO_SERVER "\0" // NoServer + DBUS_ERROR_TIMEOUT "\0" // Timeout + DBUS_ERROR_NO_NETWORK "\0" // NoNetwork + DBUS_ERROR_ADDRESS_IN_USE "\0" // AddressInUse + DBUS_ERROR_DISCONNECTED "\0" // Disconnected + DBUS_ERROR_INVALID_ARGS "\0" // InvalidArgs + DBUS_ERROR_UNKNOWN_METHOD "\0" // UnknownMethod + DBUS_ERROR_TIMED_OUT "\0" // TimedOut + DBUS_ERROR_INVALID_SIGNATURE "\0" // InvalidSignature + "com.trolltech.QtDBus.Error.UnknownInterface\0" // UnknownInterface + "com.trolltech.QtDBus.Error.InternalError\0" // InternalError + "\0"; + +ErrorMessageMapping::ErrorMessageMapping() + : messages(int(QDBusError::qKnownErrorsMax)) +{ + // create the list: + const char *p = errorMessages_string; + int i = 0; + while (*p) { + messages[i] = p; + p += strlen(p) + 1; + ++i; + } +} + +Q_GLOBAL_STATIC(ErrorMessageMapping, errorMessages) + +/*! + \class QDBusError + \brief Represents an error received from the D-Bus bus or from remote applications found in the bus. + + When dealing with the D-Bus bus service or with remote applications over D-Bus, a number of + error conditions can happen. This error conditions are sometimes signalled by a returned error + value or by a QDBusError. + + C++ and Java exceptions are a valid analogy for D-Bus errors: instead of returning normally with + a return value, remote applications and the bus may decide to throw an error condition. However, + the QtDBus implementation does not use the C++ exception-throwing mechanism, so you will receive + QDBusErrors in the return reply (see QDBusReply::error()). + + QDBusError objects are used to inspect the error name and message as received from the bus and + remote applications. You should not create such objects yourself to signal error conditions when + called from D-Bus: instead, use QDBusMessage::error and QDBusConnection::send. + + \sa QDBusConnection::send(), QDBusMessage, QDBusReply +*/ + +/*! + \enum QDBusError::KnownErrors + + In order to facilitate verification of the most common D-Bus errors generated by the D-Bus + implementation and by the bus daemon itself, QDBusError can be compared to a set of pre-defined + values: + + \value NoError QDBusError is invalid (i.e., the call succeeded) + \value Other QDBusError contains an error that is one of the well-known ones + \value Failed The call failed (\c org.freedesktop.DBus.Error.Failed) + \value NoMemory Out of memory (\c org.freedesktop.DBus.Error.NoMemory) + \value ServiceUnknown The called service is not known + (\c org.freedesktop.DBus.Error.ServiceUnknown) + \value NoReply The called method did not reply within the specified timeout + (\c org.freedesktop.DBus.Error.NoReply) + \value BadAddress The address given is not valid + (\c org.freedesktop.DBus.Error.BadAddress) + \value NotSupported The call/operation is not supported + (\c org.freedesktop.DBus.Error.NotSupported) + \value LimitsExceeded The limits allocated to this process/call/connection exceeded the + pre-defined values (\c org.freedesktop.DBus.Error.LimitsExceeded) + \value AccessDenied The call/operation tried to access a resource it isn't allowed to + (\c org.freedesktop.DBus.Error.AccessDenied) + \value NoServer \i{Documentation doesn't say what this is for} + (\c org.freedesktop.DBus.Error.NoServer) + \value Timeout \i{Documentation doesn't say what this is for or how it's used} + (\c org.freedesktop.DBus.Error.Timeout) + \value NoNetwork \i{Documentation doesn't say what this is for} + (\c org.freedesktop.DBus.Error.NoNetwork) + \value AddressInUse QDBusServer tried to bind to an address that is already in use + (\c org.freedesktop.DBus.Error.AddressInUse) + \value Disconnected The call/process/message was sent after QDBusConnection disconnected + (\c org.freedesktop.DBus.Error.Disconnected) + \value InvalidArgs The arguments passed to this call/operation are not valid + (\c org.freedesktop.DBus.Error.InvalidArgs) + \value UnknownMethod The method called was not found in this object/interface with the + given parameters (\c org.freedesktop.DBus.Error.UnknownMethod) + \value TimedOut \i{Documentation doesn't say...} + (\c org.freedesktop.DBus.Error.TimedOut) + \value InvalidSignature The type signature is not valid or compatible + (\c org.freedesktop.DBus.Error.InvalidSignature) + \value UnknownInterface The interface is not known + \value InternalError An internal error occurred + (\c com.trolltech.QtDBus.Error.InternalError) + +*/ + +/*! + \internal + Constructs a QDBusError from a DBusError structure. +*/ +QDBusError::QDBusError(const DBusError *error) + : code(NoError) +{ + if (!error || !dbus_error_is_set(error)) + return; + + code = errorMessages()->get(error->name); + nm = QString::fromUtf8(error->name); + msg = QString::fromUtf8(error->message); +} + +/*! + \internal + Constructs a QDBusError from a QDBusMessage. +*/ +QDBusError::QDBusError(const QDBusMessage &qdmsg) + : code(Other) +{ + if (qdmsg.type() != QDBusMessage::ErrorMessage) + return; + + nm = qdmsg.name(); + if (qdmsg.count()) + msg = qdmsg[0].toString(); + code = errorMessages()->get(nm.toUtf8().constData()); +} + +/*! + \internal + Constructs a QDBusError from a well-known error code +*/ +QDBusError::QDBusError(KnownErrors error, const QString &message) + : code(error) +{ + nm = errorMessages()->get(error); + msg = message; +} + +/*! + \fn QDBusError::name() const + Returns this error's name. Error names are similar to D-Bus Interface names, like + "org.freedesktop.DBus.InvalidArgs". +*/ + +/*! + \fn QDBusError::message() const + Returns the message that the callee associated with this error. Error messages are + implementation defined and usually contain a human-readable error code, though this does not + mean it is suitable for your end-users. +*/ + +/*! + \fn QDBusError::isValid() const + Returns true if this is a valid error condition (i.e., if there was an error), false otherwise. +*/ + +/*! + \fn QDBusError::operator==(KnownErrors error) const + Compares this QDBusError against the well-known error code \a error and returns true if they + match. +*/ + +/*! + \fn operator==(QDBusError::KnownErrors p1, const QDBusError &p2) + \relates QDBusError + + Compares the QDBusError \a p2 against the well-known error code \a p1 and returns true if they + match. +*/ + +#ifndef QT_NO_DEBUG +QDebug operator<<(QDebug dbg, const QDBusError &msg) +{ + dbg.nospace() << "QDBusError(" << msg.name() << ", " << msg.message() << ")"; + return dbg.space(); +} +#endif + + diff --git a/qt/src/qdbuserror.h b/qt/src/qdbuserror.h new file mode 100644 index 00000000..71c636df --- /dev/null +++ b/qt/src/qdbuserror.h @@ -0,0 +1,93 @@ +/* qdbuserror.h QDBusError object + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSERROR_H +#define QDBUSERROR_H + +#include "qdbusmacros.h" +#include <QtCore/qstring.h> + +struct DBusError; +class QDBusMessage; + +class QDBUS_EXPORT QDBusError +{ +public: + enum KnownErrors { + NoError = 0, + Other = 1, + Failed, + NoMemory, + ServiceUnknown, + NoReply, + BadAddress, + NotSupported, + LimitsExceeded, + AccessDenied, + NoServer, + Timeout, + NoNetwork, + AddressInUse, + Disconnected, + InvalidArgs, + UnknownMethod, + TimedOut, + InvalidSignature, + UnknownInterface, + InternalError, + +#ifndef Q_QDOC + // don't use this one! + qKnownErrorsMax = InternalError +#endif + }; + + QDBusError(const DBusError *error = 0); + QDBusError(const QDBusMessage& msg); + QDBusError(KnownErrors error, const QString &message); + + inline QString name() const { return nm; } + inline QString message() const { return msg; } + inline bool isValid() const { return !nm.isNull() && !msg.isNull(); } + + inline bool operator==(KnownErrors error) const + { return code == error; } + +private: + KnownErrors code; + QString nm, msg; +}; + +inline bool operator==(QDBusError::KnownErrors p1, const QDBusError &p2) +{ return p2 == p1; } +inline bool operator!=(QDBusError::KnownErrors p1, const QDBusError &p2) +{ return !(p2 == p1); } +inline bool operator!=(const QDBusError &p1, QDBusError::KnownErrors p2) +{ return !(p1 == p2); } + +#ifndef QT_NO_DEBUG +QDebug operator<<(QDebug, const QDBusError &); +#endif + +#endif diff --git a/qt/src/qdbusintegrator.cpp b/qt/src/qdbusintegrator.cpp new file mode 100644 index 00000000..07921cf9 --- /dev/null +++ b/qt/src/qdbusintegrator.cpp @@ -0,0 +1,1552 @@ +/* qdbusintegrator.cpp QDBusConnection private implementation + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <qcoreapplication.h> +#include <qcoreevent.h> +#include <qdebug.h> +#include <qmetaobject.h> +#include <qobject.h> +#include <qsocketnotifier.h> +#include <qstringlist.h> +#include <qtimer.h> + +#include "qdbusconnection_p.h" +#include "qdbusinterface_p.h" +#include "qdbusmessage.h" +#include "qdbusabstractadaptor.h" +#include "qdbusabstractadaptor_p.h" +#include "qdbustypehelper_p.h" +#include "qdbusutil.h" +#include "qdbustype_p.h" + +#ifndef USE_OUTSIDE_DISPATCH +# define USE_OUTSIDE_DISPATCH 0 +#endif + +int QDBusConnectionPrivate::messageMetaType = 0; + +typedef void (*QDBusSpyHook)(const QDBusMessage&); +typedef QVarLengthArray<QDBusSpyHook, 4> QDBusSpyHookList; +Q_GLOBAL_STATIC(QDBusSpyHookList, qDBusSpyHookList) + +struct QDBusPendingCall +{ + QPointer<QObject> receiver; + QList<int> metaTypes; + int methodIdx; + DBusPendingCall *pending; + const QDBusConnectionPrivate *connection; +}; + +class CallDeliveryEvent: public QEvent +{ +public: + CallDeliveryEvent() + : QEvent(QEvent::User), object(0), flags(0), slotIdx(-1) + { } + + const QDBusConnectionPrivate *conn; + QPointer<QObject> object; + QDBusMessage message; + QList<int> metaTypes; + + int flags; + int slotIdx; +}; + +static dbus_bool_t qDBusAddTimeout(DBusTimeout *timeout, void *data) +{ + Q_ASSERT(timeout); + Q_ASSERT(data); + + // qDebug("addTimeout %d", dbus_timeout_get_interval(timeout)); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + + if (!dbus_timeout_get_enabled(timeout)) + return true; + + if (!QCoreApplication::instance()) { + d->pendingTimeouts.append(timeout); + return true; + } + int timerId = d->startTimer(dbus_timeout_get_interval(timeout)); + if (!timerId) + return false; + + d->timeouts[timerId] = timeout; + return true; +} + +static void qDBusRemoveTimeout(DBusTimeout *timeout, void *data) +{ + Q_ASSERT(timeout); + Q_ASSERT(data); + + // qDebug("removeTimeout"); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + d->pendingTimeouts.removeAll(timeout); + + QDBusConnectionPrivate::TimeoutHash::iterator it = d->timeouts.begin(); + while (it != d->timeouts.end()) { + if (it.value() == timeout) { + d->killTimer(it.key()); + it = d->timeouts.erase(it); + } else { + ++it; + } + } +} + +static void qDBusToggleTimeout(DBusTimeout *timeout, void *data) +{ + Q_ASSERT(timeout); + Q_ASSERT(data); + + //qDebug("ToggleTimeout"); + + qDBusRemoveTimeout(timeout, data); + qDBusAddTimeout(timeout, data); +} + +static dbus_bool_t qDBusAddWatch(DBusWatch *watch, void *data) +{ + Q_ASSERT(watch); + Q_ASSERT(data); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + + int flags = dbus_watch_get_flags(watch); + int fd = dbus_watch_get_fd(watch); + + QDBusConnectionPrivate::Watcher watcher; + if (flags & DBUS_WATCH_READABLE) { + //qDebug("addReadWatch %d", fd); + watcher.watch = watch; + if (QCoreApplication::instance()) { + watcher.read = new QSocketNotifier(fd, QSocketNotifier::Read, d); + watcher.read->setEnabled(dbus_watch_get_enabled(watch)); + d->connect(watcher.read, SIGNAL(activated(int)), SLOT(socketRead(int))); + } + } + if (flags & DBUS_WATCH_WRITABLE) { + //qDebug("addWriteWatch %d", fd); + watcher.watch = watch; + if (QCoreApplication::instance()) { + watcher.write = new QSocketNotifier(fd, QSocketNotifier::Write, d); + watcher.write->setEnabled(dbus_watch_get_enabled(watch)); + d->connect(watcher.write, SIGNAL(activated(int)), SLOT(socketWrite(int))); + } + } + d->watchers.insertMulti(fd, watcher); + + return true; +} + +static void qDBusRemoveWatch(DBusWatch *watch, void *data) +{ + Q_ASSERT(watch); + Q_ASSERT(data); + + //qDebug("remove watch"); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + int fd = dbus_watch_get_fd(watch); + + QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd); + while (i != d->watchers.end() && i.key() == fd) { + if (i.value().watch == watch) { + delete i.value().read; + delete i.value().write; + d->watchers.erase(i); + return; + } + ++i; + } +} + +static void qDBusToggleWatch(DBusWatch *watch, void *data) +{ + Q_ASSERT(watch); + Q_ASSERT(data); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + int fd = dbus_watch_get_fd(watch); + + QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd); + while (i != d->watchers.end() && i.key() == fd) { + if (i.value().watch == watch) { + bool enabled = dbus_watch_get_enabled(watch); + int flags = dbus_watch_get_flags(watch); + + //qDebug("toggle watch %d to %d (write: %d, read: %d)", dbus_watch_get_fd(watch), enabled, flags & DBUS_WATCH_WRITABLE, flags & DBUS_WATCH_READABLE); + + if (flags & DBUS_WATCH_READABLE && i.value().read) + i.value().read->setEnabled(enabled); + if (flags & DBUS_WATCH_WRITABLE && i.value().write) + i.value().write->setEnabled(enabled); + return; + } + ++i; + } +} + +static void qDBusNewConnection(DBusServer *server, DBusConnection *c, void *data) +{ + Q_ASSERT(data); Q_ASSERT(server); Q_ASSERT(c); + Q_UNUSED(data); Q_UNUSED(server); Q_UNUSED(c); + + qDebug("SERVER: GOT A NEW CONNECTION"); // TODO +} + +extern QDBUS_EXPORT void qDBusAddSpyHook(QDBusSpyHook); +void qDBusAddSpyHook(QDBusSpyHook hook) +{ + qDBusSpyHookList()->append(hook); +} + +#if USE_OUTSIDE_DISPATCH +# define HANDLED DBUS_HANDLER_RESULT_HANDLED_OUTSIDE_DISPATCH +static DBusHandlerResult qDBusSignalFilterOutside(DBusConnection *connection, + DBusMessage *message, void *data) +{ + Q_ASSERT(data); + Q_UNUSED(connection); + Q_UNUSED(message); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + if (d->mode == QDBusConnectionPrivate::InvalidMode) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; // internal error, actually + + CallDeliveryEvent *e = d->postedCallDeliveryEvent(); + + d->deliverCall(*e); + delete e; + + return DBUS_HANDLER_RESULT_HANDLED; +} +#else +# define HANDLED DBUS_HANDLER_RESULT_HANDLED +#endif + +extern "C" { +static DBusHandlerResult +qDBusSignalFilter(DBusConnection *connection, DBusMessage *message, void *data) +{ + return QDBusConnectionPrivate::messageFilter(connection, message, data); +} +} + +DBusHandlerResult QDBusConnectionPrivate::messageFilter(DBusConnection *connection, + DBusMessage *message, void *data) +{ + Q_ASSERT(data); + Q_UNUSED(connection); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + if (d->mode == QDBusConnectionPrivate::InvalidMode) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + QDBusMessage amsg = QDBusMessage::fromDBusMessage(message, QDBusConnection(d->name)); + qDebug() << "got message:" << amsg; + + const QDBusSpyHookList *list = qDBusSpyHookList(); + for (int i = 0; i < list->size(); ++i) { + qDebug() << "calling the message spy hook"; + (*(*list)[i])(amsg); + } + + bool handled = false; + int msgType = dbus_message_get_type(message); + if (msgType == DBUS_MESSAGE_TYPE_SIGNAL) { + handled = d->handleSignal(amsg); + } else if (msgType == DBUS_MESSAGE_TYPE_METHOD_CALL) { + handled = d->handleObjectCall(amsg); + } + + return handled ? HANDLED : + DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +static void huntAndDestroy(QObject *needle, QDBusConnectionPrivate::ObjectTreeNode *haystack) +{ + foreach (const QDBusConnectionPrivate::ObjectTreeNode::Data &entry, haystack->children) + huntAndDestroy(needle, entry.node); + + if (needle == haystack->obj) { + haystack->obj = 0; + haystack->flags = 0; + } +} + +static void huntAndEmit(DBusConnection *connection, DBusMessage *msg, + QObject *needle, QDBusConnectionPrivate::ObjectTreeNode *haystack, + const QString &path = QString()) +{ + foreach (const QDBusConnectionPrivate::ObjectTreeNode::Data &entry, haystack->children) + huntAndEmit(connection, msg, needle, entry.node, path + QLatin1String("/") + entry.name); + + if (needle == haystack->obj && haystack->flags & QDBusConnection::ExportAdaptors) { + QByteArray p = path.toLatin1(); + if (p.isEmpty()) + p = "/"; + //qDebug() << p; + DBusMessage *msg2 = dbus_message_copy(msg); + dbus_message_set_path(msg2, p); + dbus_connection_send(connection, msg2, 0); + dbus_message_unref(msg2); + } +} + +static bool typesMatch(int metaId, int variantType) +{ + if (metaId == int(variantType)) + return true; + + if (variantType == QVariant::Int && metaId == QMetaType::Short) + return true; + + if (variantType == QVariant::UInt && (metaId == QMetaType::UShort || + metaId == QMetaType::UChar)) + return true; + + if (variantType == QVariant::List) { + if (metaId == QDBusTypeHelper<bool>::listId() || + metaId == QDBusTypeHelper<short>::listId() || + metaId == QDBusTypeHelper<ushort>::listId() || + metaId == QDBusTypeHelper<int>::listId() || + metaId == QDBusTypeHelper<uint>::listId() || + metaId == QDBusTypeHelper<qlonglong>::listId() || + metaId == QDBusTypeHelper<qulonglong>::listId() || + metaId == QDBusTypeHelper<double>::listId()) + return true; + } + + return false; // no match +} + +static int findSlot(const QMetaObject *mo, const QByteArray &name, int flags, + const QDBusTypeList &types, QList<int>& metaTypes) +{ + // find the first slot + const QMetaObject *super = mo; + while (super != &QObject::staticMetaObject && + super != &QDBusAbstractAdaptor::staticMetaObject) + super = super->superClass(); + + int attributeMask = (flags & QDBusConnection::ExportAllSlots) ? + 0 : QMetaMethod::Scriptable; + + for (int idx = super->methodCount() ; idx <= mo->methodCount(); ++idx) { + QMetaMethod mm = mo->method(idx); + + // check access: + if (mm.access() != QMetaMethod::Public) + continue; + + // check type: + // unnecessary, since slots are never public: + //if (mm.methodType() != QMetaMethod::Slot) + // continue; + + // check name: + QByteArray sig = QMetaObject::normalizedSignature(mm.signature()); + int paren = sig.indexOf('('); + if (paren != name.length() || !sig.startsWith( name )) + continue; + + int returnType = qDBusNameToTypeId(mm.typeName()); + bool isAsync = qDBusCheckAsyncTag(mm.tag()); + + // consistency check: + if (isAsync && returnType != QMetaType::Void) + continue; + + int inputCount = qDBusParametersForMethod(mm, metaTypes); + if (inputCount == -1) + continue; // problem parsing + + metaTypes[0] = returnType; + bool hasMessage = false; + if (inputCount > 0 && + metaTypes.at(inputCount) == QDBusConnectionPrivate::messageMetaType) { + // "no input parameters" is allowed as long as the message meta type is there + hasMessage = true; + --inputCount; + } + + // try to match the parameters + if (inputCount != types.count()) + continue; // not enough parameters + + bool matches = true; + int i; + for (i = 0; i < types.count(); ++i) + if ( !typesMatch(metaTypes.at(i + 1), types.at(i).qvariantType()) ) { + matches = false; + break; + } + + if (!matches) + continue; // we didn't match them all + + // consistency check: + if (isAsync && metaTypes.count() > i + 1) + continue; + + if (hasMessage && (mm.attributes() & attributeMask) != attributeMask) + continue; // not exported + + // if we got here, this slot matched + return idx; + } + + // no slot matched + return -1; +} + +static CallDeliveryEvent* prepareReply(QObject *object, int idx, const QList<int> &metaTypes, + const QDBusMessage &msg) +{ + Q_ASSERT(object); + + int n = metaTypes.count() - 1; + if (metaTypes[n] == QDBusConnectionPrivate::messageMetaType) + --n; + + // check that types match + for (int i = 0; i < n; ++i) + if (!typesMatch(metaTypes.at(i + 1), msg.at(i).type())) + return 0; // no match + + // we can deliver + // prepare for the call + CallDeliveryEvent *data = new CallDeliveryEvent; + data->object = object; + data->flags = 0; + data->message = msg; + data->metaTypes = metaTypes; + data->slotIdx = idx; + + return data; +} + +bool QDBusConnectionPrivate::activateSignal(const QDBusConnectionPrivate::SignalHook& hook, + const QDBusMessage &msg) +{ + // This is called by QDBusConnectionPrivate::handleSignal to deliver a signal + // that was received from D-Bus + // + // Signals are delivered to slots if the parameters match + // Slots can have less parameters than there are on the message + // Slots can optionally have one final parameter that is a QDBusMessage + // Slots receive read-only copies of the message (i.e., pass by value or by const-ref) + CallDeliveryEvent *call = prepareReply(hook.obj, hook.midx, hook.params, msg); + if (call) { + postCallDeliveryEvent(call); + return true; + } + return false; +} + +bool QDBusConnectionPrivate::activateCall(QObject* object, int flags, + const QDBusMessage &msg) +{ + // This is called by QDBusConnectionPrivate::handleObjectCall to place a call + // to a slot on the object. + // + // The call is delivered to the first slot that matches the following conditions: + // - has the same name as the message's target name + // - 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. + // + // Because the marshalling of D-Bus data into QVariant loses the information on + // the original types, the message signature is used to determine the original type. + // Aside from that, the "int" and "unsigned" types will be tried as well. + // + // 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. + + if (!object) + return false; + + QList<int> metaTypes; + int idx; + + { + const QMetaObject *mo = object->metaObject(); + QDBusTypeList typeList(msg.signature().toUtf8()); + QByteArray name = msg.name().toUtf8(); + + // find a slot that matches according to the rules above + idx = ::findSlot(mo, name, flags, typeList, metaTypes); + if (idx == -1) { + // try with no parameters, but with a QDBusMessage + idx = ::findSlot(mo, name, flags, QDBusTypeList(), metaTypes); + if (metaTypes.count() != 2 || metaTypes.at(1) != messageMetaType) + return false; + } + } + + // found the slot to be called + // prepare for the call: + CallDeliveryEvent *call = new CallDeliveryEvent; + + // parameters: + call->object = object; + call->flags = flags; + call->message = msg; + + // save our state: + call->metaTypes = metaTypes; + call->slotIdx = idx; + + postCallDeliveryEvent(call); + + // ready + return true; +} + +void QDBusConnectionPrivate::postCallDeliveryEvent(CallDeliveryEvent *data) +{ + Q_ASSERT(data); + data->conn = this; +#if USE_OUTSIDE_DISPATCH + callDeliveryMutex.lock(); + callDeliveryState = data; +#else + QCoreApplication::postEvent( this, data ); +#endif +} + +CallDeliveryEvent *QDBusConnectionPrivate::postedCallDeliveryEvent() +{ + CallDeliveryEvent *e = callDeliveryState; + Q_ASSERT(e && e->conn == this); + + // release it: + callDeliveryState = 0; + callDeliveryMutex.unlock(); + + return e; +} + +void QDBusConnectionPrivate::deliverCall(const CallDeliveryEvent& data) const +{ + // resume state: + const QList<int>& metaTypes = data.metaTypes; + const QDBusMessage& msg = data.message; + + 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; + for (i = 1; i <= msg.count(); ++i) { + int id = metaTypes[i]; + if (id == QDBusConnectionPrivate::messageMetaType) + break; + + if (id == int(msg.at(i - 1).userType())) + // no conversion needed + params.append(const_cast<void *>( msg.at(i - 1).constData() )); + else { + // convert to what the function expects + auxParameters.append(QVariant()); + + const QVariant &in = msg.at(i - 1); + QVariant &out = auxParameters[auxParameters.count() - 1]; + + bool error = false; + if (id == QVariant::List) { + int mid = in.userType(); + // the only conversion possible here is from a specialised QList<T> to QVariantList + if (mid == QDBusTypeHelper<bool>::listId()) + out = qVariantFromValue(QDBusTypeHelper<bool>::toVariantList(in)); + else if (mid == QDBusTypeHelper<short>::listId()) + out = qVariantFromValue(QDBusTypeHelper<short>::toVariantList(in)); + else if (mid == QDBusTypeHelper<ushort>::listId()) + out = qVariantFromValue(QDBusTypeHelper<ushort>::toVariantList(in)); + else if (mid == QDBusTypeHelper<int>::listId()) + out = qVariantFromValue(QDBusTypeHelper<int>::toVariantList(in)); + else if (mid == QDBusTypeHelper<uint>::listId()) + out = qVariantFromValue(QDBusTypeHelper<uint>::toVariantList(in)); + else if (mid == QDBusTypeHelper<qlonglong>::listId()) + out = qVariantFromValue(QDBusTypeHelper<qlonglong>::toVariantList(in)); + else if (mid == QDBusTypeHelper<qulonglong>::listId()) + out = qVariantFromValue(QDBusTypeHelper<qulonglong>::toVariantList(in)); + else if (mid == QDBusTypeHelper<double>::listId()) + out = qVariantFromValue(QDBusTypeHelper<double>::toVariantList(in)); + else + error = true; + } else if (in.type() == QVariant::UInt) { + if (id == QMetaType::UChar) { + uchar uc = in.toUInt(); + out = qVariantFromValue(uc); + } else if (id == QMetaType::UShort) { + ushort us = in.toUInt(); + out = qVariantFromValue(us); + } else { + error = true; + } + } else if (in.type() == QVariant::Int) { + if (id == QMetaType::Short) { + short s = in.toInt(); + out = qVariantFromValue(s); + } else { + error = true; + } + } else { + error = true; + } + + if (error) + qFatal("Internal error: got invalid meta type %d when trying to convert to meta type %d", + in.userType(), id); + + params.append( const_cast<void *>(out.constData()) ); + } + } + + bool takesMessage = false; + if (metaTypes.count() > i && metaTypes[i] == QDBusConnectionPrivate::messageMetaType) { + params.append(const_cast<void*>(static_cast<const void*>(&msg))); + takesMessage = true; + ++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 (data.object.isNull()) + fail = true; + else + fail = data.object->qt_metacall(QMetaObject::InvokeMetaMethod, + data.slotIdx, params.data()) >= 0; + + // do we create a reply? Only if the caller is waiting for a reply and one hasn't been sent + // yet. + if (!msg.noReply() && !msg.wasRepliedTo()) { + if (!fail) { + // normal reply + QDBusMessage reply = QDBusMessage::methodReply(msg); + reply += outputArgs; + + qDebug() << "Automatically sending reply:" << reply; + send(reply); + } + else { + // generate internal error + QDBusMessage reply = QDBusMessage::error(msg, QDBusError(QDBusError::InternalError, + QLatin1String("Failed to deliver message"))); + qWarning("Internal error: Failed to deliver message"); + send(reply); + } + } + + return; +} + +void QDBusConnectionPrivate::customEvent(QEvent *event) +{ + // nothing else should be sending custom events at us + CallDeliveryEvent* call = static_cast<CallDeliveryEvent *>(event); + + // self check: + Q_ASSERT(call->conn == this); + + deliverCall(*call); +} + +QDBusConnectionPrivate::QDBusConnectionPrivate(QObject *parent) + : QObject(parent), ref(1), mode(InvalidMode), connection(0), server(0), busService(0) +{ + extern bool qDBusInitThreads(); + static const int msgType = registerMessageMetaType(); + static const bool threads = qDBusInitThreads(); + static const bool metatypes = QDBusMetaTypeId::innerInitialize(); + + Q_UNUSED(msgType); + Q_UNUSED(threads); + Q_UNUSED(metatypes); + + dbus_error_init(&error); + + rootNode.flags = 0; +} + +QDBusConnectionPrivate::~QDBusConnectionPrivate() +{ + if (dbus_error_is_set(&error)) + dbus_error_free(&error); + + closeConnection(); + rootNode.clear(); // free resources + qDeleteAll(cachedMetaObjects); +} + +void QDBusConnectionPrivate::closeConnection() +{ + QWriteLocker locker(&lock); + ConnectionMode oldMode = mode; + mode = InvalidMode; // prevent reentrancy + if (oldMode == ServerMode) { + if (server) { + dbus_server_disconnect(server); + dbus_server_unref(server); + server = 0; + } + } else if (oldMode == ClientMode) { + if (connection) { + dbus_connection_close(connection); + // send the "close" message + while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS) + ; + dbus_connection_unref(connection); + connection = 0; + } + } +} + +bool QDBusConnectionPrivate::handleError() +{ + lastError = QDBusError(&error); + if (dbus_error_is_set(&error)) + dbus_error_free(&error); + return lastError.isValid(); +} + +void QDBusConnectionPrivate::bindToApplication() +{ + // Yay, now that we have an application we are in business + Q_ASSERT_X(QCoreApplication::instance(), "QDBusConnection", + "qDBusBindToApplication called without an application"); + moveToThread(QCoreApplication::instance()->thread()); + + // Re-add all watchers + WatcherHash oldWatchers = watchers; + watchers.clear(); + QHashIterator<int, QDBusConnectionPrivate::Watcher> it(oldWatchers); + while (it.hasNext()) { + it.next(); + if (!it.value().read && !it.value().write) { + qDBusAddWatch(it.value().watch, this); + } else { + watchers.insertMulti(it.key(), it.value()); + } + } + + // Re-add all timeouts + while (!pendingTimeouts.isEmpty()) + qDBusAddTimeout(pendingTimeouts.takeFirst(), this); +} + +void QDBusConnectionPrivate::timerEvent(QTimerEvent *e) +{ + DBusTimeout *timeout = timeouts.value(e->timerId(), 0); + dbus_timeout_handle(timeout); +} + +void QDBusConnectionPrivate::doDispatch() +{ + if (mode == ClientMode) + while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS); +} + +void QDBusConnectionPrivate::socketRead(int fd) +{ + QHashIterator<int, QDBusConnectionPrivate::Watcher> it(watchers); + while (it.hasNext()) { + it.next(); + if (it.key() == fd && it.value().read && it.value().read->isEnabled()) { + if (!dbus_watch_handle(it.value().watch, DBUS_WATCH_READABLE)) + qDebug("OUT OF MEM"); + } + } + + doDispatch(); +} + +void QDBusConnectionPrivate::socketWrite(int fd) +{ + QHashIterator<int, QDBusConnectionPrivate::Watcher> it(watchers); + while (it.hasNext()) { + it.next(); + if (it.key() == fd && it.value().write && it.value().write->isEnabled()) { + if (!dbus_watch_handle(it.value().watch, DBUS_WATCH_WRITABLE)) + qDebug("OUT OF MEM"); + } + } +} + +void QDBusConnectionPrivate::objectDestroyed(QObject *obj) +{ + QWriteLocker locker(&lock); + huntAndDestroy(obj, &rootNode); + + SignalHookHash::iterator sit = signalHooks.begin(); + while (sit != signalHooks.end()) { + if (static_cast<QObject *>(sit.value().obj) == obj) + sit = signalHooks.erase(sit); + else + ++sit; + } + + obj->disconnect(this); +} + +void QDBusConnectionPrivate::relaySignal(QObject *obj, const char *interface, const char *name, + const QVariantList &args) +{ + QReadLocker locker(&lock); + QDBusMessage message = QDBusMessage::signal(QLatin1String("/"), QLatin1String(interface), + QLatin1String(name)); + message += args; + DBusMessage *msg = message.toDBusMessage(); + if (!msg) { + qWarning("Could not emit signal %s.%s", interface, name); + return; + } + + //qDebug() << "Emitting signal" << message; + //qDebug() << "for paths:"; + dbus_message_set_no_reply(msg, true); // the reply would not be delivered to anything + huntAndEmit(connection, msg, obj, &rootNode); + dbus_message_unref(msg); +} + +int QDBusConnectionPrivate::registerMessageMetaType() +{ + int tp = messageMetaType = qRegisterMetaType<QDBusMessage>("QDBusMessage"); + return tp; +} + +int QDBusConnectionPrivate::findSlot(QObject* obj, const QByteArray &normalizedName, + QList<int> ¶ms) +{ + int midx = obj->metaObject()->indexOfMethod(normalizedName); + if (midx == -1) { + qWarning("No such slot '%s' while connecting D-Bus", normalizedName.constData()); + 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; +} + +bool QDBusConnectionPrivate::prepareHook(QDBusConnectionPrivate::SignalHook &hook, QString &key, + const QString &service, const QString &path, + const QString &interface, const QString &name, + QObject *receiver, const char *signal, int minMIdx, + bool buildSignature) +{ + QByteArray normalizedName = QMetaObject::normalizedSignature(signal + 1); + hook.midx = findSlot(receiver, normalizedName, hook.params); + if (hook.midx < minMIdx) + return false; + + hook.sender = service; + hook.path = path; + hook.obj = receiver; + + // build the D-Bus signal name and signature + QString mname = name; + if (mname.isEmpty()) { + normalizedName.truncate(normalizedName.indexOf('(')); + mname = QString::fromUtf8(normalizedName); + } + key = mname; + key.reserve(interface.length() + 1 + mname.length()); + key += ':'; + key += interface; + + if (buildSignature) { + hook.signature.clear(); + for (int i = 1; i < hook.params.count(); ++i) + if (hook.params.at(i) != messageMetaType) + hook.signature += QLatin1String( QDBusType::dbusSignature( QVariant::Type(hook.params.at(i)) ) ); + } + + return true; // connect to this signal +} + +bool QDBusConnectionPrivate::activateInternalFilters(const ObjectTreeNode *node, const QDBusMessage &msg) +{ + // object may be null + + if (msg.interface().isEmpty() || msg.interface() == QLatin1String(DBUS_INTERFACE_INTROSPECTABLE)) { + if (msg.method() == QLatin1String("Introspect") && msg.signature().isEmpty()) + qDBusIntrospectObject(node, msg); + if (msg.interface() == QLatin1String(DBUS_INTERFACE_INTROSPECTABLE)) + return true; + } + + if (node->obj && (msg.interface().isEmpty() || + msg.interface() == QLatin1String(DBUS_INTERFACE_PROPERTIES))) { + if (msg.method() == QLatin1String("Get") && msg.signature() == QLatin1String("ss")) + qDBusPropertyGet(node, msg); + else if (msg.method() == QLatin1String("Set") && msg.signature() == QLatin1String("ssv")) + qDBusPropertySet(node, msg); + + if (msg.interface() == QLatin1String(DBUS_INTERFACE_PROPERTIES)) + return true; + } + + return false; +} + +bool QDBusConnectionPrivate::activateObject(const ObjectTreeNode *node, const QDBusMessage &msg) +{ + // 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 + + 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 + foreach (const QDBusAdaptorConnector::AdaptorData &entry, connector->adaptors) + if (activateCall(entry.adaptor, newflags, msg)) + return true; + } 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.end() && it->interface == msg.interface()) + if (activateCall(it->adaptor, newflags, msg)) + return true; + } + } + + // no adaptors matched + // try our standard filters + if (activateInternalFilters(node, msg)) + return true; + + // try the object itself: + if (node->flags & QDBusConnection::ExportSlots && activateCall(node->obj, node->flags, msg)) + return true; +#if 0 + // nothing matched + qDebug("Call failed: no match for %s%s%s at %s", + qPrintable(msg.interface()), msg.interface().isEmpty() ? "" : ".", + qPrintable(msg.name()), + qPrintable(msg.path())); +#endif + return false; +} + +template<typename Func> +static bool applyForObject(QDBusConnectionPrivate::ObjectTreeNode *root, const QString &fullpath, + Func& functor) +{ + // walk the object tree + QStringList path = fullpath.split(QLatin1Char('/')); + if (path.last().isEmpty()) + path.removeLast(); // happens if path is "/" + int i = 1; + QDBusConnectionPrivate::ObjectTreeNode *node = root; + + // try our own tree first + while (node && !(node->flags & QDBusConnection::ExportChildObjects) ) { + if (i == path.count()) { + // found our object + functor(node); + return true; + } + + QVector<QDBusConnectionPrivate::ObjectTreeNode::Data>::ConstIterator it = + qLowerBound(node->children.constBegin(), node->children.constEnd(), path.at(i)); + if (it != node->children.constEnd() && it->name == path.at(i)) + // match + node = it->node; + else + node = 0; + + ++i; + } + + // any object in the tree can tell us to switch to its own object tree: + if (node && node->flags & QDBusConnection::ExportChildObjects) { + QObject *obj = node->obj; + + while (obj) { + if (i == path.count()) { + // we're at the correct level + QDBusConnectionPrivate::ObjectTreeNode fakenode(*node); + fakenode.obj = obj; + functor(&fakenode); + return true; + } + + const QObjectList children = obj->children(); + + // find a child with the proper name + QObject *next = 0; + foreach (QObject *child, children) + if (child->objectName() == path.at(i)) { + next = child; + break; + } + + if (!next) + break; + + ++i; + obj = next; + } + } + + // object not found + return false; +} + +struct qdbus_activateObject +{ + QDBusConnectionPrivate *self; + const QDBusMessage &msg; + bool returnVal; + inline qdbus_activateObject(QDBusConnectionPrivate *s, const QDBusMessage &m) + : self(s), msg(m) + { } + + inline void operator()(QDBusConnectionPrivate::ObjectTreeNode *node) + { returnVal = self->activateObject(node, msg); } +}; + +bool QDBusConnectionPrivate::handleObjectCall(const QDBusMessage &msg) +{ + QReadLocker locker(&lock); + + qdbus_activateObject apply(this, msg); + if (applyForObject(&rootNode, msg.path(), apply)) + return apply.returnVal; + + qDebug("Call failed: no object found at %s", qPrintable(msg.path())); + return false; +} + +bool QDBusConnectionPrivate::handleSignal(const QString &key, const QDBusMessage& msg) +{ + bool result = false; + SignalHookHash::const_iterator it = signalHooks.find(key); + //qDebug("looking for: %s", path.toLocal8Bit().constData()); + //qDebug() << signalHooks.keys(); + for ( ; it != signalHooks.constEnd() && it.key() == key; ++it) { + const SignalHook &hook = it.value(); + if ( !hook.sender.isEmpty() && hook.sender != msg.sender() ) + 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; + + // yes, |= + result |= activateSignal(hook, msg); + } + return result; +} + +bool QDBusConnectionPrivate::handleSignal(const QDBusMessage& msg) +{ + QString key = msg.member(); + key.reserve(key.length() + 1 + msg.interface().length()); + key += ':'; + key += msg.interface(); + + QReadLocker locker(&lock); + bool result = handleSignal(key, msg); // one try + + key.truncate(msg.member().length() + 1); // keep the ':' + result |= handleSignal(key, msg); // second try + return result; +} + +static dbus_int32_t server_slot = -1; + +void QDBusConnectionPrivate::setServer(DBusServer *s) +{ + if (!server) { + handleError(); + return; + } + + server = s; + mode = ServerMode; + + dbus_server_allocate_data_slot(&server_slot); + if (server_slot < 0) + return; + + dbus_server_set_watch_functions(server, qDBusAddWatch, qDBusRemoveWatch, + qDBusToggleWatch, this, 0); // ### check return type? + dbus_server_set_timeout_functions(server, qDBusAddTimeout, qDBusRemoveTimeout, + qDBusToggleTimeout, this, 0); + dbus_server_set_new_connection_function(server, qDBusNewConnection, this, 0); + + dbus_server_set_data(server, server_slot, this, 0); +} + +void QDBusConnectionPrivate::setConnection(DBusConnection *dbc) +{ + if (!dbc) { + handleError(); + return; + } + + connection = dbc; + mode = ClientMode; + + dbus_connection_set_exit_on_disconnect(connection, false); + dbus_connection_set_watch_functions(connection, qDBusAddWatch, qDBusRemoveWatch, + qDBusToggleWatch, this, 0); + dbus_connection_set_timeout_functions(connection, qDBusAddTimeout, qDBusRemoveTimeout, + qDBusToggleTimeout, this, 0); +// dbus_bus_add_match(connection, "type='signal',interface='com.trolltech.dbus.Signal'", &error); +// dbus_bus_add_match(connection, "type='signal'", &error); + + dbus_bus_add_match(connection, "type='signal'", &error); + if (handleError()) { + closeConnection(); + return; + } + + const char *service = dbus_bus_get_unique_name(connection); + if (service) { + QVarLengthArray<char, 56> filter; + filter.append("destination='", 13); + filter.append(service, qstrlen(service)); + filter.append("\'\0", 2); + + dbus_bus_add_match(connection, filter.constData(), &error); + if (handleError()) { + closeConnection(); + return; + } + } else { + qWarning("QDBusConnectionPrivate::SetConnection: Unable to get base service"); + } + +#if USE_OUTSIDE_DISPATCH + dbus_connection_add_filter_outside(connection, qDBusSignalFilter, qDBusSignalFilterOutside, this, 0); +#else + dbus_connection_add_filter(connection, qDBusSignalFilter, this, 0); +#endif + + //qDebug("base service: %s", service); + + // schedule a dispatch: + QMetaObject::invokeMethod(this, "doDispatch", Qt::QueuedConnection); +} + +extern "C"{ +static void qDBusResultReceived(DBusPendingCall *pending, void *user_data) +{ + QDBusConnectionPrivate::messageResultReceived(pending, user_data); +} +} + +void QDBusConnectionPrivate::messageResultReceived(DBusPendingCall *pending, void *user_data) +{ + QDBusPendingCall *call = reinterpret_cast<QDBusPendingCall *>(user_data); + QDBusConnectionPrivate *connection = const_cast<QDBusConnectionPrivate *>(call->connection); + Q_ASSERT(call->pending == pending); + + if (!call->receiver.isNull() && call->methodIdx != -1) { + DBusMessage *reply = dbus_pending_call_steal_reply(pending); + + // 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) + + QDBusMessage msg = QDBusMessage::fromDBusMessage(reply, QDBusConnection(connection->name)); + qDebug() << "got message: " << msg; + CallDeliveryEvent *e = prepareReply(call->receiver, call->methodIdx, call->metaTypes, msg); + if (e) + connection->postCallDeliveryEvent(e); + else + qDebug() << "Deliver failed!"; + } + dbus_pending_call_unref(pending); + delete call; +} + +int QDBusConnectionPrivate::send(const QDBusMessage& message) const +{ + DBusMessage *msg = message.toDBusMessage(); + if (!msg) + return 0; + + dbus_message_set_no_reply(msg, true); // the reply would not be delivered to anything + + qDebug() << "sending message:" << message; + bool isOk = dbus_connection_send(connection, msg, 0); + int serial = 0; + if (isOk) + serial = dbus_message_get_serial(msg); + + dbus_message_unref(msg); + return serial; +} + +QDBusMessage QDBusConnectionPrivate::sendWithReply(const QDBusMessage &message, + int mode) +{ + if (!QCoreApplication::instance() || mode == QDBusConnection::NoUseEventLoop) { + DBusMessage *msg = message.toDBusMessage(); + if (!msg) + return QDBusMessage(); + + qDebug() << "sending message:" << message; + DBusMessage *reply = dbus_connection_send_with_reply_and_block(connection, msg, + -1, &error); + handleError(); + dbus_message_unref(msg); + + if (lastError.isValid()) + return QDBusMessage::fromError(lastError); + + QDBusMessage amsg = QDBusMessage::fromDBusMessage(reply, QDBusConnection(name)); + qDebug() << "got message:" << amsg; + + if (dbus_connection_get_dispatch_status(connection) == DBUS_DISPATCH_DATA_REMAINS) + QMetaObject::invokeMethod(this, "doDispatch", Qt::QueuedConnection); + return amsg; + } else { // use the event loop + QDBusReplyWaiter waiter; + if (sendWithReplyAsync(message, &waiter, SLOT(reply(const QDBusMessage&))) > 0) { + // enter the event loop and wait for a reply + waiter.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents); + + lastError = waiter.replyMsg; // set or clear error + return waiter.replyMsg; + } + + return QDBusMessage(); + } +} + +int QDBusConnectionPrivate::sendWithReplyAsync(const QDBusMessage &message, QObject *receiver, + const char *method) +{ + if (!receiver || !method || !*method) + // would not be able to deliver a reply + return send(message); + + int slotIdx = -1; + QList<int> metaTypes; + QByteArray normalizedName = QMetaObject::normalizedSignature(method + 1); + slotIdx = findSlot(receiver, normalizedName, metaTypes); + if (slotIdx == -1) + // would not be able to deliver a reply + return send(message); + + DBusMessage *msg = message.toDBusMessage(); + if (!msg) + return 0; + + qDebug() << "sending message:" << message; + DBusPendingCall *pending = 0; + if (dbus_connection_send_with_reply(connection, msg, &pending, message.timeout())) { + if (slotIdx != -1) { + QDBusPendingCall *pcall = new QDBusPendingCall; + pcall->receiver = receiver; + pcall->metaTypes = metaTypes; + pcall->methodIdx = slotIdx; + pcall->connection = this; + pcall->pending = dbus_pending_call_ref(pending); + dbus_pending_call_set_notify(pending, qDBusResultReceived, pcall, 0); + } + dbus_pending_call_unref(pending); + return dbus_message_get_serial(msg); + } + + return 0; +} + +void QDBusConnectionPrivate::connectSignal(const QString &key, const SignalHook &hook) +{ + signalHooks.insertMulti(key, hook); + connect(hook.obj, SIGNAL(destroyed(QObject*)), SLOT(objectDestroyed(QObject*))); +} + +void QDBusConnectionPrivate::registerObject(const ObjectTreeNode *node) +{ + connect(node->obj, SIGNAL(destroyed(QObject*)), SLOT(objectDestroyed(QObject*))); + + if (node->flags & QDBusConnection::ExportAdaptors) { + QDBusAdaptorConnector *connector = qDBusCreateAdaptorConnector(node->obj); + + // disconnect and reconnect to avoid duplicates + connector->disconnect(SIGNAL(relaySignal(QObject*,const char*,const char*,QVariantList)), + this, SLOT(relaySignal(QObject*,const char*,const char*,QVariantList))); + connect(connector, SIGNAL(relaySignal(QObject*,const char*,const char*,QVariantList)), + SLOT(relaySignal(QObject*,const char*,const char*,QVariantList))); + } +} + +void QDBusConnectionPrivate::connectRelay(const QString &service, const QString &path, + const QString &interface, + QDBusAbstractInterface *receiver, + const char *signal) +{ + // 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(), receiver, signal, + QDBusAbstractInterface::staticMetaObject.methodCount(), true)) + return; // don't connect + + // add it to our list: + QWriteLocker locker(&lock); + SignalHookHash::ConstIterator it = signalHooks.find(key); + SignalHookHash::ConstIterator end = signalHooks.end(); + for ( ; it != end && it.key() == key; ++it) { + const SignalHook &entry = it.value(); + if (entry.sender == hook.sender && + 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); +} + +void QDBusConnectionPrivate::disconnectRelay(const QString &service, const QString &path, + const QString &interface, + QDBusAbstractInterface *receiver, + const char *signal) +{ + // 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(), receiver, signal, + QDBusAbstractInterface::staticMetaObject.methodCount(), true)) + return; // don't connect + + // remove it from our list: + QWriteLocker locker(&lock); + 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.sender == hook.sender && + entry.path == hook.path && + entry.signature == hook.signature && + entry.obj == hook.obj && + entry.midx == hook.midx) { + // found it + signalHooks.erase(it); + return; + } + } + + qWarning("QDBusConnectionPrivate::disconnectRelay called for a signal that was not found"); +} + +QString QDBusConnectionPrivate::getNameOwner(const QString& name) +{ + if (QDBusUtil::isValidUniqueConnectionName(name)) + return name; + if (!connection || !QDBusUtil::isValidBusName(name)) + return QString(); + + QDBusMessage msg = QDBusMessage::methodCall(QLatin1String(DBUS_SERVICE_DBUS), + QLatin1String(DBUS_PATH_DBUS), QLatin1String(DBUS_INTERFACE_DBUS), + QLatin1String("GetNameOwner")); + msg << name; + QDBusMessage reply = sendWithReply(msg, QDBusConnection::NoUseEventLoop); + if (!lastError.isValid() && reply.type() == QDBusMessage::ReplyMessage) + return reply.first().toString(); + return QString(); +} + +QDBusInterfacePrivate * +QDBusConnectionPrivate::findInterface(const QString &service, + const QString &path, + const QString &interface) +{ + // check if it's there first -- FIXME: add binding mode + QDBusMetaObject *mo = 0; + QString owner = getNameOwner(service); + if (connection && !owner.isEmpty() && QDBusUtil::isValidObjectPath(path) && + (interface.isEmpty() || QDBusUtil::isValidInterfaceName(interface))) + // always call here with the unique connection name + mo = findMetaObject(owner, path, interface); + + QDBusInterfacePrivate *p = new QDBusInterfacePrivate(QDBusConnection(name), this, owner, path, interface, mo); + + if (!mo) { + // invalid object + p->isValid = false; + p->lastError = lastError; + if (!lastError.isValid()) { + // try to determine why we couldn't get the data + if (!connection) + p->lastError = QDBusError(QDBusError::Disconnected, + QLatin1String("Not connected to D-Bus server")); + else if (owner.isEmpty()) + p->lastError = QDBusError(QDBusError::ServiceUnknown, + QString(QLatin1String("Service %1 is unknown")).arg(service)); + else if (!QDBusUtil::isValidObjectPath(path)) + p->lastError = QDBusError(QDBusError::InvalidArgs, + QString(QLatin1String("Object path %1 is invalid")).arg(path)); + else if (!interface.isEmpty() && !QDBusUtil::isValidInterfaceName(interface)) + p->lastError = QDBusError(QDBusError::InvalidArgs, + QString(QLatin1String("Interface %1 is invalid")).arg(interface)); + else + p->lastError = QDBusError(QDBusError::Other, QLatin1String("Unknown error")); + } + } + + return p; +} + +struct qdbus_Introspect +{ + QString xml; + inline void operator()(QDBusConnectionPrivate::ObjectTreeNode *node) + { xml = qDBusIntrospectObject(node); } +}; + +QDBusMetaObject * +QDBusConnectionPrivate::findMetaObject(const QString &service, const QString &path, + const QString &interface) +{ + // service must be a unique connection name + if (!interface.isEmpty()) { + QReadLocker locker(&lock); + QDBusMetaObject *mo = cachedMetaObjects.value(interface, 0); + if (mo) + return mo; + } + if (service == QString::fromUtf8(dbus_bus_get_unique_name(connection))) { + // it's one of our own + QWriteLocker locker(&lock); + 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; + + qdbus_Introspect apply; + if (!applyForObject(&rootNode, path, apply)) { + lastError = QDBusError(QDBusError::InvalidArgs, + QString(QLatin1String("No object at %1")).arg(path)); + return 0; // no object at path + } + + // release the lock and return + return QDBusMetaObject::createMetaObject(interface, apply.xml, cachedMetaObjects, lastError); + } + + // not local: introspect the target object: + QDBusMessage msg = QDBusMessage::methodCall(service, path, + QLatin1String(DBUS_INTERFACE_INTROSPECTABLE), + QLatin1String("Introspect")); + + + QDBusMessage reply = sendWithReply(msg, QDBusConnection::NoUseEventLoop); + + // it doesn't exist yet, we have to create it + QWriteLocker locker(&lock); + 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) + // fetch the XML description + xml = reply.first().toString(); + else { + lastError = reply; + if (reply.type() != QDBusMessage::ErrorMessage || lastError != QDBusError::UnknownMethod) + return 0; // error + } + + // release the lock and return + return QDBusMetaObject::createMetaObject(interface, xml, cachedMetaObjects, lastError); +} + +void QDBusReplyWaiter::reply(const QDBusMessage &msg) +{ + replyMsg = msg; + QTimer::singleShot(0, this, SLOT(quit())); +} + +#include "qdbusconnection_p.moc" diff --git a/qt/src/qdbusinterface.cpp b/qt/src/qdbusinterface.cpp new file mode 100644 index 00000000..6367654d --- /dev/null +++ b/qt/src/qdbusinterface.cpp @@ -0,0 +1,203 @@ +/* -*- C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusinterface.h" + +#include <dbus/dbus.h> +#include <QtCore/qpointer.h> + +#include "qdbusinterface_p.h" +#include "qdbusconnection_p.h" + +/*! + \class QDBusInterface + \brief Proxy class for interfaces on remote objects. + + QDBusInterface is a generic accessor class that is used to place calls to remote objects, + connect to signals exported by remote objects and get/set the value of remote properties. This + class is useful for dynamic access to remote objects: that is, when you do not have a generated + code that represents the remote interface. + + Calls are usually placed by using the call() function, which constructs the message, sends it + over the bus, waits for the reply and decodes the reply. Signals are connected to by using the + normal QObject::connect() function. Finally, properties are accessed using the + QObject::property() and QObject::setProperty() functions. +*/ + +QDBusInterface::QDBusInterface(QDBusInterfacePrivate *p) + : QDBusAbstractInterface(p) +{ +} + +/*! + Destroy the object interface and frees up any resource used. +*/ +QDBusInterface::~QDBusInterface() +{ + // resources are freed in QDBusInterfacePrivate::~QDBusInterfacePrivate() +} + +/*! + \internal + Overrides QObject::metaObject to return our own copy. +*/ +const QMetaObject *QDBusInterface::metaObject() const +{ + return d_func()->isValid ? d_func()->metaObject : &QDBusAbstractInterface::staticMetaObject; +} + +/*! + \internal + Override QObject::qt_metacast to catch the interface name too. +*/ +void *QDBusInterface::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, "QDBusInterface")) + return static_cast<void*>(const_cast<QDBusInterface*>(this)); + if (d_func()->interface == _clname) + return static_cast<void*>(const_cast<QDBusInterface*>(this)); + return QDBusAbstractInterface::qt_metacast(_clname); +} + +/*! + \internal + Dispatch the call through the private. +*/ +int QDBusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a); + if (_id < 0 || !d_func()->isValid) + return _id; + return d_func()->metacall(_c, _id, _a); +} + +int QDBusInterfacePrivate::metacall(QMetaObject::Call c, int id, void **argv) +{ + Q_Q(QDBusInterface); + + if (c == QMetaObject::InvokeMetaMethod) { + int offset = metaObject->methodOffset(); + QMetaMethod mm = metaObject->method(id + offset); + + if (mm.methodType() == QMetaMethod::Signal) { + // signal relay from D-Bus world to Qt world + QMetaObject::activate(q, metaObject, id, argv); + + } else if (mm.methodType() == QMetaMethod::Slot) { + // method call relay from Qt world to D-Bus world + // get D-Bus equivalent signature + QString methodName = metaObject->dbusNameForMethod(id); + const int *inputTypes = metaObject->inputTypesForMethod(id); + const int *outputTypes = metaObject->outputTypesForMethod(id); + + int inputTypesCount = *inputTypes; + int outputTypesCount = *outputTypes++; + + // we will assume that the input arguments were passed correctly + QVariantList args; + for (int i = 1; i <= inputTypesCount; ++i) + args << QVariant(inputTypes[i], argv[i]); + + // make the call + QPointer<QDBusInterface> qq = q; + QDBusMessage reply = q->callWithArgs(methodName, args); + args.clear(); + + // access to "this" or to "q" below this point must check for "qq" + // we may have been deleted! + + // check if we got the right number of parameters back: + bool success = false; + if (reply.count() == outputTypesCount) { + // copy the values out + for (int i = 0; i < outputTypesCount; ++i) { + // treat the return value specially, since it may be null: + if (i == 0 && argv[0] == 0) + continue; + + // ensure that the types are correct: + const QVariant &item = reply.at(i); + if (outputTypes[i] != item.userType()) { + success = false; + break; + } + + if (i == 0) + QDBusMetaObject::assign(argv[0], item); + else + QDBusMetaObject::assign(argv[inputTypesCount + i], item); + } + } + + // bail out, something weird happened + if (!success && !qq.isNull()) { + QString errmsg = QLatin1String("Invalid signature `%1' in return from call to %2.%3"); + lastError = QDBusError(QDBusError::InvalidSignature, + errmsg.arg(reply.signature(), interface, methodName)); + } + + // done + return -1; + } + } else if (c == QMetaObject::ReadProperty) { + // Qt doesn't support non-readable properties + // we have to re-check + QMetaProperty mp = metaObject->property(id + metaObject->propertyOffset()); + if (!mp.isReadable()) + return -1; // don't read + + QVariant value = property(mp); + if (value.type() == QVariant::Invalid) + // an error occurred -- property already set lastError + return -1; + else if (mp.type() == QVariant::LastType) + // QVariant is special in this context + *reinterpret_cast<QVariant *>(argv[0]) = value; + else + QDBusMetaObject::assign(argv[0], value); + + return -1; // handled + } else if (c == QMetaObject::WriteProperty) { + // QMetaProperty::write has already checked that we're writable + // it has also checked that the type is right + QVariant value(metaObject->propertyMetaType(id), argv[0]); + QMetaProperty mp = metaObject->property(id + metaObject->propertyOffset()); + + setProperty(mp, value); + return -1; + } + return id; +} + +QDBusInterfacePtr::QDBusInterfacePtr(QDBusConnection &conn, const QString &service, const QString &path, + const QString &interface) + : d(conn.findInterface(service, path, interface)) +{ +} + +QDBusInterfacePtr::QDBusInterfacePtr(const QString &service, const QString &path, const QString &interface) + : d(QDBus::sessionBus().findInterface(service, path, interface)) +{ +} + diff --git a/qt/src/qdbusinterface.h b/qt/src/qdbusinterface.h new file mode 100644 index 00000000..0b4d1874 --- /dev/null +++ b/qt/src/qdbusinterface.h @@ -0,0 +1,63 @@ +/* -*- C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSINTERFACE_H +#define QDBUSINTERFACE_H + +#include "qdbusabstractinterface.h" + +class QDBusInterfacePrivate; +class QDBUS_EXPORT QDBusInterface: public QDBusAbstractInterface +{ + friend class QDBusConnection; +private: + QDBusInterface(QDBusInterfacePrivate *p); + +public: + ~QDBusInterface(); + + virtual const QMetaObject *metaObject() const; + virtual void *qt_metacast(const char *); + virtual int qt_metacall(QMetaObject::Call, int, void **); + +private: + Q_DECLARE_PRIVATE(QDBusInterface) + Q_DISABLE_COPY(QDBusInterface) +}; + +struct QDBUS_EXPORT QDBusInterfacePtr +{ + QDBusInterfacePtr(QDBusInterface *iface) : d(iface) { } + QDBusInterfacePtr(QDBusConnection &conn, const QString &service, const QString &path, + const QString &interface = QString()); + QDBusInterfacePtr(const QString &service, const QString &path, const QString &interface = QString()); + ~QDBusInterfacePtr() { delete d; } + + QDBusInterface *interface() { return d; } + QDBusInterface *operator->() { return d; } +private: + QDBusInterface *const d; + Q_DISABLE_COPY(QDBusInterfacePtr) +}; + +#endif diff --git a/qt/src/qdbusinterface_p.h b/qt/src/qdbusinterface_p.h new file mode 100644 index 00000000..25cb9ffa --- /dev/null +++ b/qt/src/qdbusinterface_p.h @@ -0,0 +1,65 @@ +/* + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the public API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef QDBUSINTERFACEPRIVATE_H +#define QDBUSINTERFACEPRIVATE_H + +#include "qdbusabstractinterface_p.h" +#include "qdbusmetaobject_p.h" +#include "qdbusinterface.h" + +class QDBusInterfacePrivate: public QDBusAbstractInterfacePrivate +{ +public: + Q_DECLARE_PUBLIC(QDBusInterface) + + QDBusMetaObject *metaObject; + + inline QDBusInterfacePrivate(const QDBusConnection &con, QDBusConnectionPrivate *conp, + const QString &serv, const QString &p, const QString &iface, + QDBusMetaObject *mo = 0) + : QDBusAbstractInterfacePrivate(con, conp, serv, p, iface), metaObject(mo) + { + } + ~QDBusInterfacePrivate() + { + if (metaObject && !metaObject->cached) + delete metaObject; + } + + int metacall(QMetaObject::Call c, int id, void **argv); +}; + +#endif diff --git a/qt/src/qdbusinternalfilters.cpp b/qt/src/qdbusinternalfilters.cpp new file mode 100644 index 00000000..8886d3bf --- /dev/null +++ b/qt/src/qdbusinternalfilters.cpp @@ -0,0 +1,235 @@ +/* -*- mode: C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusconnection_p.h" + +#include <dbus/dbus.h> +#include <QtCore/qcoreapplication.h> +#include <QtCore/qmetaobject.h> +#include <QtCore/qstringlist.h> + +#include "qdbusabstractadaptor.h" +#include "qdbusabstractadaptor_p.h" +#include "qdbusconnection.h" +#include "qdbusmessage.h" +#include "qdbustypehelper_p.h" +#include "qdbusutil.h" + +// defined in qdbusxmlgenerator.cpp +extern QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo, + const QMetaObject *base, int flags); + +static const char introspectableInterfaceXml[] = + " <interface name=\"org.freedesktop.DBus.Introspectable\">\n" + " <method name=\"Introspect\">\n" + " <arg name=\"xml_data\" type=\"s\" direction=\"out\"/>\n" + " </method>\n" + " </interface>\n"; + +static const char propertiesInterfaceXml[] = + " <interface name=\"org.freedesktop.DBus.Properties\">\n" + " <method name=\"Get\">\n" + " <arg name=\"interface_name\" type=\"s\" direction=\"in\"/>\n" + " <arg name=\"property_name\" type=\"s\" direction=\"in\"/>\n" + " <arg name=\"value\" type=\"v\" direction=\"out\"/>\n" + " </method>\n" + " <method name=\"Set\">\n" + " <arg name=\"interface_name\" type=\"s\" direction=\"in\"/>\n" + " <arg name=\"property_name\" type=\"s\" direction=\"in\"/>\n" + " <arg name=\"value\" type=\"v\" direction=\"in\"/>\n" + " </method>\n" + " </interface>\n"; + +static QString generateSubObjectXml(QObject *object) +{ + QString retval; + foreach (QObject *child, object->children()) { + QString name = child->objectName(); + if (!name.isEmpty()) + retval += QString(QLatin1String(" <node name=\"%1\"/>\n")) + .arg(name); + } + return retval; +} + +QString qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode *node) +{ + // object may be null + + QString xml_data(QLatin1String(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE)); + xml_data += QLatin1String("<node>\n"); + + if (node->obj) { + if (node->flags & QDBusConnection::ExportContents) { + const QMetaObject *mo = node->obj->metaObject(); + for ( ; mo != &QObject::staticMetaObject; mo = mo->superClass()) + xml_data += qDBusGenerateMetaObjectXml(QString(), mo, mo->superClass(), + node->flags); + } + + // does this object have adaptors? + QDBusAdaptorConnector *connector; + if (node->flags & QDBusConnection::ExportAdaptors && + (connector = qDBusFindAdaptorConnector(node->obj))) { + + // trasverse every adaptor in this object + QDBusAdaptorConnector::AdaptorMap::ConstIterator it = connector->adaptors.constBegin(); + QDBusAdaptorConnector::AdaptorMap::ConstIterator end = connector->adaptors.constEnd(); + for ( ; it != end; ++it) { + // add the interface: + QString ifaceXml = QDBusAbstractAdaptorPrivate::retrieveIntrospectionXml(it->adaptor); + if (ifaceXml.isEmpty()) { + // add the interface's contents: + ifaceXml += qDBusGenerateMetaObjectXml(it->interface, it->metaObject, + &QDBusAbstractAdaptor::staticMetaObject, + QDBusConnection::ExportAllContents); + + QDBusAbstractAdaptorPrivate::saveIntrospectionXml(it->adaptor, ifaceXml); + } + + xml_data += ifaceXml; + } + } + + xml_data += QLatin1String( introspectableInterfaceXml ); + xml_data += QLatin1String( propertiesInterfaceXml ); + } + + if (node->flags & QDBusConnection::ExportChildObjects) { + xml_data += generateSubObjectXml(node->obj); + } else { + // generate from the object tree + foreach (const QDBusConnectionPrivate::ObjectTreeNode::Data &entry, node->children) { + if (entry.node && (entry.node->obj || !entry.node->children.isEmpty())) + xml_data += QString(QLatin1String(" <node name=\"%1\"/>\n")) + .arg(entry.name); + } + } + + xml_data += QLatin1String("</node>\n"); + return xml_data; +} + +void qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode *node, + const QDBusMessage &msg) +{ + // now send it + QDBusMessage reply = QDBusMessage::methodReply(msg); + reply << qDBusIntrospectObject(node); + msg.connection().send(reply); +} + +// implement the D-Bus interface org.freedesktop.DBus.Properties + +static void sendPropertyError(const QDBusMessage &msg, const QString &interface_name) +{ + QDBusMessage error = QDBusMessage::error(msg, QLatin1String(DBUS_ERROR_INVALID_ARGS), + QString::fromLatin1("Interface %1 was not found in object %2") + .arg(interface_name) + .arg(msg.path())); + msg.connection().send(error); +} + +void qDBusPropertyGet(const QDBusConnectionPrivate::ObjectTreeNode *node, const QDBusMessage &msg) +{ + Q_ASSERT(msg.count() == 2); + QString interface_name = msg.at(0).toString(); + QByteArray property_name = msg.at(1).toString().toUtf8(); + + QDBusAdaptorConnector *connector; + QVariant value; + if (node->flags & QDBusConnection::ExportAdaptors && + (connector = qDBusFindAdaptorConnector(node->obj))) { + + // find the class that implements interface_name + QDBusAdaptorConnector::AdaptorMap::ConstIterator it; + it = qLowerBound(connector->adaptors.constBegin(), connector->adaptors.constEnd(), + interface_name); + if (it != connector->adaptors.end() && it->interface == interface_name) + value = it->adaptor->property(property_name); + } + + if (!value.isValid() && node->flags & QDBusConnection::ExportProperties) { + // try the object itself + int pidx = node->obj->metaObject()->indexOfProperty(property_name); + if (pidx != -1) { + QMetaProperty mp = node->obj->metaObject()->property(pidx); + if (mp.isScriptable() || (node->flags & QDBusConnection::ExportAllProperties) == + QDBusConnection::ExportAllProperties) + value = mp.read(node->obj); + } + } + + if (!value.isValid()) { + // the property was not found + sendPropertyError(msg, interface_name); + return; + } + + QDBusMessage reply = QDBusMessage::methodReply(msg); + reply.setSignature(QLatin1String("v")); + reply << value; + msg.connection().send(reply); +} + +void qDBusPropertySet(const QDBusConnectionPrivate::ObjectTreeNode *node, const QDBusMessage &msg) +{ + Q_ASSERT(msg.count() == 3); + QString interface_name = msg.at(0).toString(); + QByteArray property_name = msg.at(1).toString().toUtf8(); + QVariant value = QDBusTypeHelper<QVariant>::fromVariant(msg.at(2)); + + QDBusAdaptorConnector *connector; + if (node->flags & QDBusConnection::ExportAdaptors && + (connector = qDBusFindAdaptorConnector(node->obj))) { + + // find the class that implements interface_name + QDBusAdaptorConnector::AdaptorMap::ConstIterator it; + it = qLowerBound(connector->adaptors.constBegin(), connector->adaptors.constEnd(), + interface_name); + if (it != connector->adaptors.end() && it->interface == interface_name) + if (it->adaptor->setProperty(property_name, value)) { + msg.connection().send(QDBusMessage::methodReply(msg)); + return; + } + } + + if (node->flags & QDBusConnection::ExportProperties) { + // try the object itself + int pidx = node->obj->metaObject()->indexOfProperty(property_name); + if (pidx != -1) { + QMetaProperty mp = node->obj->metaObject()->property(pidx); + if (mp.isScriptable() || (node->flags & QDBusConnection::ExportAllProperties) == + QDBusConnection::ExportAllProperties) { + + if (mp.write(node->obj, value)) { + msg.connection().send(QDBusMessage::methodReply(msg)); + return; + } + } + } + } + + // the property was not found or not written to + sendPropertyError(msg, interface_name); +} diff --git a/qt/src/qdbusintrospection.cpp b/qt/src/qdbusintrospection.cpp new file mode 100644 index 00000000..20acbd21 --- /dev/null +++ b/qt/src/qdbusintrospection.cpp @@ -0,0 +1,403 @@ +/* -*- C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusintrospection_p.h" +#include "qdbusxmlparser_p.h" + +/*! + \class QDBusIntrospection + \brief Information about introspected objects and interfaces on D-Bus. + \internal + + This class provides structures and methods for parsing the XML introspection data for D-Bus. + Normally, you don't have to use the methods provided here: QDBusInterface and QDBusObject will + do that for you. + + But they may prove useful if the XML data was obtained through other means (like parsing a file). +*/ + +/*! + \class QDBusIntrospection::Argument + \brief One argument to a D-Bus method or signal. + + This struct represents one argument passed to a method or received from a method or signal in + D-Bus. The struct does not contain information on the direction (input or output). +*/ + +/*! + \var QDBusIntrospection::Argument::type + The argument type. +*/ + +/*! + \var QDBusIntrospection::Argument::name + The argument name. The argument name is optional, so this may be a null QString. +*/ + +/*! + \fn QDBusIntrospection::Argument::operator==(const Argument &other) const + Compares this object against \a other and return true if they are the same. +*/ + +/*! + \class QDBusIntrospection::Method + \brief Information about one method. + + This struct represents one method discovered through introspection. A method is composed of + its \a name, its input arguments, its output arguments, and, optionally, annotations. There are no + "in-out" arguments. +*/ + +/*! + \var QDBusIntrospection::Method::name + The method's name. +*/ + +/*! + \var QDBusIntrospection::Method::inputArgs + A list of the method's input arguments. +*/ + +/*! + \var QDBusIntrospection::Method::outputArgs + A list of the method's output arguments (i.e., return values). +*/ + +/*! + \var QDBusIntrospection::Method::annotations + The annotations associated with the method. Each annotation is a pair of strings, where the key + is of the same format as a D-Bus interface name. The value is arbitrary. +*/ + +/*! + \fn QDBusIntrospection::Method::operator==(const Method &other) const + Compares this object against \a other and return true if they are the same. +*/ + +/*! + \class QDBusIntrospection::Signal + \brief Information about one signal. + + This struct represents one signal discovered through introspection. A signal is composed of + its \a name, its output arguments, and, optionally, annotations. +*/ + +/*! + \var QDBusIntrospection::Signal::name + The signal's name. +*/ + +/*! + \var QDBusIntrospection::Signal::outputArgs + A list of the signal's arguments. +*/ + +/*! + \var QDBusIntrospection::Signal::annotations + The annotations associated with the signal. Each annotation is a pair of strings, where the key + is of the same format as a D-Bus interface name. The value is arbitrary. +*/ + +/*! + \fn QDBusIntrospection::Signal::operator==(const Signal& other) const + Compares this object against \a other and return true if they are the same. +*/ + +/*! + \class QDBusIntrospection::Property + \brief Information about one property. + + This struct represents one property discovered through introspection. A property is composed of + its \a name, its \a type, its \a access rights, and, optionally, annotations. +*/ + +/*! + \var QDBusIntrospection::Property::name + The property's name. +*/ + +/*! + \var QDBusIntrospection::Property::type + The property's type. +*/ + +/*! + \enum QDBusIntrospection::Property::Access + The possible access rights for a property: + \value Read + \value Write + \value ReadWrite +*/ + +/*! + \var QDBusIntrospection::Property::access + The property's access rights. +*/ + +/*! + \var QDBusIntrospection::Property::annotations + The annotations associated with the property. Each annotation is a pair of strings, where the key + is of the same format as a D-Bus interface name. The value is arbitrary. +*/ + +/*! + \fn QDBusIntrospection::Property::operator==(const Property &other) const + Compares this object against \a other and return true if they are the same. +*/ + +/*! + \class QDBusIntrospection::Interface + \brief Information about one interface on the bus. + + Each interface on D-Bus has an unique \a name, identifying where that interface was defined. + Interfaces may have annotations, methods, signals and properties, but none are mandatory. +*/ + +/*! + \var QDBusIntrospection::Interface::name + The interface's name. +*/ + +/*! + \var QDBusIntrospection::Interface::introspection + The XML document fragment describing this interface. + + If parsed again through parseInterface, the object returned should have the same contents as + this object. +*/ + +/*! + \var QDBusIntrospection::Interface::annotations + The annotations associated with the interface. Each annotation is a pair of strings, where the key + is of the same format as a D-Bus interface name. The value is arbitrary. +*/ + +/*! + \var QDBusIntrospection::Interface::methods + The methods available in this interface. Note that method names are not unique (i.e., methods + can be overloaded with multiple arguments types). +*/ + +/*! + \var QDBusIntrospection::Interface::signals_ + The signals available in this interface. Note that signal names are not unique (i.e., signals + can be overloaded with multiple argument types). + + This member is called "signals_" because "signals" is a reserved keyword in Qt. +*/ + +/*! + \var QDBusIntrospection::Interface::properties + The properties available in this interface. Property names are unique. +*/ + +/*! + \fn QDBusIntrospection::Interface::operator==(const Interface &other) const + Compares this object against \a other and return true if they are the same. + + Note that two interfaces are considered to be the same if they have the same name. The internal + structures in the objects are not compared. +*/ + +/*! + \class QDBusIntrospection::Object + \brief Information about one object on the bus. + + An object on the D-Bus bus is represented by its service and path on the service but, unlike + interfaces, objects are mutable. That is, their contents can change with time. Therefore, + while the (service, path) pair uniquely identifies an object, the information contained in + this struct may no longer represent the object. + + An object can contain interfaces and child (sub) objects. +*/ + +/*! + \var QDBusIntrospection::Object::service + The object's service name. + + \sa parseObject(), parseObjectTree() +*/ + +/*! + \var QDBusIntrospection::Object::path + The object's path on the service. This is an absolute path. + + \sa parseObject(), parseObjectTree() +*/ + +/*! + \var QDBusIntrospection::Object::introspection + The XML document fragment describing this object, its interfaces and sub-objects at the time + of the parsing. + + The result of parseObject with this XML data should be the same as the Object struct. +*/ + +/*! + \var QDBusIntrospection::Object::interfaces + The list of interface names in this object. +*/ + +/*! + \var QDBusIntrospection::Object::childObjects + The list of child object names in this object. Note that this is a relative name, not an + absolute path. To obtain the absolute path, concatenate with \l + {QDBusIntrospection::Object::path}{path}. +*/ + +/*! + \class QDBusIntrospection::ObjectTree + \brief Complete information about one object node and its descendency. + + This struct contains the same data as QDBusIntrospection::Object, plus the actual data for the + interfaces and child (sub) objects that was available in the XML document. +*/ + +/*! + \var QDBusIntrospection::ObjectTree::interfaceData + A map of interfaces and their names. +*/ + +/*! + \var QDBusIntrospection::ObjectTree::childObjectData + A map of object paths and their data. The map key contains the relative path to the object. + + Note this map contains only the child notes that do have information about the sub-object's + contents. If the XML data did not contain the information, only the object name will be listed + in childObjects, but not in childObjectData. +*/ + +/*! + \typedef QDBusIntrospection::Annotations + Contains a QMap of an annotation pair. The annotation's name is stored in the QMap key and + must be unique. The annotation's value is stored in the QMap's value and is arbitrary. +*/ + +/*! + \typedef QDBusIntrospection::Arguments + Contains a list of arguments to either a Method or a Signal. The arguments' order is important. +*/ + +/*! + \typedef QDBusIntrospection::Methods + Contains a QMap of methods and their names. The method's name is stored in the map's key and + is not necessarily unique. The order in which multiple methods with the same name are stored + in this map is undefined. +*/ + +/*! + \typedef QDBusIntrospection::Signals + Contains a QMap of signals and their names. The signal's name is stored in the map's key and + is not necessarily unique. The order in which multiple signals with the same name are stored + in this map is undefined. +*/ + +/*! + \typedef QDBusIntrospection::Properties + Contains a QMap of properties and their names. Each property must have a unique name. +*/ + +/*! + \typedef QDBusIntrospection::Interfaces + Contains a QMap of interfaces and their names. Each interface has a unique name. +*/ + +/*! + \typedef QDBusIntrospection::Objects + Contains a QMap of objects and their paths relative to their immediate parent. + + \sa parseObjectTree() +*/ + +/*! + Parses the XML document fragment (given by \a xml) containing one interface. + + The first element tag in this XML data must be either \<node\> or \<interface\>. If it is + \<node\>, then the \<interface\> tag must be a child tag of the \<node\> one. + + If there are multiple interfaces in this XML data, it is undefined which one will be + returned. +*/ +QDBusIntrospection::Interface +QDBusIntrospection::parseInterface(const QString &xml) +{ + // be lazy + Interfaces ifs = parseInterfaces(xml); + if (ifs.isEmpty()) + return Interface(); + + // return the first in map order (probably alphabetical order) + return *ifs.constBegin().value(); +} + +/*! + Parses the XML document fragment (given by \a xml) containing several interfaces. + + If the first element tag in this document fragment is \<node\>, the interfaces parsed will + be those found as child elements of the \<node\> tag. +*/ +QDBusIntrospection::Interfaces +QDBusIntrospection::parseInterfaces(const QString &xml) +{ + QString null; + QDBusXmlParser parser(null, null, xml); + return parser.interfaces(); +} + +/*! + Parses the XML document fragment (given by \a xml) containing one object, found at the service + \a service and path \a path. + + The first element tag in this document must be \<node\>. If that tag does not contain + a name attribute, the \a path argument will be used to determine the path of this + object node. + + This function does not parse the interfaces contained in the node, nor sub-object's contents. + It will only list their names. If you need to know their contents, use parseObjectTree. +*/ +QDBusIntrospection::Object +QDBusIntrospection::parseObject(const QString &xml, const QString &service, const QString &path) +{ + QDBusXmlParser parser(service, path, xml); + QSharedDataPointer<QDBusIntrospection::Object> retval = parser.object(); + if (!retval) + return QDBusIntrospection::Object(); + return *retval; +} + +/*! + Parses the XML document fragment (given by \a xml) containing one object node and returns all + the information about the interfaces and sub-objects, found at the service \a service and path + \a path. + + The Objects map returned will contain the absolute path names in the key. +*/ +QDBusIntrospection::ObjectTree +QDBusIntrospection::parseObjectTree(const QString &xml, const QString &service, const QString &path) +{ + QDBusXmlParser parser(service, path, xml); + QSharedDataPointer<QDBusIntrospection::ObjectTree> retval = parser.objectTree(); + if (!retval) + return QDBusIntrospection::ObjectTree(); + return *retval; +} diff --git a/qt/src/qdbusintrospection_p.h b/qt/src/qdbusintrospection_p.h new file mode 100644 index 00000000..0e4e9015 --- /dev/null +++ b/qt/src/qdbusintrospection_p.h @@ -0,0 +1,147 @@ +/* -*- C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSINTROSPECTION_H +#define QDBUSINTROSPECTION_H + +#include <QtCore/qstring.h> +#include <QtCore/qlist.h> +#include <QtCore/qstringlist.h> +#include <QtCore/qmap.h> +#include <QtCore/qpair.h> +#include <QtCore/qshareddata.h> +#include "qdbusmacros.h" + +class QDBUS_EXPORT QDBusIntrospection +{ +public: + // forward declarations + struct Argument; + struct Method; + struct Signal; + struct Property; + struct Interface; + struct Object; + struct ObjectTree; + + // typedefs + typedef QMap<QString, QString> Annotations; + typedef QList<Argument> Arguments; + typedef QMultiMap<QString, Method> Methods; + typedef QMultiMap<QString, Signal> Signals; + typedef QMap<QString, Property> Properties; + typedef QMap<QString, QSharedDataPointer<Interface> > Interfaces; + typedef QMap<QString, QSharedDataPointer<ObjectTree> > Objects; + +public: + // the structs + + struct Argument + { + QString type; + QString name; + + inline bool operator==(const Argument& other) const + { return name == other.name && type == other.type; } + }; + + struct Method + { + QString name; + Arguments inputArgs; + Arguments outputArgs; + Annotations annotations; + + inline bool operator==(const Method& other) const + { return name == other.name && annotations == other.annotations && + inputArgs == other.inputArgs && outputArgs == other.outputArgs; } + }; + + struct Signal + { + QString name; + Arguments outputArgs; + Annotations annotations; + + inline bool operator==(const Signal& other) const + { return name == other.name && annotations == other.annotations && + outputArgs == other.outputArgs; } + }; + + struct Property + { + enum Access { Read, Write, ReadWrite }; + QString name; + QString type; + Access access; + Annotations annotations; + + inline bool operator==(const Property& other) const + { return access == other.access && name == other.name && + annotations == other.annotations && type == other.type; } + }; + + struct Interface: public QSharedData + { + QString name; + QString introspection; + + Annotations annotations; + Methods methods; + Signals signals_; + Properties properties; + + inline bool operator==(const Interface &other) const + { return !name.isEmpty() && name == other.name; } + }; + + struct Object: public QSharedData + { + QString service; + QString path; + QString introspection; + + QStringList interfaces; + QStringList childObjects; + }; + + struct ObjectTree: public Object + { + Interfaces interfaceData; + Objects childObjectData; + }; + +public: + static Interface parseInterface(const QString &xml); + static Interfaces parseInterfaces(const QString &xml); + static Object parseObject(const QString &xml, const QString &service = QString(), + const QString &path = QString()); + static ObjectTree parseObjectTree(const QString &xml, + const QString &service, + const QString &path); + +private: + QDBusIntrospection(); +}; + +#endif diff --git a/qt/src/qdbusmacros.h b/qt/src/qdbusmacros.h new file mode 100644 index 00000000..0af5b5b3 --- /dev/null +++ b/qt/src/qdbusmacros.h @@ -0,0 +1,60 @@ +/* qdbusmessage.h QDBusMessage object + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +/*! + \file qdbusmacros.h +*/ + +#ifndef QDBUSMACROS_H +#define QDBUSMACROS_H + +#include <QtCore/qglobal.h> +#include <QtCore/qmetatype.h> +#include <QtCore/qvariant.h> + +#ifdef QT_NO_MEMBER_TEMPLATES +# error Sorry, you need a compiler with support for template member functions to compile QtDBus. +#endif + +#if defined(QDBUS_MAKEDLL) +# define QDBUS_EXPORT Q_DECL_EXPORT +#else +# define QDBUS_EXPORT Q_DECL_IMPORT +#endif + +#ifndef Q_MOC_RUN +# define Q_ASYNC +#endif + +#ifdef Q_CC_MSVC +#include <QtCore/qlist.h> +#include <QtCore/qset.h> +#include <QtCore/qhash.h> +#include <QtCore/qvector.h> +class QDBusType; +inline uint qHash(const QVariant&) { Q_ASSERT(0); return 0; } +inline uint qHash(const QDBusType&) { Q_ASSERT(0); return 0; } +#endif + +#endif diff --git a/qt/src/qdbusmarshall.cpp b/qt/src/qdbusmarshall.cpp new file mode 100644 index 00000000..6209ffb3 --- /dev/null +++ b/qt/src/qdbusmarshall.cpp @@ -0,0 +1,554 @@ +/* qdbusmarshall.cpp + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusmarshall_p.h" +#include "qdbustype_p.h" +#include "qdbustypehelper_p.h" + +#include <qdebug.h> +#include <qvariant.h> +#include <qlist.h> +#include <qmap.h> +#include <qstringlist.h> +#include <qvarlengtharray.h> +#include <qvector.h> + +#include <dbus/dbus.h> + +static QVariant qFetchParameter(DBusMessageIter *it); + +template <typename T> +inline T qIterGet(DBusMessageIter *it) +{ + T t; + dbus_message_iter_get_basic(it, &t); + return t; +} + +template<> +inline QVariant qIterGet(DBusMessageIter *it) +{ + DBusMessageIter sub; + dbus_message_iter_recurse(it, &sub); + return QDBusTypeHelper<QVariant>::toVariant(qFetchParameter(&sub)); +} + +template <typename DBusType, typename QtType> +inline QVariant qFetchList(DBusMessageIter *arrayIt) +{ + QList<QtType> list; + + DBusMessageIter it; + dbus_message_iter_recurse(arrayIt, &it); + if (dbus_message_iter_get_array_len(&it) == 0) + return QDBusTypeHelper<QList<QtType> >::toVariant(list); + + do { + list.append( static_cast<QtType>( qIterGet<DBusType>(&it) ) ); + } while (dbus_message_iter_next(&it)); + + return QDBusTypeHelper<QList<QtType> >::toVariant(list); +} + +static QStringList qFetchStringList(DBusMessageIter *arrayIt) +{ + QStringList list; + + DBusMessageIter it; + dbus_message_iter_recurse(arrayIt, &it); + if (dbus_message_iter_get_array_len(&it) == 0) + return list; + + do { + list.append(QString::fromUtf8(qIterGet<char *>(&it))); + } while (dbus_message_iter_next(&it)); + + return list; +} + +static QVariant qFetchParameter(DBusMessageIter *it) +{ + switch (dbus_message_iter_get_arg_type(it)) { + case DBUS_TYPE_BYTE: + return qVariantFromValue(qIterGet<unsigned char>(it)); + case DBUS_TYPE_INT16: + return qVariantFromValue(qIterGet<dbus_int16_t>(it)); + case DBUS_TYPE_UINT16: + return qVariantFromValue(qIterGet<dbus_uint16_t>(it)); + case DBUS_TYPE_INT32: + return qIterGet<dbus_int32_t>(it); + case DBUS_TYPE_UINT32: + return qIterGet<dbus_uint32_t>(it); + case DBUS_TYPE_DOUBLE: + return qIterGet<double>(it); + case DBUS_TYPE_BOOLEAN: + return bool(qIterGet<dbus_bool_t>(it)); + case DBUS_TYPE_INT64: + return static_cast<qlonglong>(qIterGet<dbus_int64_t>(it)); + case DBUS_TYPE_UINT64: + return static_cast<qulonglong>(qIterGet<dbus_uint64_t>(it)); + case DBUS_TYPE_STRING: + case DBUS_TYPE_OBJECT_PATH: + case DBUS_TYPE_SIGNATURE: + return QString::fromUtf8(qIterGet<char *>(it)); + case DBUS_TYPE_VARIANT: + return qIterGet<QVariant>(it); + case DBUS_TYPE_ARRAY: { + int arrayType = dbus_message_iter_get_element_type(it); + switch (arrayType) + { + case DBUS_TYPE_BYTE: { + // QByteArray + DBusMessageIter sub; + dbus_message_iter_recurse(it, &sub); + int len = dbus_message_iter_get_array_len(&sub); + char* data; + dbus_message_iter_get_fixed_array(&sub,&data,&len); + return QByteArray(data,len); + } + case DBUS_TYPE_INT16: + return qFetchList<dbus_int16_t, short>(it); + case DBUS_TYPE_UINT16: + return qFetchList<dbus_uint16_t, ushort>(it); + case DBUS_TYPE_INT32: + return qFetchList<dbus_int32_t, int>(it); + case DBUS_TYPE_UINT32: + return qFetchList<dbus_uint32_t, uint>(it); + case DBUS_TYPE_BOOLEAN: + return qFetchList<dbus_bool_t, bool>(it); + case DBUS_TYPE_DOUBLE: + return qFetchList<double, double>(it); + case DBUS_TYPE_INT64: + return qFetchList<dbus_int64_t, qlonglong>(it); + case DBUS_TYPE_UINT64: + return qFetchList<dbus_uint64_t, qulonglong>(it); + case DBUS_TYPE_STRING: + case DBUS_TYPE_OBJECT_PATH: + case DBUS_TYPE_SIGNATURE: + return qFetchStringList(it); + case DBUS_TYPE_VARIANT: + return qFetchList<QVariant, QVariant>(it); + case DBUS_TYPE_DICT_ENTRY: { + // ### support other types of maps? + QMap<QString, QVariant> map; + DBusMessageIter sub; + + dbus_message_iter_recurse(it, &sub); + if (dbus_message_iter_get_array_len(&sub) == 0) + // empty map + return map; + + do { + DBusMessageIter itemIter; + dbus_message_iter_recurse(&sub, &itemIter); + Q_ASSERT(dbus_message_iter_has_next(&itemIter)); + QString key = qFetchParameter(&itemIter).toString(); + dbus_message_iter_next(&itemIter); + map.insertMulti(key, qFetchParameter(&itemIter)); + } while (dbus_message_iter_next(&sub)); + return map; + } + } + } + // fall through + // common handling for structs and lists of lists (for now) + case DBUS_TYPE_STRUCT: { + QList<QVariant> list; + DBusMessageIter sub; + dbus_message_iter_recurse(it, &sub); + if (dbus_message_iter_get_array_len(&sub) == 0) + return list; + do { + list.append(qFetchParameter(&sub)); + } while (dbus_message_iter_next(&sub)); + return list; + } + + default: + qWarning("Don't know how to handle type %d '%c'", dbus_message_iter_get_arg_type(it), dbus_message_iter_get_arg_type(it)); + return QVariant(); + break; + } +} + +void QDBusMarshall::messageToList(QList<QVariant> &list, DBusMessage *message) +{ + Q_ASSERT(message); + + DBusMessageIter it; + if (!dbus_message_iter_init(message, &it)) + return; + + do { + list.append(qFetchParameter(&it)); + } while (dbus_message_iter_next(&it)); +} + +// convert the variant to the given type and return true if it worked. +// if the type is not known, guess it from the variant and set. +// return false if conversion failed. +static bool checkType(QVariant &var, QDBusType &type) +{ + if (!type.isValid()) { + // guess it from the variant + type = QDBusType::guessFromVariant(var); + return true; + } + + int id = var.userType(); + + if (type.dbusType() == DBUS_TYPE_VARIANT) { + // this is a non symmetrical operation: + // nest a QVariant if we want variant and it isn't so + if (id != QDBusTypeHelper<QVariant>::id()) { + QVariant tmp = var; + var = QDBusTypeHelper<QVariant>::toVariant(tmp); + } + return true; + } + + switch (id) { + case QVariant::Bool: + case QMetaType::Short: + case QMetaType::UShort: + case QMetaType::UChar: + case QVariant::Int: + case QVariant::UInt: + case QVariant::LongLong: + case QVariant::ULongLong: + case QVariant::Double: + case QVariant::String: + if (type.isBasic()) + // QVariant can handle this on its own + return true; + + // cannot handle this + qWarning("Invalid conversion from %s to '%s'", var.typeName(), + type.dbusSignature().constData()); + var.clear(); + return false; + + case QVariant::ByteArray: + // make sure it's an "ARRAY of BYTE" + if (type.qvariantType() != QVariant::ByteArray) { + qWarning("Invalid conversion from %s to '%s'", var.typeName(), + type.dbusSignature().constData()); + var.clear(); + return false; + } + return true; + + case QVariant::StringList: + // make sure it's "ARRAY of STRING" + if (type.qvariantType() != QVariant::StringList) { + qWarning("Invalid conversion from %s to '%s'", var.typeName(), + type.dbusSignature().constData()); + var.clear(); + return false; + } + return true; + + case QVariant::List: + // could be either struct or array + if (type.dbusType() != DBUS_TYPE_ARRAY && type.dbusType() != DBUS_TYPE_STRUCT) { + qWarning("Invalid conversion from %s to '%s'", var.typeName(), + type.dbusSignature().constData()); + var.clear(); + return false; + } + + return true; + + case QVariant::Map: + if (!type.isMap()) { + qWarning("Invalid conversion from %s to '%s'", var.typeName(), + type.dbusSignature().constData()); + var.clear(); + return false; + } + + return true; + + case QVariant::Invalid: { + // create an empty variant + void *null = 0; + var = QVariant(type.qvariantType(), null); + break; + } + + default: + if (id == QDBusTypeHelper<QVariant>::id()) { + // if we got here, it means the match above for DBUS_TYPE_VARIANT didn't work + qWarning("Invalid conversion from nested variant to '%s'", + type.dbusSignature().constData()); + return false; + } else if (type.dbusType() == DBUS_TYPE_ARRAY) { + int subType = type.arrayElement().dbusType(); + if ((id == QDBusTypeHelper<bool>::listId() && subType == DBUS_TYPE_BOOLEAN) || + (id == QDBusTypeHelper<short>::listId() && subType == DBUS_TYPE_INT16) || + (id == QDBusTypeHelper<ushort>::listId() && subType == DBUS_TYPE_UINT16) || + (id == QDBusTypeHelper<int>::listId() && subType == DBUS_TYPE_INT32) || + (id == QDBusTypeHelper<uint>::listId() && subType == DBUS_TYPE_UINT32) || + (id == QDBusTypeHelper<qlonglong>::listId() && subType == DBUS_TYPE_INT64) || + (id == QDBusTypeHelper<qulonglong>::listId() && subType == DBUS_TYPE_UINT64) || + (id == QDBusTypeHelper<double>::listId() && subType == DBUS_TYPE_DOUBLE)) + return true; + } + + qWarning("Invalid conversion from %s to '%s'", var.typeName(), + type.dbusSignature().constData()); + return false; + } + + qWarning("Found unknown QVariant type %d (%s) when converting to DBus", (int)var.type(), + var.typeName()); + var.clear(); + return false; +} + +static void qVariantToIteratorInternal(DBusMessageIter *it, const QVariant &var, + const QDBusType &type); + +static void qListToIterator(DBusMessageIter *it, const QList<QVariant> &list, + const QDBusTypeList &typelist); + +template<typename T> +static void qIterAppend(DBusMessageIter *it, const QDBusType &type, T arg) +{ + dbus_message_iter_append_basic(it, type.dbusType(), &arg); +} + +template<typename DBusType, typename QtType> +static void qAppendListToMessage(DBusMessageIter *it, const QDBusType &subType, + const QVariant &var) +{ + QList<QtType> list = QDBusTypeHelper<QList<QtType> >::fromVariant(var); + foreach (const QtType &item, list) + qIterAppend(it, subType, static_cast<DBusType>(item)); +} + +static void qAppendArrayToMessage(DBusMessageIter *it, const QDBusType &subType, + const QVariant &var) +{ + DBusMessageIter sub; + dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, subType.dbusSignature(), &sub); + + switch (var.type()) + { + case QVariant::StringList: { + const QStringList list = var.toStringList(); + foreach (QString str, list) + qIterAppend(&sub, subType, str.toUtf8().constData()); + break; + } + + case QVariant::ByteArray: { + const QByteArray array = var.toByteArray(); + const char* cdata = array.constData(); + dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &cdata, array.length()); + break; + } + + case QVariant::Map: { + const QVariantMap map = var.toMap(); + const QDBusTypeList& subTypes = subType.subTypes(); + for (QMap<QString, QVariant>::const_iterator mit = map.constBegin(); + mit != map.constEnd(); ++mit) { + DBusMessageIter itemIterator; + dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, 0, &itemIterator); + + // let the string be converted to QVariant + qVariantToIteratorInternal(&itemIterator, mit.key(), subTypes[0]); + qVariantToIteratorInternal(&itemIterator, mit.value(), subTypes[1]); + + dbus_message_iter_close_container(&sub, &itemIterator); + } + break; + } + + case QVariant::List: { + const QVariantList list = var.toList(); + foreach (QVariant v, list) + qVariantToIteratorInternal(&sub, v, subType); + break; + } + + default: { + int id = var.userType(); + if (id == QDBusTypeHelper<bool>::listId()) + qAppendListToMessage<dbus_bool_t,bool>(&sub, subType, var); + else if (id == QDBusTypeHelper<short>::listId()) + qAppendListToMessage<dbus_int16_t,short>(&sub, subType, var); + else if (id == QDBusTypeHelper<ushort>::listId()) + qAppendListToMessage<dbus_uint16_t,ushort>(&sub, subType, var); + else if (id == QDBusTypeHelper<int>::listId()) + qAppendListToMessage<dbus_int32_t,int>(&sub, subType, var); + else if (id == QDBusTypeHelper<uint>::listId()) + qAppendListToMessage<dbus_uint32_t,uint>(&sub, subType, var); + else if (id == QDBusTypeHelper<qlonglong>::listId()) + qAppendListToMessage<dbus_int64_t,qlonglong>(&sub, subType, var); + else if (id == QDBusTypeHelper<qulonglong>::listId()) + qAppendListToMessage<dbus_uint64_t,qulonglong>(&sub, subType, var); + else if (id == QDBusTypeHelper<double>::listId()) + qAppendListToMessage<double,double>(&sub, subType, var); +#if 0 // never reached, since QVariant::List mached + else if (id == QDBusTypeHelper<QVariant>::listId()) + qAppendListToMessage<QVariant,QVariant>(&sub, subType, var); +#endif + else + qFatal("qAppendArrayToMessage got unknown type!"); + break; + } + } + + dbus_message_iter_close_container(it, &sub); +} + +static void qAppendStructToMessage(DBusMessageIter *it, const QDBusTypeList &typeList, + const QVariantList &list) +{ + DBusMessageIter sub; + dbus_message_iter_open_container(it, DBUS_TYPE_STRUCT, NULL, &sub); + qListToIterator(&sub, list, typeList); + dbus_message_iter_close_container(it, &sub); +} + +static void qAppendVariantToMessage(DBusMessageIter *it, const QDBusType &type, + const QVariant &var) +{ + Q_UNUSED(type); // type is 'v' + + QVariant arg = var; + if (var.userType() == QDBusTypeHelper<QVariant>::id()) + arg = QDBusTypeHelper<QVariant>::fromVariant(var); // extract the inner variant + + QDBusType t = QDBusType::guessFromVariant(arg); + + // now add this variant + DBusMessageIter sub; + dbus_message_iter_open_container(it, DBUS_TYPE_VARIANT, t.dbusSignature(), &sub); + qVariantToIteratorInternal(&sub, arg, t); + dbus_message_iter_close_container(it, &sub); +} + +static void qVariantToIterator(DBusMessageIter *it, QVariant var, QDBusType type) +{ + if (var.isNull() && !type.isValid()) + return; // cannot add a null like this + if (!checkType(var, type)) + return; // type checking failed + + qVariantToIteratorInternal(it, var, type); +} + +static void qVariantToIteratorInternal(DBusMessageIter *it, const QVariant &var, + const QDBusType &type) +{ + switch (type.dbusType()) { + case DBUS_TYPE_BYTE: + qIterAppend( it, type, QDBusTypeHelper<uchar>::fromVariant(var) ); + break; + case DBUS_TYPE_BOOLEAN: + qIterAppend( it, type, static_cast<dbus_bool_t>(var.toBool()) ); + break; + case DBUS_TYPE_INT16: + qIterAppend( it, type, QDBusTypeHelper<short>::fromVariant(var) ); + break; + case DBUS_TYPE_UINT16: + qIterAppend( it, type, QDBusTypeHelper<ushort>::fromVariant(var) ); + break; + case DBUS_TYPE_INT32: + qIterAppend( it, type, static_cast<dbus_int32_t>(var.toInt()) ); + break; + case DBUS_TYPE_UINT32: + qIterAppend( it, type, static_cast<dbus_uint32_t>(var.toUInt()) ); + break; + case DBUS_TYPE_INT64: + qIterAppend( it, type, static_cast<dbus_int64_t>(var.toLongLong()) ); + break; + case DBUS_TYPE_UINT64: + qIterAppend( it, type, static_cast<dbus_uint64_t>(var.toULongLong()) ); + break; + case DBUS_TYPE_DOUBLE: + qIterAppend( it, type, var.toDouble() ); + break; + case DBUS_TYPE_STRING: + case DBUS_TYPE_OBJECT_PATH: + case DBUS_TYPE_SIGNATURE: + qIterAppend( it, type, var.toString().toUtf8().constData() ); + break; + + // compound types: + case DBUS_TYPE_ARRAY: + // could be many things + qAppendArrayToMessage( it, type.arrayElement(), var ); + break; + + case DBUS_TYPE_VARIANT: + qAppendVariantToMessage( it, type, var ); + break; + + case DBUS_TYPE_STRUCT: + qAppendStructToMessage( it, type.subTypes(), var.toList() ); + break; + + case DBUS_TYPE_DICT_ENTRY: + qFatal("qVariantToIterator got a DICT_ENTRY!"); + break; + + default: + qWarning("Found unknown DBus type '%s'", type.dbusSignature().constData()); + break; + } +} + +void qListToIterator(DBusMessageIter *it, const QList<QVariant> &list) +{ + for (int i = 0; i < list.count(); ++i) + qVariantToIterator(it, list.at(i), QDBusType()); +} + +void qListToIterator(DBusMessageIter *it, const QList<QVariant> &list, const QDBusTypeList &types) +{ + int min = qMin(list.count(), types.count()); + for (int i = 0; i < min; ++i) + qVariantToIterator(it, list.at(i), types.at(i)); + + for (int i = min; i < types.count(); ++i) + // we're missing a few arguments, so add default parameters + qVariantToIterator(it, QVariant(), types.at(i)); +} + +void QDBusMarshall::listToMessage(const QList<QVariant> &list, DBusMessage *msg, + const QString &signature) +{ + Q_ASSERT(msg); + DBusMessageIter it; + dbus_message_iter_init_append(msg, &it); + + if (signature.isEmpty()) + qListToIterator(&it, list); + else + qListToIterator(&it, list, QDBusTypeList(signature.toUtf8())); +} diff --git a/qt/src/qdbusmarshall_p.h b/qt/src/qdbusmarshall_p.h new file mode 100644 index 00000000..7a2d46f5 --- /dev/null +++ b/qt/src/qdbusmarshall_p.h @@ -0,0 +1,57 @@ +/* qdbusmarshall_p.h QDBusMarshall object + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the public API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef QDBUSMARSHALLPRIVATE_H +#define QDBUSMARSHALLPRIVATE_H + +struct DBusMessage; + +template <typename T> class QList; +class QVariant; +class QString; + +/*! + \internal +*/ +class QDBusMarshall +{ +public: + static void listToMessage(const QList<QVariant> &list, DBusMessage *message, + const QString& signature); + static void messageToList(QList<QVariant> &list, DBusMessage *message); +}; + +#endif diff --git a/qt/src/qdbusmessage.cpp b/qt/src/qdbusmessage.cpp new file mode 100644 index 00000000..d0a0f1e5 --- /dev/null +++ b/qt/src/qdbusmessage.cpp @@ -0,0 +1,706 @@ +/* qdbusmessage.cpp + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusmessage.h" + +#include <qdebug.h> +#include <qstringlist.h> + +#include <dbus/dbus.h> + +#include "qdbuserror.h" +#include "qdbusmarshall_p.h" +#include "qdbusmessage_p.h" +#include "qdbustypehelper_p.h" + +QDBusMessagePrivate::QDBusMessagePrivate() + : connection(QString()), msg(0), reply(0), type(DBUS_MESSAGE_TYPE_INVALID), + timeout(-1), ref(1), repliedTo(false) +{ +} + +QDBusMessagePrivate::~QDBusMessagePrivate() +{ + if (msg) + dbus_message_unref(msg); + if (reply) + dbus_message_unref(reply); +} + +/////////////// +/*! + \class QDBusMessage + \brief Represents one message sent or received over the DBus bus. + + This object can represent any of four different types of messages possible on the bus + (see MessageType) + \list + \o Method calls + \o Method return values + \o Signal emissions + \o Error codes + \endlist + + Objects of this type are created with the four static functions signal, methodCall, + methodReply and error. +*/ + +/*! + \enum QDBusMessage::MessageType + The possible message types: + + \value MethodCallMessage a message representing an outgoing or incoming method call + \value SignalMessage a message representing an outgoing or incoming signal emission + \value ReplyMessage a message representing the return values of a method call + \value ErrorMessage a message representing an error condition in response to a method call + \value InvalidMessage an invalid message: this is never set on messages received from D-Bus +*/ + +/*! + Constructs a new DBus message representing a signal emission. A DBus signal is emitted + from one application and is received by all applications that are listening for that signal + from that interface. + + The signal will be constructed to represent a signal coming from the path \a path, interface \a + interface and signal name \a name. + + The QDBusMessage object that is returned can be sent with QDBusConnection::send(). +*/ +QDBusMessage QDBusMessage::signal(const QString &path, const QString &interface, + const QString &name) +{ + QDBusMessage message; + message.d_ptr->type = DBUS_MESSAGE_TYPE_SIGNAL; + message.d_ptr->path = path; + message.d_ptr->interface = interface; + message.d_ptr->name = name; + + return message; +} + +/*! + Constructs a new DBus message representing a method call. A method call always informs + its destination address (\a service, \a path, \a interface and \a method). + + The DBus bus allows calling a method on a given remote object without specifying the + destination interface, if the method name is unique. However, if two interfaces on the + remote object export the same method name, the result is undefined (one of the two may be + called or an error may be returned). + + When using DBus in a peer-to-peer context (i.e., not on a bus), the \a service parameter is + optional. + + The QDBusObject and QDBusInterface classes provide a simpler abstraction to synchronous + method calling. + + This function returns a QDBusMessage object that can be sent with QDBusConnection::send(), + QDBusConnection::sendWithReply(), or QDBusConnection::sendWithReplyAsync(). +*/ +QDBusMessage QDBusMessage::methodCall(const QString &service, const QString &path, + const QString &interface, const QString &method) +{ + QDBusMessage message; + message.d_ptr->type = DBUS_MESSAGE_TYPE_METHOD_CALL; + message.d_ptr->service = service; + message.d_ptr->path = path; + message.d_ptr->interface = interface; + message.d_ptr->name = method; + + return message; +} + +/*! + Constructs a new DBus message representing the return values from a called method. The \a other + variable represents the method call that the reply will be for. + + This function returns a QDBusMessage object that can be sent with QDBusConnection::send(). +*/ +QDBusMessage QDBusMessage::methodReply(const QDBusMessage &other) +{ + Q_ASSERT(other.d_ptr->msg); + + QDBusMessage message; + message.d_ptr->connection = other.d_ptr->connection; + message.d_ptr->type = DBUS_MESSAGE_TYPE_METHOD_RETURN; + message.d_ptr->reply = dbus_message_ref(other.d_ptr->msg); + other.d_ptr->repliedTo = true; + + return message; +} + +/*! + Constructs a DBus message representing an error condition described by the \a name + parameter. The \a msg parameter is optional and may contain a human-readable description of the + error. The \a other variable represents the method call that this error relates to. + + This function returns a QDBusMessage object that can be sent with QDBusMessage::send(). +*/ +QDBusMessage QDBusMessage::error(const QDBusMessage &other, const QString &name, + const QString &msg) +{ + Q_ASSERT(other.d_ptr->msg); + + QDBusMessage message; + message.d_ptr->connection = other.d_ptr->connection; + message.d_ptr->type = DBUS_MESSAGE_TYPE_ERROR; + message.d_ptr->name = name; + message.d_ptr->message = msg; + message.d_ptr->reply = dbus_message_ref(other.d_ptr->msg); + other.d_ptr->repliedTo = true; + + return message; +} + +/*! + \overload + Constructs a DBus message representing an error, where \a other is the method call that + generated this error and \a error is the error code. +*/ +QDBusMessage QDBusMessage::error(const QDBusMessage &other, const QDBusError &error) +{ + Q_ASSERT(other.d_ptr->msg); + + QDBusMessage message; + message.d_ptr->connection = other.d_ptr->connection; + message.d_ptr->type = DBUS_MESSAGE_TYPE_ERROR; + message.d_ptr->name = error.name(); + message.d_ptr->message = error.message(); + message.d_ptr->reply = dbus_message_ref(other.d_ptr->msg); + other.d_ptr->repliedTo = true; + + return message; +} + +/*! + Constructs an empty, invalid QDBusMessage object. + + \sa methodCall(), methodReply(), signal(), error() +*/ +QDBusMessage::QDBusMessage() +{ + d_ptr = new QDBusMessagePrivate; +} + +/*! + Constructs a copy of the object given by \a other. +*/ +QDBusMessage::QDBusMessage(const QDBusMessage &other) + : QList<QVariant>(other) +{ + d_ptr = other.d_ptr; + d_ptr->ref.ref(); +} + +/*! + Disposes of the object and frees any resources that were being held. +*/ +QDBusMessage::~QDBusMessage() +{ + if (!d_ptr->ref.deref()) + delete d_ptr; +} + +/*! + Copies the contents of the object given by \a other. +*/ +QDBusMessage &QDBusMessage::operator=(const QDBusMessage &other) +{ + QList<QVariant>::operator=(other); + qAtomicAssign(d_ptr, other.d_ptr); + return *this; +} + +static inline const char *data(const QByteArray &arr) +{ + return arr.isEmpty() ? 0 : arr.constData(); +} + +/*! + \internal + Constructs a DBusMessage object from this object. The returned value must be de-referenced + with dbus_message_unref. +*/ +DBusMessage *QDBusMessage::toDBusMessage() const +{ + DBusMessage *msg = 0; + + switch (d_ptr->type) { + case DBUS_MESSAGE_TYPE_METHOD_CALL: + msg = dbus_message_new_method_call(data(d_ptr->service.toUtf8()), data(d_ptr->path.toUtf8()), + data(d_ptr->interface.toUtf8()), data(d_ptr->name.toUtf8())); + break; + case DBUS_MESSAGE_TYPE_SIGNAL: + msg = dbus_message_new_signal(data(d_ptr->path.toUtf8()), data(d_ptr->interface.toUtf8()), + data(d_ptr->name.toUtf8())); + break; + case DBUS_MESSAGE_TYPE_METHOD_RETURN: + msg = dbus_message_new_method_return(d_ptr->reply); + break; + case DBUS_MESSAGE_TYPE_ERROR: + msg = dbus_message_new_error(d_ptr->reply, data(d_ptr->name.toUtf8()), data(d_ptr->message.toUtf8())); + break; + } + if (!msg) + return 0; + + QDBusMarshall::listToMessage(*this, msg, d_ptr->signature); + return msg; +} + +/*! + \internal + Constructs a QDBusMessage by parsing the given DBusMessage object. +*/ +QDBusMessage QDBusMessage::fromDBusMessage(DBusMessage *dmsg, const QDBusConnection &connection) +{ + QDBusMessage message; + if (!dmsg) + return message; + + message.d_ptr->connection = connection; + message.d_ptr->type = dbus_message_get_type(dmsg); + message.d_ptr->path = QString::fromUtf8(dbus_message_get_path(dmsg)); + message.d_ptr->interface = QString::fromUtf8(dbus_message_get_interface(dmsg)); + message.d_ptr->name = message.d_ptr->type == DBUS_MESSAGE_TYPE_ERROR ? + QString::fromUtf8(dbus_message_get_error_name(dmsg)) : + QString::fromUtf8(dbus_message_get_member(dmsg)); + message.d_ptr->service = QString::fromUtf8(dbus_message_get_sender(dmsg)); + message.d_ptr->signature = QString::fromUtf8(dbus_message_get_signature(dmsg)); + message.d_ptr->msg = dbus_message_ref(dmsg); + + QDBusMarshall::messageToList(message, dmsg); + return message; +} + +/*! + Creates a QDBusMessage that represents the same error as the QDBusError object. +*/ +QDBusMessage QDBusMessage::fromError(const QDBusError &error) +{ + QDBusMessage message; + message.d_ptr->type = DBUS_MESSAGE_TYPE_ERROR; + message.d_ptr->name = error.name(); + message << error.message(); + return message; +} + +/*! + Returns the path of the object that this message is being sent to (in the case of a + method call) or being received from (for a signal). +*/ +QString QDBusMessage::path() const +{ + return d_ptr->path; +} + +/*! + Returns the interface of the method being called (in the case of a method call) or of + the signal being received from. +*/ +QString QDBusMessage::interface() const +{ + return d_ptr->interface; +} + +/*! + Returns the name of the signal that was emitted or the name of the error that was + received. + \sa member() +*/ +QString QDBusMessage::name() const +{ + return d_ptr->name; +} + +/*! + \fn QDBusMessage::member() const + Returns the name of the method being called. +*/ + +/*! + \fn QDBusMessage::method() const + \overload + Returns the name of the method being called. +*/ + +/*! + Returns the name of the service or the bus address of the remote method call. +*/ +QString QDBusMessage::service() const +{ + return d_ptr->service; +} + +/*! + \fn QDBusMessage::sender() const + Returns the unique name of the remote sender. +*/ + +/*! + Returns the timeout (in milliseconds) for this message to be processed. +*/ +int QDBusMessage::timeout() const +{ + return d_ptr->timeout; +} + +/*! + Sets the timeout for this message to be processed, given by \a ms, in milliseconds. +*/ +void QDBusMessage::setTimeout(int ms) +{ + qAtomicDetach(d_ptr); + d_ptr->timeout = ms; +} + +/*! + Returns the flag that indicates if this message should see a reply or not. This is only + meaningful for MethodCall messages: any other kind of message cannot have replies and this + function will always return false for them. +*/ +bool QDBusMessage::noReply() const +{ + if (!d_ptr->msg) + return false; + return dbus_message_get_no_reply(d_ptr->msg); +} + +/*! + Returns the unique serial number assigned to this message + or 0 if the message was not sent yet. + */ +int QDBusMessage::serialNumber() const +{ + if (!d_ptr->msg) + return 0; + return dbus_message_get_serial(d_ptr->msg); +} + +/*! + Returns the unique serial number assigned to the message + that triggered this reply message. + + If this message is not a reply to another message, 0 + is returned. + + */ +int QDBusMessage::replySerialNumber() const +{ + if (!d_ptr->msg) + return 0; + return dbus_message_get_reply_serial(d_ptr->msg); +} + +/*! + Returns true if this is a MethodCall message and a reply for it has been generated using + QDBusMessage::methodReply or QDBusMessage::error. +*/ +bool QDBusMessage::wasRepliedTo() const +{ + return d_ptr->repliedTo; +} + +/*! + Returns the signature of the signal that was received or for the output arguments + of a method call. +*/ +QString QDBusMessage::signature() const +{ + return d_ptr->signature; +} + +/*! + Sets the signature for the output arguments of this method call to be the value of \a + signature. This function has no meaning in other types of messages or when dealing with received + method calls. + + A message's signature indicate the type of the parameters to + be marshalled over the bus. If there are more arguments than entries in the signature, the + tailing arguments will be silently dropped and not sent. If there are less arguments, + default values will be inserted (default values are those created by QVariant::convert + when a variant of type QVariant::Invalid is converted to the type). + +*/ +void QDBusMessage::setSignature(const QString &signature) +{ + qAtomicDetach(d_ptr); + d_ptr->signature = signature; +} + +/*! + Returns the connection this message was received on or an unconnected QDBusConnection object if + this isn't a message that has been received. +*/ +QDBusConnection QDBusMessage::connection() const +{ + return d_ptr->connection; +} + +/*! + Returns the message type. +*/ +QDBusMessage::MessageType QDBusMessage::type() const +{ + switch (d_ptr->type) { + case DBUS_MESSAGE_TYPE_METHOD_CALL: + return MethodCallMessage; + case DBUS_MESSAGE_TYPE_METHOD_RETURN: + return ReplyMessage; + case DBUS_MESSAGE_TYPE_ERROR: + return ErrorMessage; + case DBUS_MESSAGE_TYPE_SIGNAL: + return SignalMessage; + default: + return InvalidMessage; + } +} + +// Document QDBusReply here +/*! + \class QDBusReply + \brief The reply for a method call to a remote object. + + A QDBusReply object is a subset of the QDBusMessage object that represents a method call's + reply. It contains only the first output argument or the error code and is used by + QDBusInterface-derived classes to allow returning the error code as the function's return + argument. + + It can be used in the following manner: + \code + QDBusReply<QString> reply = interface->call("RemoteMethod"); + if (reply.isSuccess()) + // use the returned value + useValue(reply.value()); + else + // call failed. Show an error condition. + showError(reply.error()); + \endcode + + If the remote method call cannot fail, you can skip the error checking: + \code + QString reply = interface->call("RemoteMethod"); + \endcode + + However, if it does fail under those conditions, the value returned by QDBusReply::value() is + undefined. It may be undistinguishable from a valid return value. + + QDBusReply objects are used for remote calls that have no output arguments or return values + (i.e., they have a "void" return type). In this case, you can only test if the reply succeeded + or not, by calling isError() and isSuccess(), and inspecting the error condition by calling + error(). You cannot call value(). + + \sa QDBusMessage, QDBusInterface +*/ + +/*! + \fn QDBusReply::QDBusReply(const QDBusMessage &reply) + Automatically construct a QDBusReply object from the reply message \a reply, extracting the + first return value from it if it is a success reply. +*/ + +/*! + \fn QDBusReply::QDBusReply(const QDBusError &error) + Constructs an error reply from the D-Bus error code given by \a error. +*/ + +/*! + \fn QDBusReply::isError() const + Returns true if this reply is an error reply. You can extract the error contents using the + error() function. +*/ + +/*! + \fn QDBusReply::isSuccess() const + Returns true if this reply is a normal error reply (not an error). You can extract the returned + value with value() +*/ + +/*! + \fn QDBusReply::error() + Returns the error code that was returned from the remote function call. If the remote call did + not return an error (i.e., if it succeeded), then the QDBusError object that is returned will + not be a valid error code (QDBusError::isValid() will return false). +*/ + +/*! + \fn QDBusReply::value() + Returns the remote function's calls return value. If the remote call returned with an error, + the return value of this function is undefined and may be undistinguishable from a valid return + value. + + This function is not available if the remote call returns \c void. +*/ + +/*! + \fn QDBusReply::operator Type() + Returns the same as value(). + + This function is not available if the remote call returns \c void. +*/ + +/*! + \internal + \fn QDBusReply::fromVariant(const QDBusReply<QVariant> &variantReply) + Converts the QDBusReply<QVariant> object to this type by converting the variant contained in + \a variantReply to the template's type and copying the error condition. + + If the QVariant in variantReply is not convertible to this type, it will assume an undefined + value. +*/ + +#ifndef QT_NO_DEBUG +QDebug operator<<(QDebug dbg, QDBusMessage::MessageType t) +{ + switch (t) + { + case QDBusMessage::MethodCallMessage: + return dbg << "MethodCall"; + case QDBusMessage::ReplyMessage: + return dbg << "MethodReturn"; + case QDBusMessage::SignalMessage: + return dbg << "Signal"; + case QDBusMessage::ErrorMessage: + return dbg << "Error"; + default: + return dbg << "Invalid"; + } +} + +static void debugVariantList(QDebug dbg, const QVariantList &list); +static void debugVariantMap(QDebug dbg, const QVariantMap &map); + +static void debugVariant(QDebug dbg, const QVariant &v) +{ + dbg.nospace() << v.typeName() << "("; + switch (v.userType()) + { + case QVariant::Bool: + dbg.nospace() << v.toBool(); + break; + case QMetaType::UChar: + dbg.nospace() << qvariant_cast<uchar>(v); + break; + case QMetaType::Short: + dbg.nospace() << qvariant_cast<short>(v); + break; + case QMetaType::UShort: + dbg.nospace() << qvariant_cast<ushort>(v); + break; + case QVariant::Int: + dbg.nospace() << v.toInt(); + break; + case QVariant::UInt: + dbg.nospace() << v.toUInt(); + break; + case QVariant::LongLong: + dbg.nospace() << v.toLongLong(); + break; + case QVariant::ULongLong: + dbg.nospace() << v.toULongLong(); + break; + case QVariant::Double: + dbg.nospace() << v.toDouble(); + break; + case QVariant::String: + dbg.nospace() << v.toString(); + break; + case QVariant::ByteArray: + dbg.nospace() << v.toByteArray(); + break; + case QVariant::StringList: + dbg.nospace() << v.toStringList(); + break; + case QVariant::List: + debugVariantList(dbg, v.toList()); + break; + case QVariant::Map: + debugVariantMap(dbg, v.toMap()); + break; + + default: { + int id = v.userType(); + if (id == QDBusTypeHelper<QVariant>::id()) + debugVariant(dbg, QDBusTypeHelper<QVariant>::fromVariant(v)); + else if (id == QDBusTypeHelper<bool>::listId()) + dbg.nospace() << QDBusTypeHelper<QList<bool> >::fromVariant(v); + else if (id == QDBusTypeHelper<short>::listId()) + dbg.nospace() << QDBusTypeHelper<QList<short> >::fromVariant(v); + else if (id == QDBusTypeHelper<ushort>::listId()) + dbg.nospace() << QDBusTypeHelper<QList<ushort> >::fromVariant(v); + else if (id == QDBusTypeHelper<int>::listId()) + dbg.nospace() << QDBusTypeHelper<QList<int> >::fromVariant(v); + else if (id == QDBusTypeHelper<uint>::listId()) + dbg.nospace() << QDBusTypeHelper<QList<uint> >::fromVariant(v); + else if (id == QDBusTypeHelper<qlonglong>::listId()) + dbg.nospace() << QDBusTypeHelper<QList<qlonglong> >::fromVariant(v); + else if (id == QDBusTypeHelper<qulonglong>::listId()) + dbg.nospace() << QDBusTypeHelper<QList<qulonglong> >::fromVariant(v); + else if (id == QDBusTypeHelper<double>::listId()) + dbg.nospace() << QDBusTypeHelper<QList<double> >::fromVariant(v); + else + dbg.nospace() << "unknown"; + } + } + dbg.nospace() << ")"; +} + +static void debugVariantList(QDebug dbg, const QVariantList &list) +{ + bool first = true; + QVariantList::ConstIterator it = list.constBegin(); + QVariantList::ConstIterator end = list.constEnd(); + for ( ; it != end; ++it) { + if (!first) + dbg.nospace() << ", "; + debugVariant(dbg, *it); + first = false; + } +} + +static void debugVariantMap(QDebug dbg, const QVariantMap &map) +{ + QVariantMap::ConstIterator it = map.constBegin(); + QVariantMap::ConstIterator end = map.constEnd(); + for ( ; it != end; ++it) { + dbg << "(" << it.key() << ", "; + debugVariant(dbg, it.value()); + dbg << ") "; + } +} + +QDebug operator<<(QDebug dbg, const QDBusMessage &msg) +{ + dbg.nospace() << "QDBusMessage(type=" << msg.type() + << ", service=" << msg.service() + << ", path=" << msg.path() + << ", interface=" << msg.interface() + << ", name=" << msg.name() + << ", signature=" << msg.signature() + << ", contents=("; + debugVariantList(dbg, msg); + dbg.nospace() << " ) )"; + return dbg.space(); +} +#endif + diff --git a/qt/src/qdbusmessage.h b/qt/src/qdbusmessage.h new file mode 100644 index 00000000..f8feeae4 --- /dev/null +++ b/qt/src/qdbusmessage.h @@ -0,0 +1,99 @@ +/* qdbusmessage.h QDBusMessage object + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSMESSAGE_H +#define QDBUSMESSAGE_H + +#include "qdbusmacros.h" +#include "qdbuserror.h" +#include <QtCore/qlist.h> +#include <QtCore/qvariant.h> + +#include <limits.h> + +class QDBusMessagePrivate; +class QDBusConnection; +class QDBusConnectionPrivate; +struct DBusMessage; + +class QDBUS_EXPORT QDBusMessage: public QList<QVariant> +{ + //friend class QDBusConnection; + friend class QDBusConnectionPrivate; +public: + enum { DefaultTimeout = -1, NoTimeout = INT_MAX}; + enum MessageType { InvalidMessage, MethodCallMessage, ReplyMessage, + ErrorMessage, SignalMessage }; + + QDBusMessage(); + QDBusMessage(const QDBusMessage &other); + ~QDBusMessage(); + + QDBusMessage &operator=(const QDBusMessage &other); + + static QDBusMessage signal(const QString &path, const QString &interface, + const QString &name); + static QDBusMessage methodCall(const QString &destination, const QString &path, + const QString &interface, const QString &method); + static QDBusMessage methodReply(const QDBusMessage &other); + static QDBusMessage error(const QDBusMessage &other, const QString &name, + const QString &message = QString()); + static QDBusMessage error(const QDBusMessage &other, const QDBusError &error); + + QString path() const; + QString interface() const; + QString name() const; + inline QString member() const { return name(); } + inline QString method() const { return name(); } + QString service() const; + inline QString sender() const { return service(); } + MessageType type() const; + + int timeout() const; + void setTimeout(int ms); + + bool noReply() const; + + QString signature() const; + void setSignature(const QString &signature); + + QDBusConnection connection() const; + + int serialNumber() const; + int replySerialNumber() const; + bool wasRepliedTo() const; + +private: + DBusMessage *toDBusMessage() const; + static QDBusMessage fromDBusMessage(DBusMessage *dmsg, const QDBusConnection &connection); + static QDBusMessage fromError(const QDBusError& error); + QDBusMessagePrivate *d_ptr; +}; + +#ifndef QT_NO_DEBUG +QDebug operator<<(QDebug, const QDBusMessage &); +#endif + +#endif + diff --git a/qt/src/qdbusmessage_p.h b/qt/src/qdbusmessage_p.h new file mode 100644 index 00000000..ea958b24 --- /dev/null +++ b/qt/src/qdbusmessage_p.h @@ -0,0 +1,50 @@ +/* qdbusmessage.h QDBusMessage private object + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSMESSAGE_P_H +#define QDBUSMESSAGE_P_H + +#include <qatomic.h> +#include <qstring.h> +#include "qdbusconnection.h" +struct DBusMessage; + +class QDBusMessagePrivate +{ +public: + QDBusMessagePrivate(); + ~QDBusMessagePrivate(); + + QString service, path, interface, name, message, signature; + QDBusConnection connection; + DBusMessage *msg; + DBusMessage *reply; + int type; + int timeout; + QAtomic ref; + + mutable bool repliedTo : 1; +}; + +#endif diff --git a/qt/src/qdbusmetaobject.cpp b/qt/src/qdbusmetaobject.cpp new file mode 100644 index 00000000..a923d79a --- /dev/null +++ b/qt/src/qdbusmetaobject.cpp @@ -0,0 +1,689 @@ +/* -*- C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusmetaobject_p.h" + +#include <QtCore/qbytearray.h> +#include <QtCore/qhash.h> +#include <QtCore/qstring.h> +#include <QtCore/qvarlengtharray.h> + +#include "qdbusutil.h" +#include "qdbuserror.h" +#include "qdbusintrospection_p.h" +#include "qdbusabstractinterface_p.h" + +class QDBusMetaObjectGenerator +{ +public: + QDBusMetaObjectGenerator(const QString &interface, + const QDBusIntrospection::Interface *parsedData); + void write(QDBusMetaObject *obj); + void writeWithoutXml(QDBusMetaObject *obj); + +private: + struct Method { + QByteArray parameters; + QByteArray typeName; + QByteArray tag; + QByteArray inputSignature; + QByteArray outputSignature; + QVarLengthArray<int, 4> inputTypes; + QVarLengthArray<int, 4> outputTypes; + int flags; + }; + + struct Property { + QByteArray typeName; + QByteArray signature; + int type; + int flags; + }; + + enum PropertyFlags { + Invalid = 0x00000000, + Readable = 0x00000001, + Writable = 0x00000002, + Resettable = 0x00000004, + EnumOrFlag = 0x00000008, + StdCppSet = 0x00000100, + // Override = 0x00000200, + Designable = 0x00001000, + ResolveDesignable = 0x00002000, + Scriptable = 0x00004000, + ResolveScriptable = 0x00008000, + Stored = 0x00010000, + ResolveStored = 0x00020000, + Editable = 0x00040000, + ResolveEditable = 0x00080000, + User = 0x00100000, + ResolveUser = 0x00200000 + }; + + enum MethodFlags { + AccessPrivate = 0x00, + AccessProtected = 0x01, + AccessPublic = 0x02, + AccessMask = 0x03, //mask + + MethodMethod = 0x00, + MethodSignal = 0x04, + MethodSlot = 0x08, + MethodTypeMask = 0x0c, + + MethodCompatibility = 0x10, + MethodCloned = 0x20, + MethodScriptable = 0x40 + }; + + QMap<QByteArray, Method> methods; + QMap<QByteArray, Property> properties; + + const QDBusIntrospection::Interface *data; + QString interface; + + void parseMethods(); + void parseSignals(); + void parseProperties(); +}; + +static const int intsPerProperty = 2; +static const int intsPerMethod = 4; + +// ### from kernel/qmetaobject.cpp (Qt 4.1.2): +struct QDBusMetaObjectPrivate +{ + int revision; + int className; + int classInfoCount, classInfoData; + int methodCount, methodData; + int propertyCount, propertyData; + int enumeratorCount, enumeratorData; + + // this is specific for QDBusMetaObject: + int propertyDBusData; + int methodDBusData; +}; + +QDBusMetaObjectGenerator::QDBusMetaObjectGenerator(const QString &interfaceName, + const QDBusIntrospection::Interface *parsedData) + : data(parsedData), interface(interfaceName) +{ + if (data) { + parseProperties(); + parseSignals(); // call parseSignals first so that slots override signals + parseMethods(); + } +} + +void QDBusMetaObjectGenerator::parseMethods() +{ + foreach (const QDBusIntrospection::Method &m, data->methods) { + Method mm; + + QByteArray prototype = m.name.toLatin1(); + prototype += '('; + + bool ok = true; + + // build the input argument list + foreach (const QDBusIntrospection::Argument &arg, m.inputArgs) { + int typeId = QDBusUtil::signatureToType(arg.type); + if (typeId == QVariant::Invalid) { + ok = false; + break; + } + + mm.inputSignature += arg.type; + mm.inputTypes.append(typeId); + + mm.parameters.append(arg.name.toLatin1()); + mm.parameters.append(','); + + prototype.append( QVariant::typeToName( QVariant::Type(typeId) ) ); + prototype.append(','); + } + if (!ok) continue; + + // build the output argument list: + for (int i = 0; i < m.outputArgs.count(); ++i) { + const QDBusIntrospection::Argument &arg = m.outputArgs.at(i); + + int typeId = QDBusUtil::signatureToType(arg.type); + if (typeId == QVariant::Invalid) { + ok = false; + break; + } + + mm.outputSignature += arg.type; + mm.outputTypes.append(typeId); + + if (i == 0) { + // return value + mm.typeName = QVariant::typeToName( QVariant::Type(typeId) ); + } else { + // non-const ref parameter + mm.parameters.append(arg.name.toLatin1()); + mm.parameters.append(','); + + prototype.append( QVariant::typeToName( QVariant::Type(typeId) ) ); + prototype.append("&,"); + } + } + if (!ok) continue; + + // convert the last commas: + if (!mm.parameters.isEmpty()) { + mm.parameters.truncate(mm.parameters.length() - 1); + prototype[prototype.length() - 1] = ')'; + } else { + prototype.append(')'); + } + + // check the async tag + if (m.annotations.value(QLatin1String(ANNOTATION_NO_WAIT)) == QLatin1String("true")) + mm.tag = "Q_ASYNC"; + + // meta method flags + mm.flags = AccessPublic | MethodSlot | MethodScriptable; + + // add + methods.insert(QMetaObject::normalizedSignature(prototype), mm); + } +} + +void QDBusMetaObjectGenerator::parseSignals() +{ + foreach (const QDBusIntrospection::Signal &s, data->signals_) { + Method mm; + + QByteArray prototype = s.name.toLatin1(); + prototype += '('; + + bool ok = true; + + // build the output argument list + foreach (const QDBusIntrospection::Argument &arg, s.outputArgs) { + int typeId = QDBusUtil::signatureToType(arg.type); + if (typeId == QVariant::Invalid) { + ok = false; + break; + } + + mm.inputSignature += arg.type; + mm.inputTypes.append(typeId); + + mm.parameters.append(arg.name.toLatin1()); + mm.parameters.append(','); + + prototype.append( QVariant::typeToName( QVariant::Type(typeId) ) ); + prototype.append(','); + } + if (!ok) continue; + + // convert the last commas: + if (!mm.parameters.isEmpty()) { + mm.parameters.truncate(mm.parameters.length() - 1); + prototype[prototype.length() - 1] = ')'; + } else { + prototype.append(')'); + } + + // meta method flags + mm.flags = AccessProtected | MethodSignal | MethodScriptable; + + // add + methods.insert(QMetaObject::normalizedSignature(prototype), mm); + } +} + +void QDBusMetaObjectGenerator::parseProperties() +{ + foreach (const QDBusIntrospection::Property &p, data->properties) { + Property mp; + mp.type = QDBusUtil::signatureToType(p.type); + if (mp.type == QVariant::Invalid) + continue; + + QByteArray name = p.name.toLatin1(); + mp.signature = p.type.toLatin1(); + mp.typeName = QVariant::typeToName( QVariant::Type(mp.type) ); + + // build the flags: + mp.flags = StdCppSet | Scriptable | Stored; + if (p.access != QDBusIntrospection::Property::Write) + mp.flags |= Readable; + if (p.access != QDBusIntrospection::Property::Read) + mp.flags |= Writable; + + if (mp.typeName == "QVariant") + mp.flags |= 0xff << 24; + else if (mp.type < 0xff) + // encode the type in the flags + mp.flags |= mp.type << 24; + + // add the property: + properties.insert(name, mp); + } +} + +void QDBusMetaObjectGenerator::write(QDBusMetaObject *obj) +{ + // this code here is mostly copied from qaxbase.cpp + // with a few modifications to make it cleaner + + QString className = interface; + className.replace(QLatin1Char('.'), QLatin1String("::")); + if (className.isEmpty()) + className = QLatin1String("QDBusInterface"); + + QVarLengthArray<int> data; + data.resize(sizeof(QDBusMetaObjectPrivate) / sizeof(int)); + + QDBusMetaObjectPrivate *header = reinterpret_cast<QDBusMetaObjectPrivate *>(data.data()); + header->revision = 1; + header->className = 0; + header->classInfoCount = 0; + header->classInfoData = 0; + header->methodCount = methods.count(); + header->methodData = data.size(); + header->propertyCount = properties.count(); + header->propertyData = header->methodData + header->methodCount * 5; + header->enumeratorCount = 0; + header->enumeratorData = 0; + header->propertyDBusData = header->propertyData + header->propertyCount * 3; + header->methodDBusData = header->propertyDBusData + header->propertyCount * intsPerProperty; + + int data_size = data.size() + + (header->methodCount * (5+intsPerMethod)) + + (header->propertyCount * (3+intsPerProperty)); + foreach (const Method &mm, methods) + data_size += 2 + mm.inputTypes.count() + mm.outputTypes.count(); + data.resize(data_size + 1); + + char null('\0'); + QByteArray stringdata = className.toLatin1(); + stringdata += null; + stringdata.reserve(8192); + + int offset = header->methodData; + int signatureOffset = header->methodDBusData; + int typeidOffset = header->methodDBusData + header->methodCount * intsPerMethod; + data[typeidOffset++] = 0; // eod + + // add each method: + for (QMap<QByteArray, Method>::ConstIterator it = methods.constBegin(); + it != methods.constEnd(); ++it) { + // form "prototype\0parameters\0typeName\0tag\0inputSignature\0outputSignature" + const Method &mm = it.value(); + + data[offset++] = stringdata.length(); + stringdata += it.key(); // prototype + stringdata += null; + data[offset++] = stringdata.length(); + stringdata += mm.parameters; + stringdata += null; + data[offset++] = stringdata.length(); + stringdata += mm.typeName; + stringdata += null; + data[offset++] = stringdata.length(); + stringdata += mm.tag; + stringdata += null; + data[offset++] = mm.flags; + + data[signatureOffset++] = stringdata.length(); + stringdata += mm.inputSignature; + stringdata += null; + data[signatureOffset++] = stringdata.length(); + stringdata += mm.outputSignature; + stringdata += null; + + data[signatureOffset++] = typeidOffset; + data[typeidOffset++] = mm.inputTypes.count(); + memcpy(data.data() + typeidOffset, mm.inputTypes.data(), mm.inputTypes.count() * sizeof(int)); + typeidOffset += mm.inputTypes.count(); + + data[signatureOffset++] = typeidOffset; + data[typeidOffset++] = mm.outputTypes.count(); + memcpy(data.data() + typeidOffset, mm.outputTypes.data(), mm.outputTypes.count() * sizeof(int)); + typeidOffset += mm.outputTypes.count(); + } + + Q_ASSERT(offset == header->propertyData); + Q_ASSERT(signatureOffset == header->methodDBusData + header->methodCount * intsPerMethod); + Q_ASSERT(typeidOffset == data.size()); + + // add each property + signatureOffset = header->propertyDBusData; + for (QMap<QByteArray, Property>::ConstIterator it = properties.constBegin(); + it != properties.constEnd(); ++it) { + const Property &mp = it.value(); + + // form is "name\0typeName\0signature\0" + data[offset++] = stringdata.length(); + stringdata += it.key(); // name + stringdata += null; + data[offset++] = stringdata.length(); + stringdata += mp.typeName; + stringdata += null; + data[offset++] = mp.flags; + + data[signatureOffset++] = stringdata.length(); + stringdata += mp.signature; + stringdata += null; + data[signatureOffset++] = mp.type; + } + + Q_ASSERT(offset == header->propertyDBusData); + Q_ASSERT(signatureOffset == header->methodDBusData); + + char *string_data = new char[stringdata.length()]; + memcpy(string_data, stringdata, stringdata.length()); + + uint *uint_data = new uint[data.size()]; + memcpy(uint_data, data.data(), data.size() * sizeof(int)); + + // put the metaobject together + obj->d.data = uint_data; + obj->d.extradata = 0; + obj->d.stringdata = string_data; + obj->d.superdata = &QDBusAbstractInterface::staticMetaObject; +} + +#if 0 +void QDBusMetaObjectGenerator::writeWithoutXml(const QString &interface) +{ + // no XML definition + QString tmp(interface); + tmp.replace(QLatin1Char('.'), QLatin1String("::")); + QByteArray name(tmp.toLatin1()); + + QDBusMetaObjectPrivate *header = new QDBusMetaObjectPrivate; + memset(header, 0, sizeof *header); + header->revision = 1; + // leave the rest with 0 + + char *stringdata = new char[name.length() + 1]; + stringdata[name.length()] = '\0'; + + d.data = reinterpret_cast<uint*>(header); + d.extradata = 0; + d.stringdata = stringdata; + d.superdata = &QDBusAbstractInterface::staticMetaObject; + cached = false; +} +#endif + +///////// +// class QDBusMetaObject + +QDBusMetaObject *QDBusMetaObject::createMetaObject(const QString &interface, const QString &xml, + QHash<QString, QDBusMetaObject *> &cache, + QDBusError &error) +{ + error = QDBusError(); + QDBusIntrospection::Interfaces parsed = QDBusIntrospection::parseInterfaces(xml); + + QDBusMetaObject *we = 0; + QDBusIntrospection::Interfaces::ConstIterator it = parsed.constBegin(); + QDBusIntrospection::Interfaces::ConstIterator end = parsed.constEnd(); + for ( ; it != end; ++it) { + // check if it's in the cache + QDBusMetaObject *obj = cache.value(it.key(), 0); + if (!obj) { + // not in cache; create + obj = new QDBusMetaObject; + QDBusMetaObjectGenerator generator(it.key(), it.value().constData()); + generator.write(obj); + + if ( (obj->cached = !it.key().startsWith( QLatin1String("local.") )) ) + // cache it + cache.insert(it.key(), obj); + + } + + if (it.key() == interface) + // it's us + we = obj; + } + + if (we) + return we; + // still nothing? + + if (parsed.isEmpty()) { + // object didn't return introspection + we = new QDBusMetaObject; + QDBusMetaObjectGenerator generator(interface, 0); + generator.write(we); + we->cached = false; + return we; + } else if (interface.isEmpty()) { + // merge all interfaces + it = parsed.constBegin(); + QDBusIntrospection::Interface merged = *it.value().constData(); + + for (++it; it != end; ++it) { + merged.annotations.unite(it.value()->annotations); + merged.methods.unite(it.value()->methods); + merged.signals_.unite(it.value()->signals_); + merged.properties.unite(it.value()->properties); + } + + merged.name = QLatin1String("local.Merged"); + merged.introspection.clear(); + + we = new QDBusMetaObject; + QDBusMetaObjectGenerator generator(merged.name, &merged); + generator.write(we); + we->cached = false; + return we; + } + + // mark as an error + error = QDBusError(QDBusError::UnknownInterface, + QString( QLatin1String("Interface '%1' was not found") ) + .arg(interface)); + return 0; +} + +QDBusMetaObject::QDBusMetaObject() +{ +} + +inline const QDBusMetaObjectPrivate *priv(const uint* data) +{ + return reinterpret_cast<const QDBusMetaObjectPrivate *>(data); +} + +const char *QDBusMetaObject::dbusNameForMethod(int id) const +{ + //id -= methodOffset(); + if (id >= 0 && id < priv(d.data)->methodCount) { + int handle = priv(d.data)->methodDBusData + id*intsPerMethod; + return d.stringdata + d.data[handle]; + } + return 0; +} + +const char *QDBusMetaObject::inputSignatureForMethod(int id) const +{ + //id -= methodOffset(); + if (id >= 0 && id < priv(d.data)->methodCount) { + int handle = priv(d.data)->methodDBusData + id*intsPerMethod; + return d.stringdata + d.data[handle + 1]; + } + return 0; +} + +const char *QDBusMetaObject::outputSignatureForMethod(int id) const +{ + //id -= methodOffset(); + if (id >= 0 && id < priv(d.data)->methodCount) { + int handle = priv(d.data)->methodDBusData + id*intsPerMethod; + return d.stringdata + d.data[handle + 2]; + } + return 0; +} + +const int *QDBusMetaObject::inputTypesForMethod(int id) const +{ + //id -= methodOffset(); + if (id >= 0 && id < priv(d.data)->methodCount) { + int handle = priv(d.data)->methodDBusData + id*intsPerMethod; + return reinterpret_cast<const int*>(d.data + d.data[handle + 3]); + } + return 0; +} + +const int *QDBusMetaObject::outputTypesForMethod(int id) const +{ + //id -= methodOffset(); + if (id >= 0 && id < priv(d.data)->methodCount) { + int handle = priv(d.data)->methodDBusData + id*intsPerMethod; + return reinterpret_cast<const int*>(d.data + d.data[handle + 4]); + } + return 0; +} + +int QDBusMetaObject::propertyMetaType(int id) const +{ + //id -= propertyOffset(); + if (id >= 0 && id < priv(d.data)->propertyCount) { + int handle = priv(d.data)->propertyDBusData + id*intsPerProperty; + return d.data[handle + 1]; + } + return 0; +} + +template<typename T> +static inline void assign_helper(void *ptr, const QVariant &value) +{ + *reinterpret_cast<T *>(ptr) = qvariant_cast<T>(value); +} + +void QDBusMetaObject::assign(void *ptr, const QVariant &value) +{ + switch (value.userType()) + { + case QVariant::Bool: + assign_helper<bool>(ptr, value); + return; + + case QMetaType::UChar: + assign_helper<uchar>(ptr, value); + return; + + case QMetaType::Short: + assign_helper<short>(ptr, value); + return; + + case QMetaType::UShort: + assign_helper<ushort>(ptr, value); + return; + + case QVariant::Int: + assign_helper<int>(ptr, value); + return; + + case QVariant::UInt: + assign_helper<uint>(ptr, value); + return; + + case QVariant::LongLong: + assign_helper<qlonglong>(ptr, value); + return; + + case QVariant::ULongLong: + assign_helper<qulonglong>(ptr, value); + return; + + case QVariant::Double: + assign_helper<double>(ptr, value); + return; + + case QVariant::String: + assign_helper<QString>(ptr, value); + return; + + case QVariant::ByteArray: + assign_helper<QByteArray>(ptr, value); + return; + + case QVariant::List: + assign_helper<QVariantList>(ptr, value); + return; + + case QVariant::Map: + assign_helper<QVariantMap>(ptr, value); + return; + + default: + ; + } +} + +bool QDBusMetaTypeId::initialized = false; +int QDBusMetaTypeId::variant = 0; +int QDBusMetaTypeId::boollist = 0; +int QDBusMetaTypeId::shortlist = 0; +int QDBusMetaTypeId::ushortlist = 0; +int QDBusMetaTypeId::intlist = 0; +int QDBusMetaTypeId::uintlist = 0; +int QDBusMetaTypeId::longlonglist = 0; +int QDBusMetaTypeId::ulonglonglist = 0; +int QDBusMetaTypeId::doublelist = 0; + +bool QDBusMetaTypeId::innerInitialize() +{ + variant = qRegisterMetaType<QVariant>("QVariant"); + boollist = qRegisterMetaType<QList<bool> >("QList<bool>"); + shortlist = qRegisterMetaType<QList<short> >("QList<short>"); + ushortlist = qRegisterMetaType<QList<ushort> >("QList<ushort>"); + intlist = qRegisterMetaType<QList<int> >("QList<int>"); + uintlist = qRegisterMetaType<QList<uint> >("QList<uint>"); + longlonglist = qRegisterMetaType<QList<qlonglong> >("QList<qlonglong>"); + ulonglonglist = qRegisterMetaType<QList<qulonglong> >("QList<qulonglong>"); + doublelist = qRegisterMetaType<QList<double> >("QList<double>"); + initialized = true; + return true; +} + +int qDBusMetaTypeId(QVariant *) +{ QDBusMetaTypeId::initialize(); return QDBusMetaTypeId::variant; } +int qDBusMetaTypeId(QList<bool> *) +{ QDBusMetaTypeId::initialize(); return QDBusMetaTypeId::boollist; } +int qDBusMetaTypeId(QList<short> *) +{ QDBusMetaTypeId::initialize(); return QDBusMetaTypeId::shortlist; } +int qDBusMetaTypeId(QList<ushort> *) +{ QDBusMetaTypeId::initialize(); return QDBusMetaTypeId::ushortlist; } +int qDBusMetaTypeId(QList<int> *) +{ QDBusMetaTypeId::initialize(); return QDBusMetaTypeId::intlist; } +int qDBusMetaTypeId(QList<uint> *) +{ QDBusMetaTypeId::initialize(); return QDBusMetaTypeId::uintlist; } +int qDBusMetaTypeId(QList<qlonglong> *) +{ QDBusMetaTypeId::initialize(); return QDBusMetaTypeId::longlonglist; } +int qDBusMetaTypeId(QList<qulonglong> *) +{ QDBusMetaTypeId::initialize(); return QDBusMetaTypeId::ulonglonglist; } +int qDBusMetaTypeId(QList<double> *) +{ QDBusMetaTypeId::initialize(); return QDBusMetaTypeId::doublelist; } diff --git a/qt/src/qdbusmetaobject_p.h b/qt/src/qdbusmetaobject_p.h new file mode 100644 index 00000000..746240d1 --- /dev/null +++ b/qt/src/qdbusmetaobject_p.h @@ -0,0 +1,96 @@ +/* + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the public API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef QDBUSMETAOBJECTPRIVATE_H +#define QDBUSMETAOBJECTPRIVATE_H + +#include <QtCore/qmetaobject.h> +#include "qdbusmacros.h" + +class QDBusError; + +struct QDBusMetaObjectPrivate; +struct QDBUS_EXPORT QDBusMetaObject: public QMetaObject +{ + bool cached; + + static QDBusMetaObject *createMetaObject(const QString &interface, const QString &xml, + QHash<QString, QDBusMetaObject *> &map, + QDBusError &error); + ~QDBusMetaObject() + { + delete [] d.stringdata; + delete [] d.data; + } + + // methods (slots & signals): + const char *dbusNameForMethod(int id) const; + const char *inputSignatureForMethod(int id) const; + const char *outputSignatureForMethod(int id) const; + const int *inputTypesForMethod(int id) const; + const int *outputTypesForMethod(int id) const; + + // properties: + int propertyMetaType(int id) const; + + // helper function: + static void assign(void *, const QVariant &value); + +private: + QDBusMetaObject(); +}; + +struct QDBusMetaTypeId +{ + static bool innerInitialize(); + static bool initialized; + static inline void initialize() + { + if (initialized) return; + innerInitialize(); + } + + static int variant; + static int boollist; + static int shortlist; + static int ushortlist; + static int intlist; + static int uintlist; + static int longlonglist; + static int ulonglonglist; + static int doublelist; +}; + +#endif diff --git a/qt/src/qdbusmisc.cpp b/qt/src/qdbusmisc.cpp new file mode 100644 index 00000000..9aaf9f24 --- /dev/null +++ b/qt/src/qdbusmisc.cpp @@ -0,0 +1,156 @@ +/* qdbusmisc.cpp Miscellaneous routines that didn't fit anywhere else + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <string.h> + +#include <QtCore/qvariant.h> +#include <QtCore/qmetaobject.h> + +#include "qdbusconnection_p.h" +#include "qdbustypehelper_p.h" + +bool qDBusCheckAsyncTag(const char *tag) +{ + if (!tag || !*tag) + return false; + + const char *p = strstr(tag, "async"); + if (p != NULL && + (p == tag || *(p-1) == ' ') && + (p[5] == '\0' || p[5] == ' ')) + return true; + + p = strstr(tag, "Q_ASYNC"); + if (p != NULL && + (p == tag || *(p-1) == ' ') && + (p[7] == '\0' || p[7] == ' ')) + return true; + + return false; +} + +int qDBusNameToTypeId(const char *name) +{ + int id = static_cast<int>( QVariant::nameToType(name) ); + if (id == QVariant::UserType) + id = QMetaType::type(name); + + switch (id) { + case QVariant::Bool: + case QVariant::Int: + case QVariant::UInt: + case QVariant::Char: + case QMetaType::Short: + case QMetaType::UShort: + case QMetaType::UChar: + case QVariant::LongLong: + case QVariant::ULongLong: + case QVariant::Double: + case QVariant::String: + case QVariant::Date: + case QVariant::Time: + case QVariant::DateTime: + case QVariant::Map: + case QVariant::StringList: + case QVariant::ByteArray: + case QVariant::List: + return id; + + default: + if (id == QDBusConnectionPrivate::registerMessageMetaType() || + id == QDBusTypeHelper<QVariant>::id() || + id == QDBusTypeHelper<bool>::listId() || + id == QDBusTypeHelper<short>::listId() || + id == QDBusTypeHelper<ushort>::listId() || + id == QDBusTypeHelper<int>::listId() || + id == QDBusTypeHelper<qlonglong>::listId() || + id == QDBusTypeHelper<qulonglong>::listId() || + id == QDBusTypeHelper<double>::listId()) + return id; + + return 0; // invalid + } +} + +// calculates the metatypes for the method +// the slot must have the parameters in the following form: +// - zero or more value or const-ref parameters of any kind +// - zero or one const ref of QDBusMessage +// - zero or more non-const ref parameters +// No parameter may be a template. +// this function returns -1 if the parameters don't match the above form +// this function returns the number of *input* parameters, including the QDBusMessage one if any +// this function does not check the return type, so metaTypes[0] is always 0 and always present +// metaTypes.count() >= retval + 1 in all cases +// +// sig must be the normalised signature for the method +int qDBusParametersForMethod(const QMetaMethod &mm, QList<int>& metaTypes) +{ + QList<QByteArray> parameterTypes = mm.parameterTypes(); + metaTypes.clear(); + + metaTypes.append(0); // return type + int inputCount = 0; + bool seenMessage = false; + foreach (QByteArray type, parameterTypes) { + if (type.endsWith('*')) { + //qWarning("Could not parse the method '%s'", mm.signature()); + // pointer? + return -1; + } + + if (type.endsWith('&')) { + type.truncate(type.length() - 1); + int id = qDBusNameToTypeId(type); + if (id == 0) { + //qWarning("Could not parse the method '%s'", mm.signature()); + // invalid type in method parameter list + return -1; + } + + metaTypes.append( id ); + seenMessage = true; // it cannot appear anymore anyways + continue; + } + + if (seenMessage) { // && !type.endsWith('&') + //qWarning("Could not parse the method '%s'", mm.signature()); + // non-output parameters after message or after output params + return -1; // not allowed + } + + int id = qDBusNameToTypeId(type); + if (id == 0) { + //qWarning("Could not parse the method '%s'", mm.signature()); + // invalid type in method parameter list + return -1; + } + metaTypes.append(id); + ++inputCount; + + if (id == QDBusConnectionPrivate::registerMessageMetaType()) + seenMessage = true; + } + + return inputCount; +} diff --git a/qt/src/qdbusreply.h b/qt/src/qdbusreply.h new file mode 100644 index 00000000..0b5c12d9 --- /dev/null +++ b/qt/src/qdbusreply.h @@ -0,0 +1,132 @@ +/* qdbusreply.h QDBusReply object - a reply from D-Bus + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSREPLY_H +#define QDBUSREPLY_H + +#include <QtCore/qglobal.h> +#include <QtCore/qvariant.h> + +#include "qdbusmacros.h" +#include "qdbusmessage.h" +#include "qdbuserror.h" + +#include "qdbustypehelper_p.h" + +template<typename T> +class QDBusReply +{ + typedef T Type; +public: + inline QDBusReply(const QDBusMessage &reply) + : m_data(Type()) + { + *this = reply; + } + inline QDBusReply& operator=(const QDBusMessage& reply) + { + m_error = reply; + if (isSuccess()) + m_data = QDBusTypeHelper<Type>::fromVariant(reply.at(0)); + else + m_data = Type(); + return *this; + } + + inline QDBusReply(const QDBusError &error = QDBusError()) + : m_error(error), m_data(Type()) + { + } + inline QDBusReply& operator=(const QDBusError& error) + { + m_error = error; + m_data = Type(); + return *this; + } + + inline QDBusReply& operator=(const QDBusReply& other) + { + m_error = other.m_error; + m_data = other.m_data; + return *this; + } + + inline bool isError() const { return m_error.isValid(); } + inline bool isSuccess() const { return !m_error.isValid(); } + + inline const QDBusError& error() { return m_error; } + + inline Type value() + { + return m_data; + } + + inline operator Type () + { + return m_data; + } + + static QDBusReply<T> fromVariant(const QDBusReply<QVariant> &variantReply) + { + QDBusReply<T> retval; + retval.m_error = variantReply.m_error; + if (retval.isSuccess()) { + retval.m_data = qvariant_cast<Type>(variantReply.m_data); + if (!qVariantCanConvert<Type>(variantReply.m_data)) + retval.m_error = QDBusError(QDBusError::InvalidSignature, + QLatin1String("Unexpected reply signature")); + } + return retval; + } + +private: + QDBusError m_error; + Type m_data; +}; + +# ifndef Q_QDOC +// specialize for void: +template<> +class QDBUS_EXPORT QDBusReply<void> +{ +public: + inline QDBusReply(const QDBusMessage &reply) + : m_error(reply) + { + } + inline QDBusReply(const QDBusError &error) + : m_error(error) + { + } + + inline bool isError() const { return m_error.isValid(); } + inline bool isSuccess() const { return !m_error.isValid(); } + + inline const QDBusError& error() { return m_error; } + +private: + QDBusError m_error; +}; +# endif + +#endif diff --git a/qt/src/qdbusserver.cpp b/qt/src/qdbusserver.cpp new file mode 100644 index 00000000..b3b9835e --- /dev/null +++ b/qt/src/qdbusserver.cpp @@ -0,0 +1,61 @@ +/* qdbusserver.cpp + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusserver.h" +#include "qdbusconnection_p.h" + +QDBusServer::QDBusServer(const QString &addr, QObject *parent) + : QObject(parent) +{ + d = new QDBusConnectionPrivate(this); + + if (addr.isEmpty()) + return; + + d->setServer(dbus_server_listen(addr.toUtf8().constData(), &d->error)); +} + +bool QDBusServer::isConnected() const +{ + return d->server && dbus_server_get_is_connected(d->server); +} + +QDBusError QDBusServer::lastError() const +{ + return d->lastError; +} + +QString QDBusServer::address() const +{ + QString addr; + if (d->server) { + char *c = dbus_server_get_address(d->server); + addr = QString::fromUtf8(c); + dbus_free(c); + } + + return addr; +} + +#include "qdbusserver.moc" diff --git a/qt/src/qdbusserver.h b/qt/src/qdbusserver.h new file mode 100644 index 00000000..55607860 --- /dev/null +++ b/qt/src/qdbusserver.h @@ -0,0 +1,48 @@ +/* qdbusserver.h QDBusServer object + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef QDBUSSERVER_H +#define QDBUSSERVER_H + +#include "qdbusmacros.h" +#include <QtCore/qobject.h> +#include <QtCore/qstring.h> + +class QDBusConnectionPrivate; +class QDBusError; + +class QDBUS_EXPORT QDBusServer: public QObject +{ + Q_OBJECT +public: + QDBusServer(const QString &address, QObject *parent = 0); + + bool isConnected() const; + QDBusError lastError() const; + QString address() const; + +private: + Q_DISABLE_COPY(QDBusServer) + QDBusConnectionPrivate *d; +}; + +#endif diff --git a/qt/src/qdbusthread.cpp b/qt/src/qdbusthread.cpp new file mode 100644 index 00000000..f45a0096 --- /dev/null +++ b/qt/src/qdbusthread.cpp @@ -0,0 +1,116 @@ +/* qdbusintegrator.cpp QDBusConnection private implementation + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <QtCore/qmutex.h> +#include <QtCore/qwaitcondition.h> + +#include <dbus/dbus.h> + +struct DBusMutex: public QMutex +{ + inline DBusMutex() + : QMutex( QMutex::NonRecursive ) + { } + + static DBusMutex* mutex_new() + { + return new DBusMutex; + } + + static void mutex_free(DBusMutex *mutex) + { + delete mutex; + } + + static dbus_bool_t mutex_lock(DBusMutex *mutex) + { + mutex->lock(); + return true; + } + + static dbus_bool_t mutex_unlock(DBusMutex *mutex) + { + mutex->unlock(); + return true; + } +}; + +struct DBusCondVar: public QWaitCondition +{ + inline DBusCondVar() + { } + + static DBusCondVar* condvar_new() + { + return new DBusCondVar; + } + + static void condvar_free(DBusCondVar *cond) + { + delete cond; + } + + static void condvar_wait(DBusCondVar *cond, DBusMutex *mutex) + { + cond->wait(mutex); + } + + static dbus_bool_t condvar_wait_timeout(DBusCondVar *cond, DBusMutex *mutex, int msec) + { + return cond->wait(mutex, msec); + } + + static void condvar_wake_one(DBusCondVar *cond) + { + cond->wakeOne(); + } + + static void condvar_wake_all(DBusCondVar *cond) + { + cond->wakeAll(); + } +}; + +bool qDBusInitThreads() +{ + static DBusThreadFunctions fcn = { + DBUS_THREAD_FUNCTIONS_ALL_MASK, + DBusMutex::mutex_new, + DBusMutex::mutex_free, + DBusMutex::mutex_lock, + DBusMutex::mutex_unlock, + DBusCondVar::condvar_new, + DBusCondVar::condvar_free, + DBusCondVar::condvar_wait, + DBusCondVar::condvar_wait_timeout, + DBusCondVar::condvar_wake_one, + DBusCondVar::condvar_wake_all, + 0, 0, 0, 0, 0, 0, 0, 0 + }; + + dbus_threads_init(&fcn); + return true; +} + + diff --git a/qt/src/qdbustype.cpp b/qt/src/qdbustype.cpp new file mode 100644 index 00000000..7f17a372 --- /dev/null +++ b/qt/src/qdbustype.cpp @@ -0,0 +1,847 @@ +/* -*- C++ -*- + * + * Copyright (C) 2005 Thiago Macieira <thiago@kde.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbustype_p.h" +#include "qdbustypehelper_p.h" +#include <dbus/dbus.h> + +#include <QtCore/qstringlist.h> + +class QDBusTypePrivate: public QSharedData +{ +public: + int code; + mutable int qvariantType; + mutable QByteArray signature; + QDBusTypeList subTypes; + + inline QDBusTypePrivate() + : code(0), qvariantType(QVariant::Invalid) + { } +}; + +/*! + \class QDBusType + \brief Represents one single D-Bus type. + \internal + + D-Bus provides a set of primitive types that map to normal, C++ types and to QString, as well as + the possibility to extend the set with the so-called "container" types. The available types are + as follows: + + - Primitive (or basic): integers of 16, 32 and 64 bits, both signed and unsigned; byte (8 bits); + double-precision floating point and Unicode strings + - Arrays: a homogeneous, ordered list of zero or more entries + - Maps: an unordered list of (key, value) pairs, where key must be a primitive type and value + can be any D-Bus type + - Structs: an ordered list of a fixed number of entries of any type + - Variants: a "wildcard" container that can assume the value of any other type, including + structs and arrays + + Any type can be placed inside an array (including other arrays), but only entries of the same + type can be placed inside the same array. The analogous type for D-Bus arrays are the Qt + #QList template classes. + + Structs have a fixed number of entries and each entry has a fixed type. They are analogous to C + and C++ structs (hence the name). + + Maps or dictionaries are analogous to the Qt #QMap template class, with the additional + restriction that the key type must be a primitive one. D-Bus implements maps by using arrays of + a special type (a "dictionary entry"), so inspecting a QDBusType of a Map will reveal that it is + an array (see isArray()). + + Variants contain exactly one entry, but the type can vary freely. It is analogous to the Qt + class #QVariant, but the QtDBus implementation uses #QDBusVariant to represent D-Bus Variants. +*/ + +/*! + Constructs an empty (invalid) type. +*/ +QDBusType::QDBusType() + : d(0) +{ +} + +/*! + Constructs the type based on the D-Bus type given by \a type. +*/ +QDBusType::QDBusType(int type) +{ + char c[2] = { type, 0 }; + *this = QDBusType(c); +} + +/*! + Constructs the type based on the QVariant type given by \a type. + + \sa QVariant::Type +*/ +QDBusType::QDBusType(QVariant::Type type) +{ + const char *sig = dbusSignature(type); + + // it never returns NULL + // but it may return an empty string: + if (sig[0] == '\0') + return; + + if (qstrlen(sig) > 2) { + *this = QDBusType(sig); + } else { + d = new QDBusTypePrivate; + d->qvariantType = type; + d->code = sig[0]; + if (sig[1] == '\0') + // single-letter type + return; + else { + // two-letter type + // must be an array + d->code = sig[0]; + QDBusType t; + t.d = new QDBusTypePrivate; + t.d->code = sig[1]; + d->subTypes << t; + } + } +} + +/*! + Parses the D-Bus signature given by \a signature and constructs the type it represents. +*/ +QDBusType::QDBusType(const char* signature) +{ + if ( !dbus_signature_validate_single(signature, 0) ) + return; + + DBusSignatureIter iter; + dbus_signature_iter_init(&iter, signature); + *this = QDBusType(&iter); + if (d) + d->signature = signature; +} + +/*! + \overload + Parses the D-Bus signature given by \a str and constructs the type it represents. +*/ +QDBusType::QDBusType(const QString& str) +{ + *this = QDBusType( str.toUtf8().constData() ); +} + +/*! + \overload + Parses the D-Bus signature given by \a str and constructs the type it represents. +*/ +QDBusType::QDBusType(const QByteArray& str) +{ + *this = QDBusType( str.constData() ); +} + +/*! + \internal + Creates a QDBusType object based on the current element pointed to by \a iter. +*/ +QDBusType::QDBusType(DBusSignatureIter* iter) + : d(new QDBusTypePrivate) +{ + if ( dbus_type_is_container( d->code = dbus_signature_iter_get_current_type(iter) ) ) { + // we have to recurse + if ( d->code == DBUS_TYPE_VARIANT ) + return; // no we don't. dbus_type_is_container lies to us + + // we have to recurse + DBusSignatureIter subiter; + dbus_signature_iter_recurse(iter, &subiter); + + d->subTypes = QDBusTypeList(&subiter); + + // sanity checking: + if ( d->code == DBUS_TYPE_ARRAY ) + Q_ASSERT_X(d->subTypes.size() == 1, "QDBusType", + "more than one element in array"); + else if (d->code == DBUS_TYPE_DICT_ENTRY ) + Q_ASSERT_X(d->subTypes.size() == 2, "QDBusType", + "maps must have exactly two elements"); + } +} + +/*! + Copies the type from the object \a other. +*/ +QDBusType::QDBusType(const QDBusType& other) + : d(other.d) +{ +} + +/*! + Release the resources associated with this type. +*/ +QDBusType::~QDBusType() +{ +} + +/*! + Copies the type from the object given by \a other. +*/ +QDBusType& QDBusType::operator=(const QDBusType& other) +{ + d = other.d; + return *this; +} + +/*! + Returns the DBus type for this type. +*/ +int QDBusType::dbusType() const +{ + return d ? d->code : DBUS_TYPE_INVALID; +} + +/*! + Returns the DBus signature for this type and subtypes. +*/ +QByteArray QDBusType::dbusSignature() const +{ + if (!d) + return QByteArray(); + + if (!d->signature.isEmpty()) + return d->signature; + + if (d->subTypes.isEmpty()) + return d->signature = QByteArray(1, d->code); + + QByteArray retval; + switch (d->code) { + // can only be array, map or struct + + case DBUS_TYPE_ARRAY: + Q_ASSERT_X(d->subTypes.size() == 1, "QDBusType::dbusSignature", + "more than one element in array"); + + retval += DBUS_TYPE_ARRAY; + retval += d->subTypes.at(0).dbusSignature(); + break; + + case DBUS_TYPE_DICT_ENTRY: { + Q_ASSERT_X(d->subTypes.size() == 2, "QDBusType::dbusSignature", + "maps must have exactly two elements"); + + QByteArray value = d->subTypes.at(1).dbusSignature(); + char key = d->subTypes.at(0).dbusType(); + + Q_ASSERT(key != DBUS_TYPE_INVALID); + Q_ASSERT(!value.isEmpty()); + + retval.reserve(value.length() + 3); + retval = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING; + retval += key; + retval += value; + retval += DBUS_DICT_ENTRY_END_CHAR; + break; + } + + case DBUS_TYPE_STRUCT: + retval = d->subTypes.dbusSignature(); + retval.prepend(DBUS_STRUCT_BEGIN_CHAR); + retval.append(DBUS_STRUCT_END_CHAR); + break; + + default: + Q_ASSERT_X(false, "QDBusType::dbusSignature", "invalid container type"); + } + + d->signature = retval; + return retval; +} + +/*! + Returns the QVariant::Type for this entry. +*/ +int QDBusType::qvariantType() const +{ + if (d && d->qvariantType != QVariant::Invalid) + return d->qvariantType; + + if (!d) + return QVariant::Invalid; + + return d->qvariantType = qvariantType(dbusSignature().constData()); +} + +/*! + Returns true if this type is a valid one. +*/ +bool QDBusType::isValid() const +{ + return d && d->code != DBUS_TYPE_INVALID; +} + +/*! + Returns true if this type is a basic one. +*/ +bool QDBusType::isBasic() const +{ + return d && dbus_type_is_basic(d->code); +} + +/*! + Returns true if this type is a container. +*/ +bool QDBusType::isContainer() const +{ + return d && dbus_type_is_container(d->code); +} + +/*! + Returns the subtypes of this type, if this is a container. + + \sa isContainer() +*/ +QDBusTypeList QDBusType::subTypes() const +{ + if (d) + return d->subTypes; + return QDBusTypeList(); +} + +/*! + Returns true if this type is an array. + + \sa isContainer(), arrayElement() +*/ +bool QDBusType::isArray() const +{ + return dbusType() == DBUS_TYPE_ARRAY; +} + +/*! + This is a convenience function that returns the element type of an array. + If this object is not an array, it returns an invalid QDBusType. + + \sa isArray() +*/ +QDBusType QDBusType::arrayElement() const +{ + if (isArray() && d->subTypes.count() == 1) + return d->subTypes.first(); + return QDBusType(); +} + +/*! + Returns true if this type is a map (i.e., an array of dictionary entries). + + \sa isContainer(), isArray(), arrayElement() +*/ +bool QDBusType::isMap() const +{ + return arrayElement().dbusType() == DBUS_TYPE_DICT_ENTRY; +} + +/*! + If this object is a map, returns the (basic) type that corresponds to the key type. + If this object is not a map, returns an invalid QDBusType. + + \sa isMap() +*/ +QDBusType QDBusType::mapKey() const +{ + if (isMap()) + return arrayElement().d->subTypes.first(); + return QDBusType(); +} + +/*! + If this object is a map, returns the type that corresponds to the value type. + If this object is not a map, returns an invalid QDBusType. + + \sa isMap() +*/ +QDBusType QDBusType::mapValue() const +{ + if (isMap()) + return arrayElement().d->subTypes.at(1); + return QDBusType(); +} + +/*! + Returns true if this type is the same one as \a other. +*/ +bool QDBusType::operator==(const QDBusType& other) const +{ + if (!d && !other.d) + return true; + if (!d || !other.d) + return false; + return d->code == other.d->code && d->subTypes == other.d->subTypes; +} + +/*! + \fn QDBusType::operator!=(const QDBusType &other) const + Returns true if the this type and the one given by \a other are different. +*/ + +/*! + Converts the DBus type code \a type to QVariant::Type. +*/ +int QDBusType::qvariantType(int type) +{ + char c[2] = { type, 0 }; + return qvariantType(c); +} + +/*! + Converts the DBus type signature \a signature to QVariant::Type. +*/ +int QDBusType::qvariantType(const char* signature) +{ + if (!signature) + return QVariant::Invalid; + + // three special cases that don't validate as single: + if (qstrlen(signature) == 1) { + if (signature[0] == DBUS_TYPE_STRUCT) + return QVariant::List; + else if (signature[0] == DBUS_TYPE_DICT_ENTRY) + return QVariant::Map; + else if (signature[0] == DBUS_TYPE_ARRAY) + return QVariant::List; + } + + // now we can validate + if ( !dbus_signature_validate_single(signature, 0) ) + return QVariant::Invalid; + + switch (signature[0]) + { + case DBUS_TYPE_BOOLEAN: + return QVariant::Bool; + + case DBUS_TYPE_BYTE: + return QMetaType::UChar; + + case DBUS_TYPE_INT16: + return QMetaType::Short; + + case DBUS_TYPE_UINT16: + return QMetaType::UShort; + + case DBUS_TYPE_INT32: + return QVariant::Int; + + case DBUS_TYPE_UINT32: + return QVariant::UInt; + + case DBUS_TYPE_INT64: + return QVariant::LongLong; + + case DBUS_TYPE_UINT64: + return QVariant::ULongLong; + + case DBUS_TYPE_DOUBLE: + return QVariant::Double; + + case DBUS_TYPE_STRING: + case DBUS_TYPE_OBJECT_PATH: + case DBUS_TYPE_SIGNATURE: + return QVariant::String; + + case DBUS_STRUCT_BEGIN_CHAR: + return QVariant::List; // change to QDBusStruct in the future + + case DBUS_TYPE_VARIANT: + return QDBusTypeHelper<QVariant>::id(); + + case DBUS_TYPE_ARRAY: // special case + switch (signature[1]) { + case DBUS_TYPE_BOOLEAN: + return QDBusTypeHelper<bool>::listId(); + + case DBUS_TYPE_BYTE: + return QVariant::ByteArray; + + case DBUS_TYPE_INT16: + return QDBusTypeHelper<short>::listId(); + + case DBUS_TYPE_UINT16: + return QDBusTypeHelper<ushort>::listId(); + + case DBUS_TYPE_INT32: + return QDBusTypeHelper<int>::listId(); + + case DBUS_TYPE_UINT32: + return QDBusTypeHelper<uint>::listId(); + + case DBUS_TYPE_INT64: + return QDBusTypeHelper<qlonglong>::listId(); + + case DBUS_TYPE_UINT64: + return QDBusTypeHelper<qulonglong>::listId(); + + case DBUS_TYPE_DOUBLE: + return QDBusTypeHelper<double>::listId(); + + case DBUS_TYPE_STRING: + case DBUS_TYPE_OBJECT_PATH: + case DBUS_TYPE_SIGNATURE: + return QVariant::StringList; + + case DBUS_TYPE_VARIANT: + return QVariant::List; + + case DBUS_DICT_ENTRY_BEGIN_CHAR: + return QVariant::Map; + + default: + return QVariant::List; + } + default: + return QVariant::Invalid; + + } +} + +/*! + Converts the QVariant::Type \a t to a DBus type code. +*/ +int QDBusType::dbusType(QVariant::Type t) +{ + switch (t) + { + case QVariant::Bool: + return DBUS_TYPE_BOOLEAN; + + case QVariant::Int: + return DBUS_TYPE_INT32; + + case QVariant::UInt: + return DBUS_TYPE_UINT32; + + case QVariant::LongLong: + return DBUS_TYPE_INT64; + + case QVariant::ULongLong: + return DBUS_TYPE_UINT64; + + case QVariant::Double: + return DBUS_TYPE_DOUBLE; + + // from QMetaType: + case QMetaType::Short: + return DBUS_TYPE_INT16; + + case QMetaType::UShort: + return DBUS_TYPE_UINT16; + + case QMetaType::UChar: + return DBUS_TYPE_BYTE; + + case QVariant::String: + return DBUS_TYPE_STRING; + + case QVariant::Map: + // internal type information has been lost + return DBUS_TYPE_DICT_ENTRY; + + case QVariant::List: + case QVariant::StringList: + case QVariant::ByteArray: + // could also be a struct... + return DBUS_TYPE_ARRAY; + + case QVariant::UserType: + return DBUS_TYPE_INVALID; // invalid + + default: + break; // avoid compiler warnings + } + + if (int(t) == QDBusTypeHelper<QVariant>::id()) + return DBUS_TYPE_VARIANT; + + return DBUS_TYPE_INVALID; +} + +/*! + Converts the QVariant::Type \a t to a DBus type signature. +*/ +const char* QDBusType::dbusSignature(QVariant::Type t) +{ + switch (t) + { + case QVariant::Bool: + return DBUS_TYPE_BOOLEAN_AS_STRING; + + case QVariant::Int: + return DBUS_TYPE_INT32_AS_STRING; + + case QVariant::UInt: + return DBUS_TYPE_UINT32_AS_STRING; + + case QMetaType::Short: + return DBUS_TYPE_INT16_AS_STRING; + + case QMetaType::UShort: + return DBUS_TYPE_UINT16_AS_STRING; + + case QMetaType::UChar: + return DBUS_TYPE_BYTE_AS_STRING; + + case QVariant::LongLong: + return DBUS_TYPE_INT64_AS_STRING; + + case QVariant::ULongLong: + return DBUS_TYPE_UINT64_AS_STRING; + + case QVariant::Double: + return DBUS_TYPE_DOUBLE_AS_STRING; + + case QVariant::String: + return DBUS_TYPE_STRING_AS_STRING; + + case QVariant::Map: + // internal type information has been lost + return DBUS_TYPE_ARRAY_AS_STRING + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + DBUS_TYPE_STRING_AS_STRING + DBUS_TYPE_VARIANT_AS_STRING + DBUS_DICT_ENTRY_END_CHAR_AS_STRING; // a{sv} + + case QVariant::StringList: + return DBUS_TYPE_ARRAY_AS_STRING + DBUS_TYPE_STRING_AS_STRING; // as + + case QVariant::ByteArray: + return DBUS_TYPE_ARRAY_AS_STRING + DBUS_TYPE_BYTE_AS_STRING; // ay + + case QVariant::List: + // not a string list + // internal list data has been lost + // could also be a struct... + return DBUS_TYPE_ARRAY_AS_STRING + DBUS_TYPE_VARIANT_AS_STRING; // av + + default: + if (int(t) == QDBusTypeHelper<QVariant>::id()) + return DBUS_TYPE_VARIANT_AS_STRING; + if (int(t) == QDBusTypeHelper<bool>::listId()) + return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BOOLEAN_AS_STRING; + if (int(t) == QDBusTypeHelper<short>::listId()) + return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT16_AS_STRING; + if (int(t) == QDBusTypeHelper<ushort>::listId()) + return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_UINT16_AS_STRING; + if (int(t) == QDBusTypeHelper<int>::listId()) + return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT32_AS_STRING; + if (int(t) == QDBusTypeHelper<uint>::listId()) + return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_UINT32_AS_STRING; + if (int(t) == QDBusTypeHelper<qlonglong>::listId()) + return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT64_AS_STRING; + if (int(t) == QDBusTypeHelper<qulonglong>::listId()) + return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_UINT64_AS_STRING; + if (int(t) == QDBusTypeHelper<double>::listId()) + return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_DOUBLE_AS_STRING; + + return DBUS_TYPE_INVALID_AS_STRING; + } +} + +/*! + \enum QDBusType::VariantListMode + Defines how the guessFromVariant() function will behave when the QVariant is of type + QVariant::List. +*/ + +/*! + Guesses the DBus type from the given \a variant. +*/ +QDBusType QDBusType::guessFromVariant(const QVariant& variant, VariantListMode mode) +{ + if (variant.type() == QVariant::List) { + // investigate deeper + QDBusType t; + t.d = new QDBusTypePrivate; + const QVariantList list = variant.toList(); + + t.d->code = DBUS_TYPE_ARRAY; + if (!list.isEmpty()) { + // check if all elements have the same type + QVariant::Type type = list.first().type(); + foreach (const QVariant& v, list) + if (type != v.type()) { + // at least one is different + type = QVariant::Invalid; + break; + } + + if (type != QVariant::Invalid) { + // all are of the same type + t.d->subTypes << guessFromVariant(list.first()); + return t; + } + } else { + // an array of "something" + t.d->subTypes << QDBusType('v'); + return t; + } + + // treat it as a struct + t.d->code = DBUS_TYPE_STRUCT; + foreach (const QVariant& v, list) + t.d->subTypes << guessFromVariant(v, mode); + + return t; + } + else if (variant.type() == QVariant::Map) { + // investigate deeper + QDBusType t, t2, t3; + t2.d = new QDBusTypePrivate; + t2.d->code = DBUS_TYPE_DICT_ENTRY; + + // the key + t3.d = new QDBusTypePrivate; + t3.d->code = DBUS_TYPE_STRING; + t2.d->subTypes << t3; + + const QVariantMap map = variant.toMap(); + if (!map.isEmpty()) { + // check if all elements have the same type + QVariantMap::const_iterator it = map.constBegin(), + end = map.constEnd(); + QVariant::Type type = it.value().type(); + for ( ; it != end; ++it) + if (type != it.value().type()) { + // at least one is different + type = QVariant::Invalid; + break; + } + + if (type != QVariant::Invalid) + t2.d->subTypes << guessFromVariant(map.constBegin().value()); + else { + // multiple types + t3.d->code = DBUS_TYPE_VARIANT; + t2.d->subTypes << t3; + } + } + else { + // information lost + t3.d->code = DBUS_TYPE_VARIANT; + t2.d->subTypes << t3; + } + + t.d = new QDBusTypePrivate; + t.d->code = DBUS_TYPE_ARRAY; + t.d->subTypes << t2; + return t; + } + else + return QDBusType( QVariant::Type( variant.userType() ) ); +} + +/*! + \class QDBusTypeList + \brief A list of DBus types. + \internal + + Represents zero or more DBus types in sequence, such as those used in argument lists + or in subtypes of structs and maps. +*/ + +/*! + \fn QDBusTypeList::QDBusTypeList() + + Default constructor. + */ + +/*! + \fn QDBusTypeList::QDBusTypeList(const QDBusTypeList& other) + + Copy constructor: copies the type list from \a other. +*/ + +/*! + \fn QDBusTypeList::QDBusTypeList(const QList<QDBusType>& other) + + Copy constructor: copies the type list from \a other. +*/ + +/*! + Constructs a type list by parsing the given \a signature. +*/ +QDBusTypeList::QDBusTypeList(const char* signature) +{ + if (!signature || !*signature) + return; // empty + + // validate it first + if ( !dbus_signature_validate(signature, 0) ) + return; + + // split it into components + DBusSignatureIter iter; + dbus_signature_iter_init(&iter, signature); + + do { + *this << QDBusType(&iter); + } while (dbus_signature_iter_next(&iter)); +} + +/*! + \internal + Constructs a type list by parsing the elements on this iterator level. +*/ +QDBusTypeList::QDBusTypeList(DBusSignatureIter* iter) +{ + do { + QDBusType item(iter); + if (!item.isValid()) { + clear(); + return; + } + + *this << item; + } while (dbus_signature_iter_next(iter)); +} + +/*! + Returns true if this type list can represent the inner components of a map. +*/ +bool QDBusTypeList::canBeMap() const +{ + return size() == 2 && at(0).isBasic(); +} + +/*! + Reconstructs the type signature that this type list represents. +*/ +QByteArray QDBusTypeList::dbusSignature() const +{ + QByteArray retval; + foreach (QDBusType t, *this) + retval += t.dbusSignature(); + return retval; +} diff --git a/qt/src/qdbustype_p.h b/qt/src/qdbustype_p.h new file mode 100644 index 00000000..b719960e --- /dev/null +++ b/qt/src/qdbustype_p.h @@ -0,0 +1,109 @@ +/* -*- C++ -*- + * + * Copyright (C) 2005 Thiago Macieira <thiago@kde.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSTYPE_H +#define QDBUSTYPE_H + +#include <QtCore/qvariant.h> +#include <QtCore/qbytearray.h> +#include <QtCore/qshareddata.h> +#include <QtCore/qlist.h> +#include "qdbusmacros.h" +#include <dbus/dbus.h> + +// forward declaration +class QDBusTypeList; + +class QDBusTypePrivate; +class QDBUS_EXPORT QDBusType +{ +public: + QDBusType(); + explicit QDBusType(int type); + explicit QDBusType(QVariant::Type type); + explicit QDBusType(const char* signature); + explicit QDBusType(DBusSignatureIter*); + explicit QDBusType(const QString& str); + explicit QDBusType(const QByteArray& str); + QDBusType(const QDBusType& other); + + ~QDBusType(); + + QDBusType& operator=(const QDBusType& other); + + int qvariantType() const; + + int dbusType() const; + QByteArray dbusSignature() const; + bool isValid() const; + bool isBasic() const; + bool isContainer() const; + + QDBusTypeList subTypes() const; + + bool isArray() const; + QDBusType arrayElement() const; + + bool isMap() const; + QDBusType mapKey() const; + QDBusType mapValue() const; + + bool operator==(const QDBusType& other) const; + inline bool operator!=(const QDBusType &other) const + { return !(*this == other); } + + static int qvariantType(int type); + static int qvariantType(const char* signature); + static int dbusType(QVariant::Type); + static const char* dbusSignature(QVariant::Type); + + enum VariantListMode { + ListIsArray, + ListIsStruct + }; + static QDBusType guessFromVariant(const QVariant &variant, VariantListMode = ListIsArray); + +private: + QSharedDataPointer<QDBusTypePrivate> d; +}; + +class QDBUS_EXPORT QDBusTypeList: public QList<QDBusType> +{ +public: + inline QDBusTypeList() { } + inline QDBusTypeList(const QDBusTypeList& other) + : QList<QDBusType>(other) + { } + inline QDBusTypeList(const QList<QDBusType>& other) + : QList<QDBusType>(other) + { } + QDBusTypeList(const char* signature); + QDBusTypeList(DBusSignatureIter*); + + bool canBeMap() const; + + QByteArray dbusSignature() const; +}; + +#endif // QDBUSTYPE_H diff --git a/qt/src/qdbustypehelper_p.h b/qt/src/qdbustypehelper_p.h new file mode 100644 index 00000000..7ebd7f3e --- /dev/null +++ b/qt/src/qdbustypehelper_p.h @@ -0,0 +1,231 @@ +/* qdbuslisthelper_p.h Helper class to convert to and from QVariantList + * + * Copyright (C) 2005 Harald Fernengel <harry@kdevelop.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the public API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef QDBUSTYPEHELPERPRIVATE_H +#define QDBUSTYPEHELPERPRIVATE_H + +#include <QtCore/qlist.h> +#include <QtCore/qvariant.h> +#include <QtCore/qmetatype.h> + +// we're going to support all D-Bus primitive types here: +// uchar -- not needed: QByteArray +// bool +// short +// ushort +// int +// uint +// qlonglong +// qulonglong +// double +// QString -- not needed: QStringList +// QList -- not possible: will use QVariant +// QVariant +// QDBusStruct -- not yet existant +// QMap -- not possible: will use QVariant + +inline QDBUS_EXPORT int qDBusMetaTypeId(bool *) { return QVariant::Bool; } +inline QDBUS_EXPORT int qDBusMetaTypeId(uchar *) { return QMetaType::UChar; } +inline QDBUS_EXPORT int qDBusMetaTypeId(short *) { return QMetaType::Short; } +inline QDBUS_EXPORT int qDBusMetaTypeId(ushort *) { return QMetaType::UShort; } +inline QDBUS_EXPORT int qDBusMetaTypeId(int *) { return QVariant::Int; } +inline QDBUS_EXPORT int qDBusMetaTypeId(uint *) { return QVariant::UInt; } +inline QDBUS_EXPORT int qDBusMetaTypeId(qlonglong *) { return QVariant::LongLong; } +inline QDBUS_EXPORT int qDBusMetaTypeId(qulonglong *) { return QVariant::ULongLong; } +inline QDBUS_EXPORT int qDBusMetaTypeId(double *) { return QVariant::Double; } +inline QDBUS_EXPORT int qDBusMetaTypeId(QString *) { return QVariant::String; } +QDBUS_EXPORT int qDBusMetaTypeId(QVariant *); +QDBUS_EXPORT int qDBusMetaTypeId(QList<bool> *); +inline QDBUS_EXPORT int qDBusMetaTypeId(QByteArray *) { return QVariant::ByteArray; } +QDBUS_EXPORT int qDBusMetaTypeId(QList<short> *); +QDBUS_EXPORT int qDBusMetaTypeId(QList<ushort> *); +QDBUS_EXPORT int qDBusMetaTypeId(QList<int> *); +QDBUS_EXPORT int qDBusMetaTypeId(QList<uint> *); +QDBUS_EXPORT int qDBusMetaTypeId(QList<qlonglong> *); +QDBUS_EXPORT int qDBusMetaTypeId(QList<qulonglong> *); +QDBUS_EXPORT int qDBusMetaTypeId(QList<double> *); +inline QDBUS_EXPORT int qDBusMetaTypeId(QStringList *) { return QVariant::StringList; } +inline QDBUS_EXPORT int qDBusMetaTypeId(QVariantList *) { return QVariant::List; } +inline QDBUS_EXPORT int qDBusMetaTypeId(QVariantMap *) { return QVariant::Map; } + +// implement the copy mechanism +template<class T> +struct QDBusTypeHelper +{ + typedef T Type; + typedef QList<T> List; + + static inline int id() + { + Type* t = 0; + return qDBusMetaTypeId(t); + } + + static inline int listId() + { + List *l = 0; + return qDBusMetaTypeId(l); + } + + static inline QVariant toVariant(const Type &t) + { + return QVariant(id(), &t); + } + + static bool canSpecialConvert(const QVariant &); + static Type specialConvert(const QVariant &); + + static inline Type fromVariant(const QVariant &v) + { + if (canSpecialConvert(v)) + return specialConvert(v); + + QVariant copy(v); + if (copy.convert( QVariant::Type(id()) )) + return *reinterpret_cast<const Type *>(copy.constData()); + return Type(); + } + + static inline QVariantList toVariantList(const List list) + { + QVariantList tmp; + Q_FOREACH (const Type &t, list) + tmp.append(toVariant(t)); + return tmp; + } + + static inline QVariantList toVariantList(const QVariant &v) + { + return toVariantList(QDBusTypeHelper<List>::fromVariant(v)); + } + + static inline List fromVariantList(const QVariantList list) + { + List tmp; + Q_FOREACH (const QVariant &v, list) + tmp.append(fromVariant(v)); + return tmp; + } +}; + +template<> +struct QDBusTypeHelper<QVariant> +{ + static inline int id() + { + QVariant *t = 0; + return qDBusMetaTypeId(t); + } + + static inline int listId() + { + return QVariant::List; + } + + static inline QVariant toVariant(const QVariant &t) + { + return QVariant(id(), &t); + } + + static inline QVariant fromVariant(const QVariant &v) + { + if (v.userType() == id()) + return *reinterpret_cast<const QVariant *>(v.constData()); + return v; + } + + static inline QVariantList toVariantList(const QVariantList &list) + { + return list; + } + + static inline QVariantList fromVariantList(const QVariantList &list) + { + return list; + } +}; + +#if !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_NO_CAST_TO_ASCII) +template<> +struct QDBusTypeHelper<char *> +{ + static inline int id() + { return QVariant::String; } + + static inline QVariant toVariant(const char *t) + { return QVariant(t); } + + static inline QByteArray fromVariant(const QVariant &v) + { return v.toString().toAscii(); } +}; + +template<> +struct QDBusTypeHelper<const char *> +{ + static inline int id() + { return QVariant::String; } + + static inline QVariant toVariant(const char *t) + { return QVariant(t); } + + static inline QByteArray fromVariant(const QVariant &v) + { return v.toString().toAscii(); } +}; +#endif + +// support three exceptions: uchar, short and ushort +// we have to do this as long as QVariant can't convert to/from the integer metatypes +template<> inline bool QDBusTypeHelper<short>::canSpecialConvert(const QVariant &v) +{ return v.userType() < int(QVariant::UserType); } +template<> inline short QDBusTypeHelper<short>::specialConvert(const QVariant &v) +{ return v.toInt(); } + +template<> inline bool QDBusTypeHelper<ushort>::canSpecialConvert(const QVariant &v) +{ return v.userType() < int(QVariant::UserType); } +template<> inline ushort QDBusTypeHelper<ushort>::specialConvert(const QVariant &v) +{ return v.toUInt(); } + +template<> inline bool QDBusTypeHelper<uchar>::canSpecialConvert(const QVariant &v) +{ return v.userType() < int(QVariant::UserType); } +template<> inline uchar QDBusTypeHelper<uchar>::specialConvert(const QVariant &v) +{ return v.toUInt(); } + +template<typename T> inline bool QDBusTypeHelper<T>::canSpecialConvert(const QVariant &) +{ return false; } +template<typename T> inline T QDBusTypeHelper<T>::specialConvert(const QVariant &) +{ return T(); } + +#endif diff --git a/qt/src/qdbusutil.cpp b/qt/src/qdbusutil.cpp new file mode 100644 index 00000000..872434c5 --- /dev/null +++ b/qt/src/qdbusutil.cpp @@ -0,0 +1,235 @@ +/* -*- C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusutil.h" + +#include <dbus/dbus.h> + +#include <QtCore/qstringlist.h> +#include <QtCore/qregexp.h> + +#include "qdbustype_p.h" + +/*! + \namespace QDBusUtil + The QDBusUtil namespace contains a few functions that are of general use when dealing with D-Bus + strings. +*/ +namespace QDBusUtil +{ + /*! + \fn QDBusUtil::isValidInterfaceName(const QString &ifaceName) + Returns true if this is \a ifaceName is a valid interface name. + + Valid interface names must: + \list + \o not be empty + \o not exceed 255 characters in length + \o be composed of dot-separated string components that contain only ASCII letters, digits + and the underscore ("_") character + \o contain at least two such components + \endlist + */ + bool isValidInterfaceName(const QString& ifaceName) + { + if (ifaceName.isEmpty() || ifaceName.length() > DBUS_MAXIMUM_NAME_LENGTH) + return false; + + QStringList parts = ifaceName.split(QLatin1Char('.')); + if (parts.count() < 2) + return false; // at least two parts + + foreach (QString part, parts) + if (!isValidMemberName(part)) + return false; + + return true; + } + + /*! + \fn QDBusUtil::isValidUniqueConnectionName(const QString &connName) + Returns true if \a connName is a valid unique connection name. + + Unique connection names start with a colon (":") and are followed by a list of dot-separated + components composed of ASCII letters, digits, the hypen or the underscore ("_") character. + */ + bool isValidUniqueConnectionName(const QString &connName) + { + if (connName.isEmpty() || connName.length() > DBUS_MAXIMUM_NAME_LENGTH || + !connName.startsWith(QLatin1Char(':'))) + return false; + + QStringList parts = connName.mid(1).split(QLatin1Char('.')); + if (parts.count() < 1) + return false; + + QRegExp regex(QLatin1String("[a-zA-Z0-9_-]+")); + foreach (QString part, parts) + if (!regex.exactMatch(part)) + return false; + + return true; + } + + /*! + \fn QDBusUtil::isValidBusName(const QString &busName) + Returns true if \a busName is a valid bus name. + + A valid bus name is either a valid unique connection name or follows the rules: + \list + \o is not empty + \o does not exceed 255 characters in length + \o be composed of dot-separated string components that contain only ASCII letters, digits, + hyphens or underscores ("_"), but don't start with a digit + \o contains at least two such elements + \endlist + + \sa isValidUniqueConnectionName() + */ + bool isValidBusName(const QString &busName) + { + if (busName.isEmpty() || busName.length() > DBUS_MAXIMUM_NAME_LENGTH) + return false; + + if (busName.startsWith(QLatin1Char(':'))) + return isValidUniqueConnectionName(busName); + + QStringList parts = busName.split(QLatin1Char('.')); + if (parts.count() < 1) + return false; + + QRegExp regex(QLatin1String("[a-zA-Z_-][a-zA-Z0-9_-]*")); + foreach (QString part, parts) + if (!regex.exactMatch(part)) + return false; + + return true; + } + + /*! + \fn QDBusUtil::isValidMemberName(const QString &memberName) + Returns true if \a memberName is a valid member name. A valid member name does not exceed + 255 characters in length, is not empty, is composed only of ASCII letters, digits and + underscores, but does not start with a digit. + */ + bool isValidMemberName(const QString &memberName) + { + if (memberName.isEmpty() || memberName.length() > DBUS_MAXIMUM_NAME_LENGTH) + return false; + + QRegExp regex(QLatin1String("[a-zA-Z_][a-zA-Z0-9_]+")); + return regex.exactMatch(memberName); + } + + /*! + \fn QDBusUtil::isValidErrorName(const QString &errorName) + Returns true if \a errorName is a valid error name. Valid error names are valid interface + names and vice-versa, so this function is actually an alias for isValidInterfaceName. + */ + bool isValidErrorName(const QString &errorName) + { + return isValidInterfaceName(errorName); + } + + /*! + \fn QDBusUtil::isValidObjectPath(const QString &path) + Returns true if \a path is valid object path. + + Valid object paths follow the rules: + \list + \o start with the slash character ("/") + \o do not end in a slash, unless the path is just the initial slash + \o do not contain any two slashes in sequence + \o contain slash-separated parts, each of which is composed of ASCII letters, digits and + underscores ("_") + \endlist + */ + bool isValidObjectPath(const QString &path) + { + if (path == QLatin1String("/")) + return true; + + if (!path.startsWith(QLatin1Char('/')) || path.indexOf(QLatin1String("//")) != -1 || + path.endsWith(QLatin1Char('/'))) + return false; + + QStringList parts = path.split(QLatin1Char('/')); + Q_ASSERT(parts.count() >= 1); + parts.removeFirst(); // it starts with /, so we get an empty first part + + QRegExp regex(QLatin1String("[a-zA-Z0-9_]+")); + foreach (QString part, parts) + if (!regex.exactMatch(part)) + return false; + + return true; + } + + /*! + \fn QDBusUtil::isValidSignature(const QString &signature) + Returns true if \a signature is a valid D-Bus type signature for one or more types. + This function returns true if it can all of \a signature into valid, individual types and no + characters remain in \a signature. + + \sa isValidSingleSignature() + */ + bool isValidSignature(const QString &signature) + { + return dbus_signature_validate(signature.toUtf8(), 0); + } + + /*! + \fn QDBusUtil::isValidSingleSignature(const QString &signature) + Returns true if \a signature is a valid D-Bus type signature for exactly one full type. This + function tries to convert the type signature into a D-Bus type and, if it succeeds and no + characters remain in the signature, it returns true. + */ + bool isValidSingleSignature(const QString &signature) + { + return dbus_signature_validate_single(signature.toUtf8(), 0); + } + + /*! + \fn QDBusUtil::signatureToType(const QString &signature) + Returns the Qt meta type id for the given D-Bus signature for exactly one full type, given + by \a signature. + + \sa isValidSingleSignature(), typeToSignature(), QVariant::type(), QVariant::userType() + */ + QVariant::Type signatureToType(const QString &signature) + { + return QVariant::Type( QDBusType::qvariantType(signature.toLatin1().constData()) ); + } + + /*! + \fn QDBusUtil::typeToSignature(QVariant::Type type) + Returns the D-Bus signature equivalent to the supplied meta type id \a type. + + \sa isValidSingleSignature(), signatureToType(), QVariant::type(), QVariant::userType() + */ + const char *typeToSignature(QVariant::Type type) + { + return QDBusType::dbusSignature( type ); + } + +} // namespace QDBusUtil diff --git a/qt/src/qdbusutil.h b/qt/src/qdbusutil.h new file mode 100644 index 00000000..dd2b4df9 --- /dev/null +++ b/qt/src/qdbusutil.h @@ -0,0 +1,55 @@ +/* -*- C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSUTIL_H +#define QDBUSUTIL_H + +#include <QtCore/qstring.h> +#include <QtCore/qvariant.h> + +#include "qdbusmacros.h" + +namespace QDBusUtil +{ + QDBUS_EXPORT bool isValidInterfaceName(const QString &ifaceName); + + QDBUS_EXPORT bool isValidUniqueConnectionName(const QString &busName); + + QDBUS_EXPORT bool isValidBusName(const QString &busName); + + QDBUS_EXPORT bool isValidMemberName(const QString &memberName); + + QDBUS_EXPORT bool isValidErrorName(const QString &errorName); + + QDBUS_EXPORT bool isValidObjectPath(const QString &path); + + QDBUS_EXPORT bool isValidSignature(const QString &signature); + + QDBUS_EXPORT bool isValidSingleSignature(const QString &signature); + + QDBUS_EXPORT QVariant::Type signatureToType(const QString &signature); + + QDBUS_EXPORT const char *typeToSignature(QVariant::Type type); +} + +#endif diff --git a/qt/src/qdbusxmlgenerator.cpp b/qt/src/qdbusxmlgenerator.cpp new file mode 100644 index 00000000..cbd5388b --- /dev/null +++ b/qt/src/qdbusxmlgenerator.cpp @@ -0,0 +1,194 @@ +/* -*- mode: C++ -*- + * + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <QtCore/qcoreapplication.h> +#include <QtCore/qmetaobject.h> +#include <QtCore/qstringlist.h> + +#include "qdbusinterface_p.h" // for ANNOTATION_NO_WAIT +#include "qdbusabstractadaptor_p.h" // for QCLASSINFO_DBUS_* +#include "qdbusconnection_p.h" // for the flags +#include "qdbusutil.h" + +extern QDBUS_EXPORT QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo, + const QMetaObject *base, int flags); + +// implement the D-Bus org.freedesktop.DBus.Introspectable interface +// we do that by analysing the metaObject of all the adaptor interfaces + +static QString generateInterfaceXml(const QMetaObject *mo, int flags, int methodOffset, int propOffset) +{ + QString retval; + + // start with properties: + if (flags & QDBusConnection::ExportProperties) { + for (int i = propOffset; i < mo->propertyCount(); ++i) { + static const char *accessvalues[] = {0, "read", "write", "readwrite"}; + + QMetaProperty mp = mo->property(i); + + if (!mp.isScriptable() && (flags & QDBusConnection::ExportAllProperties) != + QDBusConnection::ExportAllProperties) + continue; + + int access = 0; + if (mp.isReadable()) + access |= 1; + if (mp.isWritable()) + access |= 2; + + int typeId = qDBusNameToTypeId(mp.typeName()); + if (!typeId) + continue; + + retval += QString(QLatin1String(" <property name=\"%1\" type=\"%2\" access=\"%3\" />\n")) + .arg(mp.name()) + .arg(QLatin1String( QDBusUtil::typeToSignature( QVariant::Type(typeId) ))) + .arg(QLatin1String( accessvalues[access] )); + } + } + + // now add methods: + for (int i = methodOffset; i < mo->methodCount(); ++i) { + QMetaMethod mm = mo->method(i); + QByteArray signature = mm.signature(); + int paren = signature.indexOf('('); + + bool isSignal; + if (mm.methodType() == QMetaMethod::Signal) + // adding a signal + isSignal = true; + else if (mm.methodType() == QMetaMethod::Slot && mm.access() == QMetaMethod::Public) + isSignal = false; + else + continue; // neither signal nor public slot + + if ((isSignal && !(flags & QDBusConnection::ExportSignals)) || + (!isSignal && !(flags & QDBusConnection::ExportSlots))) + continue; + + QString xml = QString(QLatin1String(" <%1 name=\"%2\">\n")) + .arg(isSignal ? QLatin1String("signal") : QLatin1String("method")) + .arg(QLatin1String(signature.left(paren))); + + // check the return type first + int typeId = qDBusNameToTypeId(mm.typeName()); + if (typeId) + xml += QString(QLatin1String(" <arg type=\"%1\" direction=\"out\"/>\n")) + .arg(QLatin1String(QDBusUtil::typeToSignature( QVariant::Type(typeId) ))); + else if (*mm.typeName()) + continue; // wasn't a valid type + + QList<QByteArray> names = mm.parameterNames(); + QList<int> types; + int inputCount = qDBusParametersForMethod(mm, types); + if (inputCount == -1) + continue; // invalid form + if (isSignal && inputCount + 1 != types.count()) + continue; // signal with output arguments? + if (isSignal && types.at(inputCount) == QDBusConnectionPrivate::messageMetaType) + continue; // signal with QDBusMessage argument? + + int j; + bool isScriptable = mm.attributes() & QMetaMethod::Scriptable; + for (j = 1; j < types.count(); ++j) { + // input parameter for a slot or output for a signal + if (types.at(j) == QDBusConnectionPrivate::messageMetaType) { + isScriptable = true; + continue; + } + + QString name; + if (!names.at(j - 1).isEmpty()) + name = QString(QLatin1String("name=\"%1\" ")).arg(QLatin1String(names.at(j - 1))); + + bool isOutput = isSignal || j > inputCount; + + xml += QString(QLatin1String(" <arg %1type=\"%2\" direction=\"%3\"/>\n")) + .arg(name) + .arg(QLatin1String(QDBusUtil::typeToSignature( QVariant::Type(types.at(j)) ))) + .arg(isOutput ? QLatin1String("out") : QLatin1String("in")); + } + + if (!isScriptable) { + // check if this was added by other means + if (isSignal && (flags & QDBusConnection::ExportAllSignals) != QDBusConnection::ExportAllSignals) + continue; + if (!isSignal && (flags & QDBusConnection::ExportAllSlots) != QDBusConnection::ExportAllSlots) + continue; + } + + if (qDBusCheckAsyncTag(mm.tag())) + // add the no-reply annotation + xml += QLatin1String(" <annotation name=\"" ANNOTATION_NO_WAIT "\"" + " value=\"true\"/>\n"); + + retval += xml; + retval += QString(QLatin1String(" </%1>\n")) + .arg(isSignal ? QLatin1String("signal") : QLatin1String("method")); + } + + return retval; +} + +QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo, const QMetaObject *base, + int flags) +{ + if (interface.isEmpty()) { + // generate the interface name from the meta object + int idx = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTERFACE); + if (idx >= mo->classInfoOffset()) { + interface = QLatin1String(mo->classInfo(idx).value()); + } else { + interface = QLatin1String(mo->className()); + interface.replace(QLatin1String("::"), QLatin1String(".")); + + if (interface.startsWith( QLatin1String("QDBus") )) { + interface.prepend( QLatin1String("com.trolltech.QtDBus.") ); + } else if (interface.startsWith( QLatin1Char('Q') )) { + // assume it's Qt + interface.prepend( QLatin1String("com.trolltech.Qt.") ); + } else if (!QCoreApplication::instance() || + QCoreApplication::instance()->applicationName().isEmpty()) { + interface.prepend( QLatin1String("local.") ); + } else { + interface.prepend(QLatin1Char('.')).prepend( QCoreApplication::instance()->applicationName() ); + QStringList domainName = QCoreApplication::instance()->organizationDomain().split(QLatin1Char('.')); + foreach (const QString &part, domainName) + interface.prepend(QLatin1Char('.')).prepend(part); + } + } + } + + QString xml; + int idx = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTROSPECTION); + if (idx >= mo->classInfoOffset()) + return QString::fromUtf8(mo->classInfo(idx).value()); + else + xml = generateInterfaceXml(mo, flags, base->methodCount(), base->propertyCount()); + + if (xml.isEmpty()) + return QString(); // don't add an empty interface + return QString(QLatin1String(" <interface name=\"%1\">\n%2 </interface>\n")) + .arg(interface, xml); +} diff --git a/qt/src/qdbusxmlparser.cpp b/qt/src/qdbusxmlparser.cpp new file mode 100644 index 00000000..0370cb23 --- /dev/null +++ b/qt/src/qdbusxmlparser.cpp @@ -0,0 +1,308 @@ +/* -*- C++ -*- + * + * Copyright (C) 2005 Thiago Macieira <thiago@kde.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "qdbusxmlparser_p.h" +#include "qdbusinterface.h" +#include "qdbusinterface_p.h" +#include "qdbusconnection_p.h" +#include "qdbusutil.h" + +#include <QtXml/qdom.h> +#include <QtCore/qmap.h> +#include <QtCore/qvariant.h> +#include <QtCore/qtextstream.h> + +static QDBusIntrospection::Annotations +parseAnnotations(const QDomElement& elem) +{ + QDBusIntrospection::Annotations retval; + QDomNodeList list = elem.elementsByTagName(QLatin1String("annotation")); + for (int i = 0; i < list.count(); ++i) + { + QDomElement ann = list.item(i).toElement(); + if (ann.isNull()) + continue; + + QString name = ann.attribute(QLatin1String("name")), + value = ann.attribute(QLatin1String("value")); + + if (name.isEmpty()) + continue; + + retval.insert(name, value); + } + + return retval; +} + +static QDBusIntrospection::Arguments +parseArgs(const QDomElement& elem, const QLatin1String& direction, bool acceptEmpty = false) +{ + QDBusIntrospection::Arguments retval; + QDomNodeList list = elem.elementsByTagName(QLatin1String("arg")); + for (int i = 0; i < list.count(); ++i) + { + QDomElement arg = list.item(i).toElement(); + if (arg.isNull()) + continue; + + if ((acceptEmpty && !arg.hasAttribute(QLatin1String("direction"))) || + arg.attribute(QLatin1String("direction")) == direction) { + + QDBusIntrospection::Argument argData; + if (arg.hasAttribute(QLatin1String("name"))) + argData.name = arg.attribute(QLatin1String("name")); // can be empty + argData.type = arg.attribute(QLatin1String("type")); + if (!QDBusUtil::isValidSingleSignature(argData.type)) + continue; + + retval << argData; + } + } + return retval; +} + +QDBusXmlParser::QDBusXmlParser(const QString& service, const QString& path, + const QString& xmlData) + : m_service(service), m_path(path) +{ + QDomDocument doc; + doc.setContent(xmlData); + m_node = doc.firstChildElement(QLatin1String("node")); +} + +QDBusXmlParser::QDBusXmlParser(const QString& service, const QString& path, + const QDomElement& node) + : m_service(service), m_path(path), m_node(node) +{ +} + +QDBusIntrospection::Interfaces +QDBusXmlParser::interfaces() const +{ + QDBusIntrospection::Interfaces retval; + + if (m_node.isNull()) + return retval; + + QDomNodeList interfaces = m_node.elementsByTagName(QLatin1String("interface")); + for (int i = 0; i < interfaces.count(); ++i) + { + QDomElement iface = interfaces.item(i).toElement(); + QString ifaceName = iface.attribute(QLatin1String("name")); + if (iface.isNull() || ifaceName.isEmpty()) + continue; // for whatever reason + + QDBusIntrospection::Interface *ifaceData = new QDBusIntrospection::Interface; + ifaceData->name = ifaceName; + { + // save the data + QTextStream ts(&ifaceData->introspection); + iface.save(ts,2); + } + + // parse annotations + ifaceData->annotations = parseAnnotations(iface); + + // parse methods + QDomNodeList list = iface.elementsByTagName(QLatin1String("method")); + for (int j = 0; j < list.count(); ++j) + { + QDomElement method = list.item(j).toElement(); + QString methodName = method.attribute(QLatin1String("name")); + if (method.isNull() || methodName.isEmpty()) + continue; + + QDBusIntrospection::Method methodData; + methodData.name = methodName; + + // parse arguments + methodData.inputArgs = parseArgs(method, QLatin1String("in")); + methodData.outputArgs = parseArgs(method, QLatin1String("out")); + methodData.annotations = parseAnnotations(method); + + // add it + ifaceData->methods.insert(methodName, methodData); + } + + // parse signals + list = iface.elementsByTagName(QLatin1String("signal")); + for (int j = 0; j < list.count(); ++j) + { + QDomElement signal = list.item(j).toElement(); + QString signalName = signal.attribute(QLatin1String("name")); + if (signal.isNull() || signalName.isEmpty()) + continue; + + QDBusIntrospection::Signal signalData; + signalData.name = signalName; + + // parse data + signalData.outputArgs = parseArgs(signal, QLatin1String("out"), true); + signalData.annotations = parseAnnotations(signal); + + // add it + ifaceData->signals_.insert(signalName, signalData); + } + + // parse properties + list = iface.elementsByTagName(QLatin1String("property")); + for (int j = 0; j < list.count(); ++j) + { + QDomElement property = list.item(j).toElement(); + QString propertyName = property.attribute(QLatin1String("name")); + if (property.isNull() || propertyName.isEmpty()) + continue; + + QDBusIntrospection::Property propertyData; + + // parse data + propertyData.name = propertyName; + propertyData.type = property.attribute(QLatin1String("type")); + propertyData.annotations = parseAnnotations(property); + + if (!QDBusUtil::isValidSingleSignature(propertyData.type)) + // cannot be! + continue; + + QString access = property.attribute(QLatin1String("access")); + if (access.isEmpty()) + // can't be empty either! + continue; + else if (access == QLatin1String("read")) + propertyData.access = QDBusIntrospection::Property::Read; + else if (access == QLatin1String("write")) + propertyData.access = QDBusIntrospection::Property::Write; + else if (access == QLatin1String("readwrite")) + propertyData.access = QDBusIntrospection::Property::ReadWrite; + else + continue; // invalid one! + + // add it + ifaceData->properties.insert(propertyName, propertyData); + } + + // add it + retval.insert(ifaceName, QSharedDataPointer<QDBusIntrospection::Interface>(ifaceData)); + } + + return retval; +} + +QSharedDataPointer<QDBusIntrospection::Object> +QDBusXmlParser::object() const +{ + if (m_node.isNull()) + return QSharedDataPointer<QDBusIntrospection::Object>(); + + QDBusIntrospection::Object* objData; + objData = new QDBusIntrospection::Object; + objData->service = m_service; + objData->path = m_path; + + // check if we have anything to process + if (objData->introspection.isNull() && !m_node.firstChild().isNull()) { + // yes, introspect this object + QTextStream ts(&objData->introspection); + m_node.save(ts,2); + + QDomNodeList objects = m_node.elementsByTagName(QLatin1String("node")); + for (int i = 0; i < objects.count(); ++i) { + QDomElement obj = objects.item(i).toElement(); + QString objName = obj.attribute(QLatin1String("name")); + if (obj.isNull() || objName.isEmpty()) + continue; // for whatever reason + + objData->childObjects.append(objName); + } + + QDomNodeList interfaces = m_node.elementsByTagName(QLatin1String("interface")); + for (int i = 0; i < interfaces.count(); ++i) { + QDomElement iface = interfaces.item(i).toElement(); + QString ifaceName = iface.attribute(QLatin1String("name")); + if (iface.isNull() || ifaceName.isEmpty()) + continue; + + objData->interfaces.append(ifaceName); + } + } else { + objData->introspection = QLatin1String("<node/>\n"); + } + + QSharedDataPointer<QDBusIntrospection::Object> retval; + retval = objData; + return retval; +} + +QSharedDataPointer<QDBusIntrospection::ObjectTree> +QDBusXmlParser::objectTree() const +{ + QSharedDataPointer<QDBusIntrospection::ObjectTree> retval; + + if (m_node.isNull()) + return retval; + + retval = new QDBusIntrospection::ObjectTree; + + retval->service = m_service; + retval->path = m_path; + + QTextStream ts(&retval->introspection); + m_node.save(ts,2); + + // interfaces are easy: + retval->interfaceData = interfaces(); + retval->interfaces = retval->interfaceData.keys(); + + // sub-objects are slightly more difficult: + QDomNodeList objects = m_node.elementsByTagName(QLatin1String("node")); + for (int i = 0; i < objects.count(); ++i) { + QDomElement obj = objects.item(i).toElement(); + QString objName = obj.attribute(QLatin1String("name")); + if (obj.isNull() || objName.isEmpty()) + continue; // for whatever reason + + // check if we have anything to process + if (!obj.firstChild().isNull()) { + // yes, introspect this object + QString xml; + QTextStream ts(&xml); + obj.save(ts,0); + + // parse it + QString objAbsName = m_path; + if (!objAbsName.endsWith(QLatin1Char('/'))) + objAbsName.append(QLatin1Char('/')); + objAbsName += objName; + + QDBusXmlParser parser(m_service, objAbsName, obj); + retval->childObjectData.insert(objName, parser.objectTree()); + } + + retval->childObjects << objName; + } + + return QSharedDataPointer<QDBusIntrospection::ObjectTree>( retval ); +} + diff --git a/qt/src/qdbusxmlparser_p.h b/qt/src/qdbusxmlparser_p.h new file mode 100644 index 00000000..8f4f69b1 --- /dev/null +++ b/qt/src/qdbusxmlparser_p.h @@ -0,0 +1,53 @@ +/* -*- C++ -*- + * + * Copyright (C) 2005 Thiago Macieira <thiago@kde.org> + * Copyright (C) 2006 Trolltech AS. All rights reserved. + * Author: Thiago Macieira <thiago.macieira@trolltech.com> + * + * Licensed under the Academic Free License version 2.1 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef QDBUSXMLPARSER_H +#define QDBUSXMLPARSER_H + +#include <QtCore/qmap.h> +#include <QtXml/qdom.h> +#include "qdbusmacros.h" +#include "qdbusintrospection_p.h" + +/*! + \internal +*/ +class QDBusXmlParser +{ + QString m_service; + QString m_path; + QDomElement m_node; + +public: + QDBusXmlParser(const QString& service, const QString& path, + const QString& xmlData); + QDBusXmlParser(const QString& service, const QString& path, + const QDomElement& node); + + QDBusIntrospection::Interfaces interfaces() const; + QSharedDataPointer<QDBusIntrospection::Object> object() const; + QSharedDataPointer<QDBusIntrospection::ObjectTree> objectTree() const; +}; + +#endif |