diff options
Diffstat (limited to 'src/dbus')
64 files changed, 20376 insertions, 0 deletions
diff --git a/src/dbus/dbus.pro b/src/dbus/dbus.pro new file mode 100644 index 0000000000..08c9ea1fb2 --- /dev/null +++ b/src/dbus/dbus.pro @@ -0,0 +1,90 @@ +TARGET = QtDBus +QPRO_PWD = $$PWD +QT = core \ + xml +CONFIG += link_pkgconfig +DEFINES += QT_BUILD_DBUS_LIB \ + DBUS_API_SUBJECT_TO_CHANGE +QMAKE_CXXFLAGS += $$QT_CFLAGS_DBUS +contains(QT_CONFIG, dbus-linked) { + LIBS_PRIVATE += $$QT_LIBS_DBUS + DEFINES += QT_LINKED_LIBDBUS +} + +# INCLUDEPATH += . +unix|win32-g++* { + QMAKE_PKGCONFIG_DESCRIPTION = Qt \ + DBus \ + module + QMAKE_PKGCONFIG_REQUIRES = QtCore \ + QtXml +} +win32 { + wince*:LIBS_PRIVATE += -lws2 + else:LIBS_PRIVATE += -lws2_32 \ + -ladvapi32 \ + -lnetapi32 \ + -luser32 + CONFIG(debug, debug|release):LIBS_PRIVATE += -ldbus-1d + else:LIBS_PRIVATE += -ldbus-1 +} +include(../qbase.pri) +PUB_HEADERS = qdbusargument.h \ + qdbusconnectioninterface.h \ + qdbusmacros.h \ + qdbuserror.h \ + qdbusextratypes.h \ + qdbusmessage.h \ + qdbusserver.h \ + qdbusconnection.h \ + qdbusabstractinterface.h \ + qdbusinterface.h \ + qdbusabstractadaptor.h \ + qdbusreply.h \ + qdbusmetatype.h \ + qdbuspendingcall.h \ + qdbuspendingreply.h \ + qdbuscontext.h +HEADERS += $$PUB_HEADERS \ + qdbusconnection_p.h \ + qdbusmessage_p.h \ + qdbusinterface_p.h \ + qdbusxmlparser_p.h \ + qdbusabstractadaptor_p.h \ + qdbusargument_p.h \ + qdbusutil_p.h \ + qdbusabstractinterface_p.h \ + qdbuscontext_p.h \ + qdbusthreaddebug_p.h \ + qdbusintegrator_p.h \ + qdbuspendingcall_p.h \ + qdbus_symbols_p.h \ + qdbusservicewatcher.h \ + qdbusunixfiledescriptor.h +SOURCES += qdbusconnection.cpp \ + qdbusconnectioninterface.cpp \ + qdbuserror.cpp \ + qdbusintegrator.cpp \ + qdbusmessage.cpp \ + qdbusserver.cpp \ + qdbusabstractinterface.cpp \ + qdbusinterface.cpp \ + qdbusxmlparser.cpp \ + qdbusutil.cpp \ + qdbusintrospection.cpp \ + qdbusabstractadaptor.cpp \ + qdbusinternalfilters.cpp \ + qdbusmetaobject.cpp \ + qdbusxmlgenerator.cpp \ + qdbusmisc.cpp \ + qdbusargument.cpp \ + qdbusreply.cpp \ + qdbusmetatype.cpp \ + qdbusextratypes.cpp \ + qdbusmarshaller.cpp \ + qdbuscontext.cpp \ + qdbuspendingcall.cpp \ + qdbuspendingreply.cpp \ + qdbus_symbols.cpp \ + qdbusservicewatcher.cpp \ + qdbusunixfiledescriptor.cpp diff --git a/src/dbus/qdbus_symbols.cpp b/src/dbus/qdbus_symbols.cpp new file mode 100644 index 0000000000..a62d52e04e --- /dev/null +++ b/src/dbus/qdbus_symbols.cpp @@ -0,0 +1,118 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtCore/qglobal.h> +#include <QtCore/qlibrary.h> +#include <QtCore/qmutex.h> +#include <private/qmutexpool_p.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +void *qdbus_resolve_me(const char *name); + +#if !defined QT_LINKED_LIBDBUS + +static QLibrary *qdbus_libdbus = 0; + +void qdbus_unloadLibDBus() +{ + delete qdbus_libdbus; + qdbus_libdbus = 0; +} + +bool qdbus_loadLibDBus() +{ + static volatile bool triedToLoadLibrary = false; +#ifndef QT_NO_THREAD + QMutexLocker locker(QMutexPool::globalInstanceGet((void *)&qdbus_resolve_me)); +#endif + QLibrary *&lib = qdbus_libdbus; + if (triedToLoadLibrary) + return lib && lib->isLoaded(); + + lib = new QLibrary; + triedToLoadLibrary = true; + + static int majorversions[] = { 3, 2, -1 }; + lib->unload(); + lib->setFileName(QLatin1String("dbus-1")); + for (uint i = 0; i < sizeof(majorversions) / sizeof(majorversions[0]); ++i) { + lib->setFileNameAndVersion(lib->fileName(), majorversions[i]); + if (lib->load() && lib->resolve("dbus_connection_open_private")) + return true; + + lib->unload(); + } + + delete lib; + lib = 0; + return false; +} + +void *qdbus_resolve_conditionally(const char *name) +{ + if (qdbus_loadLibDBus()) + return qdbus_libdbus->resolve(name); + return 0; +} + +void *qdbus_resolve_me(const char *name) +{ + void *ptr = 0; + if (!qdbus_loadLibDBus()) + qFatal("Cannot find libdbus-1 in your system to resolve symbol '%s'.", name); + + ptr = qdbus_libdbus->resolve(name); + if (!ptr) + qFatal("Cannot resolve '%s' in your libdbus-1.", name); + + return ptr; +} + +Q_DESTRUCTOR_FUNCTION(qdbus_unloadLibDBus) + +#endif // QT_LINKED_LIBDBUS + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbus_symbols_p.h b/src/dbus/qdbus_symbols_p.h new file mode 100644 index 0000000000..039657ef0b --- /dev/null +++ b/src/dbus/qdbus_symbols_p.h @@ -0,0 +1,375 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// 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 QDBUS_SYMBOLS_P_H +#define QDBUS_SYMBOLS_P_H + +#include <QtCore/qglobal.h> +#include <dbus/dbus.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +#if !defined QT_LINKED_LIBDBUS + +void *qdbus_resolve_conditionally(const char *name); // doesn't print a warning +void *qdbus_resolve_me(const char *name); // prints a warning +bool qdbus_loadLibDBus(); + +# define DEFINEFUNC(ret, func, args, argcall, funcret) \ + typedef ret (* _q_PTR_##func) args; \ + static inline ret q_##func args \ + { \ + static _q_PTR_##func ptr; \ + if (!ptr) \ + ptr = (_q_PTR_##func) qdbus_resolve_me(#func); \ + funcret ptr argcall; \ + } + +#else // defined QT_LINKED_LIBDBUS + +inline bool qdbus_loadLibDBus() { return true; } + +# define DEFINEFUNC(ret, func, args, argcall, funcret) \ + static inline ret q_##func args { funcret func argcall; } + +#endif // defined QT_LINKED_LIBDBUS + +/* dbus-bus.h */ +DEFINEFUNC(void, dbus_bus_add_match, (DBusConnection *connection, + const char *rule, + DBusError *error), + (connection, rule, error), ) +DEFINEFUNC(void, dbus_bus_remove_match, (DBusConnection *connection, + const char *rule, + DBusError *error), + (connection, rule, error), ) +DEFINEFUNC(dbus_bool_t, dbus_bus_register,(DBusConnection *connection, + DBusError *error), + (connection, error), return) +DEFINEFUNC(DBusConnection *, dbus_bus_get_private, (DBusBusType type, + DBusError *error), + (type, error), return) +DEFINEFUNC(const char*, dbus_bus_get_unique_name, (DBusConnection *connection), + (connection), return) + +/* dbus-connection.h */ +DEFINEFUNC(dbus_bool_t , dbus_connection_add_filter, (DBusConnection *connection, + DBusHandleMessageFunction function, + void *user_data, + DBusFreeFunction free_data_function), + (connection, function, user_data, free_data_function), return) +DEFINEFUNC(void , dbus_connection_close, (DBusConnection *connection), + (connection), return) +DEFINEFUNC(DBusDispatchStatus , dbus_connection_dispatch, (DBusConnection *connection), + (connection), return) +DEFINEFUNC(DBusDispatchStatus , dbus_connection_get_dispatch_status, (DBusConnection *connection), + (connection), return) +DEFINEFUNC(dbus_bool_t , dbus_connection_get_is_connected, (DBusConnection *connection), + (connection), return) +DEFINEFUNC(DBusConnection* , dbus_connection_open_private, (const char *address, + DBusError *error), + (address, error), return) +DEFINEFUNC(DBusConnection* , dbus_connection_ref, (DBusConnection *connection), + (connection), return) +DEFINEFUNC(dbus_bool_t , dbus_connection_send, (DBusConnection *connection, + DBusMessage *message, + dbus_uint32_t *client_serial), + (connection, message, client_serial), return) +DEFINEFUNC(dbus_bool_t , dbus_connection_send_with_reply, (DBusConnection *connection, + DBusMessage *message, + DBusPendingCall **pending_return, + int timeout_milliseconds), + (connection, message, pending_return, timeout_milliseconds), return) +DEFINEFUNC(DBusMessage * , dbus_connection_send_with_reply_and_block, (DBusConnection *connection, + DBusMessage *message, + int timeout_milliseconds, + DBusError *error), + (connection, message, timeout_milliseconds, error), return) +DEFINEFUNC(void , dbus_connection_set_exit_on_disconnect, (DBusConnection *connection, + dbus_bool_t exit_on_disconnect), + (connection, exit_on_disconnect), ) +DEFINEFUNC(dbus_bool_t , dbus_connection_set_timeout_functions, (DBusConnection *connection, + DBusAddTimeoutFunction add_function, + DBusRemoveTimeoutFunction remove_function, + DBusTimeoutToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function), + (connection, add_function, remove_function, toggled_function, data, free_data_function), return) +DEFINEFUNC(dbus_bool_t , dbus_connection_set_watch_functions, (DBusConnection *connection, + DBusAddWatchFunction add_function, + DBusRemoveWatchFunction remove_function, + DBusWatchToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function), + (connection, add_function, remove_function, toggled_function, data, free_data_function), return) +DEFINEFUNC(void , dbus_connection_set_wakeup_main_function, (DBusConnection *connection, + DBusWakeupMainFunction wakeup_main_function, + void *data, + DBusFreeFunction free_data_function), + (connection, wakeup_main_function, data, free_data_function), ) +DEFINEFUNC(void , dbus_connection_set_dispatch_status_function, (DBusConnection *connection, + DBusDispatchStatusFunction function, + void *data, + DBusFreeFunction free_data_function), + (connection, function, data, free_data_function), ) + +DEFINEFUNC(void , dbus_connection_unref, (DBusConnection *connection), + (connection), ) +DEFINEFUNC(dbus_bool_t , dbus_timeout_get_enabled, (DBusTimeout *timeout), + (timeout), return) +DEFINEFUNC(int , dbus_timeout_get_interval, (DBusTimeout *timeout), + (timeout), return) +DEFINEFUNC(dbus_bool_t , dbus_timeout_handle, (DBusTimeout *timeout), + (timeout), return) + +DEFINEFUNC(dbus_bool_t , dbus_watch_get_enabled, (DBusWatch *watch), + (watch), return) +DEFINEFUNC(int , dbus_watch_get_fd, (DBusWatch *watch), + (watch), return) +DEFINEFUNC(unsigned int , dbus_watch_get_flags, (DBusWatch *watch), + (watch), return) +DEFINEFUNC(dbus_bool_t , dbus_watch_handle, (DBusWatch *watch, + unsigned int flags), + (watch, flags), return) + +/* dbus-errors.h */ +DEFINEFUNC(void , dbus_error_free, (DBusError *error), + (error), ) +DEFINEFUNC(void , dbus_error_init, (DBusError *error), + (error), ) +DEFINEFUNC(dbus_bool_t , dbus_error_is_set, (const DBusError *error), + (error), return) + +/* dbus-memory.h */ +DEFINEFUNC(void , dbus_free, (void *memory), (memory), ) + +/* dbus-message.h */ +DEFINEFUNC(DBusMessage* , dbus_message_copy, (const DBusMessage *message), + (message), return) +DEFINEFUNC(dbus_bool_t , dbus_message_get_auto_start, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_error_name, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_interface, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_member, (DBusMessage *message), + (message), return) +DEFINEFUNC(dbus_bool_t , dbus_message_get_no_reply, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_path, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_sender, (DBusMessage *message), + (message), return) +DEFINEFUNC(dbus_uint32_t , dbus_message_get_serial, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_signature, (DBusMessage *message), + (message), return) +DEFINEFUNC(int , dbus_message_get_type, (DBusMessage *message), + (message), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_append_basic, (DBusMessageIter *iter, + int type, + const void *value), + (iter, type, value), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_append_fixed_array, (DBusMessageIter *iter, + int element_type, + const void *value, + int n_elements), + (iter, element_type, value, n_elements), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_close_container, (DBusMessageIter *iter, + DBusMessageIter *sub), + (iter, sub), return) +DEFINEFUNC(int , dbus_message_iter_get_arg_type, (DBusMessageIter *iter), + (iter), return) +DEFINEFUNC(void , dbus_message_iter_get_basic, (DBusMessageIter *iter, + void *value), + (iter, value), ) +DEFINEFUNC(int , dbus_message_iter_get_element_type, (DBusMessageIter *iter), + (iter), return) +DEFINEFUNC(void , dbus_message_iter_get_fixed_array, (DBusMessageIter *iter, + void *value, + int *n_elements), + (iter, value, n_elements), return) +DEFINEFUNC(char* , dbus_message_iter_get_signature, (DBusMessageIter *iter), + (iter), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_init, (DBusMessage *message, + DBusMessageIter *iter), + (message, iter), return) +DEFINEFUNC(void , dbus_message_iter_init_append, (DBusMessage *message, + DBusMessageIter *iter), + (message, iter), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_next, (DBusMessageIter *iter), + (iter), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_open_container, (DBusMessageIter *iter, + int type, + const char *contained_signature, + DBusMessageIter *sub), + (iter, type, contained_signature, sub), return) +DEFINEFUNC(void , dbus_message_iter_recurse, (DBusMessageIter *iter, + DBusMessageIter *sub), + (iter, sub), ) +DEFINEFUNC(DBusMessage* , dbus_message_new, (int message_type), + (message_type), return) +DEFINEFUNC(DBusMessage* , dbus_message_new_method_call, (const char *bus_name, + const char *path, + const char *interface, + const char *method), + (bus_name, path, interface, method), return) +DEFINEFUNC(DBusMessage* , dbus_message_new_signal, (const char *path, + const char *interface, + const char *name), + (path, interface, name), return) +DEFINEFUNC(DBusMessage* , dbus_message_ref, (DBusMessage *message), + (message), return) +DEFINEFUNC(void , dbus_message_set_auto_start, (DBusMessage *message, + dbus_bool_t auto_start), + (message, auto_start), return) +DEFINEFUNC(dbus_bool_t , dbus_message_set_destination, (DBusMessage *message, + const char *destination), + (message, destination), return) +DEFINEFUNC(dbus_bool_t , dbus_message_set_error_name, (DBusMessage *message, + const char *name), + (message, name), return) +DEFINEFUNC(void , dbus_message_set_no_reply, (DBusMessage *message, + dbus_bool_t no_reply), + (message, no_reply), return) +DEFINEFUNC(dbus_bool_t , dbus_message_set_path, (DBusMessage *message, + const char *object_path), + (message, object_path), return) +DEFINEFUNC(dbus_bool_t , dbus_message_set_reply_serial, (DBusMessage *message, + dbus_uint32_t reply_serial), + (message, reply_serial), return) +DEFINEFUNC(dbus_bool_t , dbus_message_set_sender, (DBusMessage *message, + const char *sender), + (message, sender), return) +DEFINEFUNC(void , dbus_message_unref, (DBusMessage *message), + (message), ) + +/* dbus-misc.h */ +DEFINEFUNC(void , dbus_get_version , (int *major_version_p, + int *minor_version_p, + int *micro_version_p), + (major_version_p, minor_version_p, micro_version_p), ) + +/* dbus-pending-call.h */ +DEFINEFUNC(dbus_bool_t , dbus_pending_call_set_notify, (DBusPendingCall *pending, + DBusPendingCallNotifyFunction function, + void *user_data, + DBusFreeFunction free_user_data), + (pending, function, user_data, free_user_data), return) +DEFINEFUNC(void , dbus_pending_call_block, (DBusPendingCall *pending), + (pending), ) +DEFINEFUNC(void , dbus_pending_call_cancel, (DBusPendingCall *pending), + (pending), ) +DEFINEFUNC(dbus_bool_t , dbus_pending_call_get_completed, (DBusPendingCall *pending), + (pending), return) +DEFINEFUNC(DBusMessage* , dbus_pending_call_steal_reply, (DBusPendingCall *pending), + (pending), return) +DEFINEFUNC(void , dbus_pending_call_unref, (DBusPendingCall *pending), + (pending), return) + +/* dbus-server.h */ +DEFINEFUNC(dbus_bool_t , dbus_server_allocate_data_slot, (dbus_int32_t *slot_p), + (slot_p), return) +DEFINEFUNC(void , dbus_server_disconnect, (DBusServer *server), + (server), ) +DEFINEFUNC(char* , dbus_server_get_address, (DBusServer *server), + (server), return) +DEFINEFUNC(dbus_bool_t , dbus_server_get_is_connected, (DBusServer *server), + (server), return) +DEFINEFUNC(DBusServer* , dbus_server_listen, (const char *address, + DBusError *error), + (address, error), return) +DEFINEFUNC(dbus_bool_t , dbus_server_set_data, (DBusServer *server, + int slot, + void *data, + DBusFreeFunction free_data_func), + (server, slot, data, free_data_func), return) +DEFINEFUNC(void , dbus_server_set_new_connection_function, (DBusServer *server, + DBusNewConnectionFunction function, + void *data, + DBusFreeFunction free_data_function), + (server, function, data, free_data_function), ) +DEFINEFUNC(dbus_bool_t , dbus_server_set_timeout_functions, (DBusServer *server, + DBusAddTimeoutFunction add_function, + DBusRemoveTimeoutFunction remove_function, + DBusTimeoutToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function), + (server, add_function, remove_function, toggled_function, data, free_data_function), return) +DEFINEFUNC(dbus_bool_t , dbus_server_set_watch_functions, (DBusServer *server, + DBusAddWatchFunction add_function, + DBusRemoveWatchFunction remove_function, + DBusWatchToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function), + (server, add_function, remove_function, toggled_function, data, free_data_function), return) +DEFINEFUNC(void , dbus_server_unref, (DBusServer *server), + (server), ) + +/* dbus-thread.h */ +DEFINEFUNC(dbus_bool_t , dbus_threads_init_default, (), (), return) + + +/* D-Bus 1.4 symbols */ +#if !defined(QT_LINKED_LIBDBUS) || (DBUS_VERSION >= 0x010400) +DEFINEFUNC(dbus_bool_t , dbus_connection_can_send_type , (DBusConnection *connection, + int type), + (connection, type), return) +#endif + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif // QDBUS_SYMBOLS_P_H diff --git a/src/dbus/qdbusabstractadaptor.cpp b/src/dbus/qdbusabstractadaptor.cpp new file mode 100644 index 0000000000..c75bbaa639 --- /dev/null +++ b/src/dbus/qdbusabstractadaptor.cpp @@ -0,0 +1,384 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusabstractadaptor.h" + +#include <QtCore/qcoreapplication.h> +#include <QtCore/qmetaobject.h> +#include <QtCore/qset.h> +#include <QtCore/qtimer.h> +#include <QtCore/qthread.h> + +#include "qdbusconnection.h" + +#include "qdbusconnection_p.h" // for qDBusParametersForMethod +#include "qdbusabstractadaptor_p.h" +#include "qdbusmetatype_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +QDBusAdaptorConnector *qDBusFindAdaptorConnector(QObject *obj) +{ + if (!obj) + return 0; + const QObjectList &children = obj->children(); + QObjectList::ConstIterator it = children.constBegin(); + QObjectList::ConstIterator end = children.constEnd(); + for ( ; it != end; ++it) { + QDBusAdaptorConnector *connector = qobject_cast<QDBusAdaptorConnector *>(*it); + if (connector) { + connector->polish(); + return connector; + } + } + return 0; +} + +QDBusAdaptorConnector *qDBusFindAdaptorConnector(QDBusAbstractAdaptor *adaptor) +{ + return qDBusFindAdaptorConnector(adaptor->parent()); +} + +QDBusAdaptorConnector *qDBusCreateAdaptorConnector(QObject *obj) +{ + QDBusAdaptorConnector *connector = qDBusFindAdaptorConnector(obj); + if (connector) + return connector; + return new QDBusAdaptorConnector(obj); +} + +QString QDBusAbstractAdaptorPrivate::retrieveIntrospectionXml(QDBusAbstractAdaptor *adaptor) +{ + return adaptor->d_func()->xml; +} + +void QDBusAbstractAdaptorPrivate::saveIntrospectionXml(QDBusAbstractAdaptor *adaptor, + const QString &xml) +{ + adaptor->d_func()->xml = xml; +} + +/*! + \class QDBusAbstractAdaptor + \inmodule QtDBus + \since 4.2 + + \brief The QDBusAbstractAdaptor class is the base class of 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 (its parent) 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. Note that only one interface can be + exposed in this way. + + 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 obj as the parent object. +*/ +QDBusAbstractAdaptor::QDBusAbstractAdaptor(QObject* obj) + : QObject(*new QDBusAbstractAdaptorPrivate, obj) +{ + QDBusAdaptorConnector *connector = qDBusCreateAdaptorConnector(obj); + + connector->waitingForPolish = true; + QMetaObject::invokeMethod(connector, "polish", Qt::QueuedConnection); +} + +/*! + 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() +{ +} + +/*! + 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(); + bool connected = false; + 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) + connected = connect(parent(), sig, sig) || connected; + } + d_func()->autoRelaySignals = connected; +} + +/*! + Returns true if automatic signal relaying from the real object (see object()) is enabled, + otherwiser returns false. + + \sa setAutoRelaySignals() +*/ +bool QDBusAbstractAdaptor::autoRelaySignals() const +{ + return d_func()->autoRelaySignals; +} + +QDBusAdaptorConnector::QDBusAdaptorConnector(QObject *obj) + : QObject(obj), waitingForPolish(false) +{ +} + +QDBusAdaptorConnector::~QDBusAdaptorConnector() +{ +} + +void QDBusAdaptorConnector::addAdaptor(QDBusAbstractAdaptor *adaptor) +{ + // find the interface name + const QMetaObject *mo = adaptor->metaObject(); + int ciid = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTERFACE); + if (ciid != -1) { + QMetaClassInfo mci = mo->classInfo(ciid); + if (*mci.value()) { + // find out if this interface exists first + const char *interface = mci.value(); + AdaptorMap::Iterator it = qLowerBound(adaptors.begin(), adaptors.end(), + QByteArray(interface)); + if (it != adaptors.end() && qstrcmp(interface, it->interface) == 0) { + // exists. Replace it (though it's probably the same) + if (it->adaptor != adaptor) { + // reconnect the signals + disconnectAllSignals(it->adaptor); + connectAllSignals(adaptor); + } + it->adaptor = adaptor; + } else { + // create a new one + AdaptorData entry; + entry.interface = interface; + entry.adaptor = adaptor; + adaptors << entry; + + // connect the adaptor's signals to our relaySlot slot + connectAllSignals(adaptor); + } + } + } +} + +void QDBusAdaptorConnector::disconnectAllSignals(QObject *obj) +{ + QMetaObject::disconnect(obj, -1, this, metaObject()->methodOffset()); +} + +void QDBusAdaptorConnector::connectAllSignals(QObject *obj) +{ + QMetaObject::connect(obj, -1, this, metaObject()->methodOffset(), Qt::DirectConnection); +} + +void QDBusAdaptorConnector::polish() +{ + if (!waitingForPolish) + return; // avoid working multiple times if multiple adaptors were added + + waitingForPolish = false; + const QObjectList &objs = parent()->children(); + QObjectList::ConstIterator it = objs.constBegin(); + QObjectList::ConstIterator end = objs.constEnd(); + for ( ; it != end; ++it) { + QDBusAbstractAdaptor *adaptor = qobject_cast<QDBusAbstractAdaptor *>(*it); + if (adaptor) + addAdaptor(adaptor); + } + + // sort the adaptor list + qSort(adaptors); +} + +void QDBusAdaptorConnector::relaySlot(void **argv) +{ + QObjectPrivate *d = static_cast<QObjectPrivate *>(d_ptr.data()); + relay(d->currentSender->sender, d->currentSender->signal, argv); +} + +void QDBusAdaptorConnector::relay(QObject *senderObj, int lastSignalIdx, void **argv) +{ + if (lastSignalIdx < QObject::staticMetaObject.methodCount()) + // QObject signal (destroyed(QObject *)) -- ignore + return; + + const QMetaObject *senderMetaObject = senderObj->metaObject(); + QMetaMethod mm = senderMetaObject->method(lastSignalIdx); + + QObject *realObject = senderObj; + if (qobject_cast<QDBusAbstractAdaptor *>(senderObj)) + // it's an adaptor, so the real object is in fact its parent + realObject = realObject->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) == QDBusMetaTypeId::message) { + // invalid signal signature + // qDBusParametersForMethod has not yet complained about this one + qWarning("QDBusAbstractAdaptor: Cannot relay signal %s::%s", + senderMetaObject->className(), mm.signature()); + return; + } + + QVariantList args; + for (int i = 1; i < types.count(); ++i) + args << QVariant(types.at(i), argv[i]); + + // now emit the signal with all the information + emit relaySignal(realObject, senderMetaObject, lastSignalIdx, args); +} + +// our Meta Object +// modify carefully: this has been hand-edited! +// the relaySlot slot has local ID 0 (we use this when calling QMetaObject::connect) +// it also gets called with the void** array + +static const uint qt_meta_data_QDBusAdaptorConnector[] = { + // content: + 1, // revision + 0, // classname + 0, 0, // classinfo + 3, 10, // methods + 0, 0, // properties + 0, 0, // enums/sets + + // slots: signature, parameters, type, tag, flags + 106, 22, 22, 22, 0x0a, + 118, 22, 22, 22, 0x0a, + + // signals: signature, parameters, type, tag, flags + 47, 23, 22, 22, 0x05, + + 0 // eod +}; + +static const char qt_meta_stringdata_QDBusAdaptorConnector[] = { + "QDBusAdaptorConnector\0\0obj,metaobject,sid,args\0" + "relaySignal(QObject*,const QMetaObject*,int,QVariantList)\0\0relaySlot()\0" + "polish()\0" +}; + +const QMetaObject QDBusAdaptorConnector::staticMetaObject = { + { &QObject::staticMetaObject, qt_meta_stringdata_QDBusAdaptorConnector, + qt_meta_data_QDBusAdaptorConnector, 0 } +}; + +const QMetaObject *QDBusAdaptorConnector::metaObject() const +{ + return &staticMetaObject; +} + +void *QDBusAdaptorConnector::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_QDBusAdaptorConnector)) + return static_cast<void*>(const_cast<QDBusAdaptorConnector*>(this)); + return QObject::qt_metacast(_clname); +} + +int QDBusAdaptorConnector::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QObject::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + if (_c == QMetaObject::InvokeMetaMethod) { + switch (_id) { + case 0: relaySlot(_a); break; // HAND EDIT: add the _a parameter + case 1: polish(); break; + case 2: relaySignal((*reinterpret_cast< QObject*(*)>(_a[1])),(*reinterpret_cast< const QMetaObject*(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])),(*reinterpret_cast< const QVariantList(*)>(_a[4]))); break; + } + _id -= 3; + } + return _id; +} + +// SIGNAL 0 +void QDBusAdaptorConnector::relaySignal(QObject * _t1, const QMetaObject * _t2, int _t3, const QVariantList & _t4) +{ + void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)), const_cast<void*>(reinterpret_cast<const void*>(&_t4)) }; + QMetaObject::activate(this, &staticMetaObject, 2, _a); +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusabstractadaptor.h b/src/dbus/qdbusabstractadaptor.h new file mode 100644 index 0000000000..a9241a1f61 --- /dev/null +++ b/src/dbus/qdbusabstractadaptor.h @@ -0,0 +1,80 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSABSTRACTADAPTOR_H +#define QDBUSABSTRACTADAPTOR_H + +#include <QtCore/qobject.h> +#include <QtDBus/qdbusmacros.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusAbstractAdaptorPrivate; +class Q_DBUS_EXPORT QDBusAbstractAdaptor: public QObject +{ + Q_OBJECT +protected: + QDBusAbstractAdaptor(QObject *parent); + +public: + ~QDBusAbstractAdaptor(); + +protected: + void setAutoRelaySignals(bool enable); + bool autoRelaySignals() const; + +private: + Q_DECLARE_PRIVATE(QDBusAbstractAdaptor) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS + +#endif diff --git a/src/dbus/qdbusabstractadaptor_p.h b/src/dbus/qdbusabstractadaptor_p.h new file mode 100644 index 0000000000..678fc2ddf6 --- /dev/null +++ b/src/dbus/qdbusabstractadaptor_p.h @@ -0,0 +1,138 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// 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 <qdbusabstractadaptor.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> +#include "private/qobject_p.h" + +#define QCLASSINFO_DBUS_INTERFACE "D-Bus Interface" +#define QCLASSINFO_DBUS_INTROSPECTION "D-Bus Introspection" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +class QDBusAbstractAdaptor; +class QDBusAdaptorConnector; +class QDBusAdaptorManager; +class QDBusConnectionPrivate; + +class QDBusAbstractAdaptorPrivate: public QObjectPrivate +{ + Q_DECLARE_PUBLIC(QDBusAbstractAdaptor) +public: + QDBusAbstractAdaptorPrivate() : autoRelaySignals(false) {} + QString xml; + bool autoRelaySignals; + + static QString retrieveIntrospectionXml(QDBusAbstractAdaptor *adaptor); + static void saveIntrospectionXml(QDBusAbstractAdaptor *adaptor, const QString &xml); +}; + +class QDBusAdaptorConnector: public QObject +{ + Q_OBJECT_FAKE + +public: // typedefs + struct AdaptorData + { + const char *interface; + QDBusAbstractAdaptor *adaptor; + + inline bool operator<(const AdaptorData &other) const + { return QByteArray(interface) < other.interface; } + inline bool operator<(const QString &other) const + { return QLatin1String(interface) < other; } + inline bool operator<(const QByteArray &other) const + { return interface < other; } + }; + typedef QVector<AdaptorData> AdaptorMap; + +public: // methods + explicit QDBusAdaptorConnector(QObject *parent); + ~QDBusAdaptorConnector(); + + void addAdaptor(QDBusAbstractAdaptor *adaptor); + void connectAllSignals(QObject *object); + void disconnectAllSignals(QObject *object); + void relay(QObject *sender, int id, void **); + +//public slots: + void relaySlot(void **); + void polish(); + +protected: +//signals: + void relaySignal(QObject *obj, const QMetaObject *metaObject, int sid, const QVariantList &args); + +public: // member variables + AdaptorMap adaptors; + bool waitingForPolish : 1; +}; + +extern QDBusAdaptorConnector *qDBusFindAdaptorConnector(QObject *object); +extern QDBusAdaptorConnector *qDBusCreateAdaptorConnector(QObject *object); + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif // QDBUSABSTRACTADAPTORPRIVATE_H diff --git a/src/dbus/qdbusabstractinterface.cpp b/src/dbus/qdbusabstractinterface.cpp new file mode 100644 index 0000000000..9e82c09ed0 --- /dev/null +++ b/src/dbus/qdbusabstractinterface.cpp @@ -0,0 +1,776 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusabstractinterface.h" +#include "qdbusabstractinterface_p.h" + +#include <qthread.h> + +#include "qdbusargument.h" +#include "qdbuspendingcall.h" +#include "qdbusmessage_p.h" +#include "qdbusmetaobject_p.h" +#include "qdbusmetatype_p.h" +#include "qdbusutil_p.h" + +#include <qdebug.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +static QDBusError checkIfValid(const QString &service, const QString &path, + const QString &interface, bool isDynamic, bool isPeer) +{ + // We should be throwing exceptions here... oh well + QDBusError error; + + // dynamic interfaces (QDBusInterface) can have empty interfaces, but not service and object paths + // non-dynamic is the opposite: service and object paths can be empty, but not the interface + if (!isDynamic) { + // use assertion here because this should never happen, at all + Q_ASSERT_X(!interface.isEmpty(), "QDBusAbstractInterface", "Interface name cannot be empty"); + } + if (!QDBusUtil::checkBusName(service, (isDynamic && !isPeer) ? QDBusUtil::EmptyNotAllowed : QDBusUtil::EmptyAllowed, &error)) + return error; + if (!QDBusUtil::checkObjectPath(path, isDynamic ? QDBusUtil::EmptyNotAllowed : QDBusUtil::EmptyAllowed, &error)) + return error; + if (!QDBusUtil::checkInterfaceName(interface, QDBusUtil::EmptyAllowed, &error)) + return error; + + // no error + return QDBusError(); +} + +QDBusAbstractInterfacePrivate::QDBusAbstractInterfacePrivate(const QString &serv, + const QString &p, + const QString &iface, + const QDBusConnection& con, + bool isDynamic) + : connection(con), service(serv), path(p), interface(iface), + lastError(checkIfValid(serv, p, iface, isDynamic, (connectionPrivate() && + connectionPrivate()->mode == QDBusConnectionPrivate::PeerMode))), + isValid(!lastError.isValid()) +{ + if (!isValid) + return; + + if (!connection.isConnected()) { + lastError = QDBusError(QDBusError::Disconnected, + QLatin1String("Not connected to D-Bus server")); + } else if (!service.isEmpty()) { + currentOwner = connectionPrivate()->getNameOwner(service); // verify the name owner + if (currentOwner.isEmpty()) { + lastError = connectionPrivate()->lastError; + } + } +} + +bool QDBusAbstractInterfacePrivate::canMakeCalls() const +{ + // recheck only if we have a wildcard (i.e. empty) service or path + // if any are empty, set the error message according to QDBusUtil + if (service.isEmpty() && connectionPrivate()->mode != QDBusConnectionPrivate::PeerMode) + return QDBusUtil::checkBusName(service, QDBusUtil::EmptyNotAllowed, &lastError); + if (path.isEmpty()) + return QDBusUtil::checkObjectPath(path, QDBusUtil::EmptyNotAllowed, &lastError); + return true; +} + +void QDBusAbstractInterfacePrivate::property(const QMetaProperty &mp, QVariant &where) const +{ + if (!isValid || !canMakeCalls()) { // can't make calls + where.clear(); + return; + } + + // is this metatype registered? + const char *expectedSignature = ""; + if (mp.type() != 0xff) { + expectedSignature = QDBusMetaType::typeToSignature(where.userType()); + if (expectedSignature == 0) { + qWarning("QDBusAbstractInterface: type %s must be registered with QtDBus before it can be " + "used to read property %s.%s", + mp.typeName(), qPrintable(interface), mp.name()); + lastError = QDBusError(QDBusError::Failed, + QString::fromLatin1("Unregistered type %1 cannot be handled") + .arg(QLatin1String(mp.typeName()))); + where.clear(); + return; + } + } + + // try to read this property + QDBusMessage msg = QDBusMessage::createMethodCall(service, path, + QLatin1String(DBUS_INTERFACE_PROPERTIES), + QLatin1String("Get")); + QDBusMessagePrivate::setParametersValidated(msg, true); + msg << interface << QString::fromUtf8(mp.name()); + QDBusMessage reply = connection.call(msg, QDBus::Block); + + if (reply.type() != QDBusMessage::ReplyMessage) { + lastError = reply; + where.clear(); + return; + } + 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())); + where.clear(); + return; + } + + QByteArray foundSignature; + const char *foundType = 0; + QVariant value = qvariant_cast<QDBusVariant>(reply.arguments().at(0)).variant(); + + if (value.userType() == where.userType() || mp.type() == 0xff + || (expectedSignature[0] == 'v' && expectedSignature[1] == '\0')) { + // simple match + where = value; + return; + } + + if (value.userType() == qMetaTypeId<QDBusArgument>()) { + QDBusArgument arg = qvariant_cast<QDBusArgument>(value); + + foundType = "user type"; + foundSignature = arg.currentSignature().toLatin1(); + if (foundSignature == expectedSignature) { + // signatures match, we can demarshall + QDBusMetaType::demarshall(arg, where.userType(), where.data()); + return; + } + } else { + foundType = value.typeName(); + foundSignature = QDBusMetaType::typeToSignature(value.userType()); + } + + // there was an error... + QString errmsg = QLatin1String("Unexpected `%1' (%2) when retrieving property `%3.%4' " + "(expected type `%5' (%6))"); + lastError = QDBusError(QDBusError::InvalidSignature, + errmsg.arg(QString::fromLatin1(foundType), + QString::fromLatin1(foundSignature), + interface, + QString::fromUtf8(mp.name()), + QString::fromLatin1(mp.typeName()), + QString::fromLatin1(expectedSignature))); + where.clear(); + return; +} + +bool QDBusAbstractInterfacePrivate::setProperty(const QMetaProperty &mp, const QVariant &value) +{ + if (!isValid || !canMakeCalls()) // can't make calls + return false; + + // send the value + QDBusMessage msg = QDBusMessage::createMethodCall(service, path, + QLatin1String(DBUS_INTERFACE_PROPERTIES), + QLatin1String("Set")); + QDBusMessagePrivate::setParametersValidated(msg, true); + msg << interface << QString::fromUtf8(mp.name()) << QVariant::fromValue(QDBusVariant(value)); + QDBusMessage reply = connection.call(msg, QDBus::Block); + + if (reply.type() != QDBusMessage::ReplyMessage) { + lastError = reply; + return false; + } + return true; +} + +void QDBusAbstractInterfacePrivate::_q_serviceOwnerChanged(const QString &name, + const QString &oldOwner, + const QString &newOwner) +{ + Q_UNUSED(oldOwner); + //qDebug() << "QDBusAbstractInterfacePrivate serviceOwnerChanged" << name << oldOwner << newOwner; + if (name == service) { + currentOwner = newOwner; + } +} + +QDBusAbstractInterfaceBase::QDBusAbstractInterfaceBase(QDBusAbstractInterfacePrivate &d, QObject *parent) + : QObject(d, parent) +{ +} + +int QDBusAbstractInterfaceBase::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + int saved_id = _id; + _id = QObject::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + + if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty) { + QMetaProperty mp = metaObject()->property(saved_id); + int &status = *reinterpret_cast<int *>(_a[2]); + QVariant &variant = *reinterpret_cast<QVariant *>(_a[1]); + + if (_c == QMetaObject::WriteProperty) { + status = d_func()->setProperty(mp, variant) ? 1 : 0; + } else { + d_func()->property(mp, variant); + status = variant.isValid() ? 1 : 0; + } + _id = -1; + } + return _id; +} + +/*! + \class QDBusAbstractInterface + \inmodule QtDBus + \since 4.2 + + \brief The QDBusAbstractInterface class is the 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 {qdbusxml2cpp.html}{The QDBus compiler}, QDBusInterface +*/ + +/*! + \internal + This is the constructor called from QDBusInterface::QDBusInterface. +*/ +QDBusAbstractInterface::QDBusAbstractInterface(QDBusAbstractInterfacePrivate &d, QObject *parent) + : QDBusAbstractInterfaceBase(d, parent) +{ + // keep track of the service owner + if (d.isValid && + d.connection.isConnected() + && !d.service.isEmpty() + && !d.service.startsWith(QLatin1Char(':'))) + d_func()->connection.connect(QLatin1String(DBUS_SERVICE_DBUS), // service + QString(), // path + QLatin1String(DBUS_INTERFACE_DBUS), // interface + QLatin1String("NameOwnerChanged"), + QStringList() << d.service, + QString(), // signature + this, SLOT(_q_serviceOwnerChanged(QString,QString,QString))); +} + +/*! + \internal + This is the constructor called from static classes derived from + QDBusAbstractInterface (i.e., those generated by dbusxml2cpp). +*/ +QDBusAbstractInterface::QDBusAbstractInterface(const QString &service, const QString &path, + const char *interface, const QDBusConnection &con, + QObject *parent) + : QDBusAbstractInterfaceBase(*new QDBusAbstractInterfacePrivate(service, path, QString::fromLatin1(interface), + con, false), parent) +{ + // keep track of the service owner + if (d_func()->isValid && + d_func()->connection.isConnected() + && !service.isEmpty() + && !service.startsWith(QLatin1Char(':'))) + d_func()->connection.connect(QLatin1String(DBUS_SERVICE_DBUS), // service + QString(), // path + QLatin1String(DBUS_INTERFACE_DBUS), // interface + QLatin1String("NameOwnerChanged"), + QStringList() << service, + QString(), //signature + this, SLOT(_q_serviceOwnerChanged(QString,QString,QString))); +} + +/*! + Releases this object's resources. +*/ +QDBusAbstractInterface::~QDBusAbstractInterface() +{ +} + +/*! + 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. +*/ +bool QDBusAbstractInterface::isValid() const +{ + return !d_func()->currentOwner.isEmpty(); +} + +/*! + Returns the connection this interface is assocated with. +*/ +QDBusConnection QDBusAbstractInterface::connection() const +{ + return d_func()->connection; +} + +/*! + 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; +} + +/*! + 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. + + \threadsafe +*/ +QDBusMessage QDBusAbstractInterface::callWithArgumentList(QDBus::CallMode mode, + const QString& method, + const QList<QVariant>& args) +{ + Q_D(QDBusAbstractInterface); + + if (!d->isValid || !d->canMakeCalls()) + return QDBusMessage::createError(d->lastError); + + QString m = method; + // split out the signature from the method + int pos = method.indexOf(QLatin1Char('.')); + if (pos != -1) + m.truncate(pos); + + if (mode == QDBus::AutoDetect) { + // determine if this a sync or async call + mode = QDBus::Block; + const QMetaObject *mo = metaObject(); + QByteArray match = m.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("Q_NOREPLY")) + mode = QDBus::NoBlock; + + break; + } + } + } + +// qDebug() << "QDBusAbstractInterface" << "Service" << service() << "Path:" << path(); + QDBusMessage msg = QDBusMessage::createMethodCall(service(), path(), interface(), m); + QDBusMessagePrivate::setParametersValidated(msg, true); + msg.setArguments(args); + + QDBusMessage reply = d->connection.call(msg, mode); + if (thread() == QThread::currentThread()) + d->lastError = reply; // will clear if reply isn't an error + + // ensure that there is at least one element + if (reply.arguments().isEmpty()) + reply << QVariant(); + + return reply; +} + +/*! + \since 4.5 + Places a call to the remote method specified by \a method on this + interface, using \a args as arguments. This function returns a + QDBusPendingCall object that can be used to track the status of the + reply and access its contents once it has arrived. + + Normally, you should place calls using asyncCall(). + + \threadsafe +*/ +QDBusPendingCall QDBusAbstractInterface::asyncCallWithArgumentList(const QString& method, + const QList<QVariant>& args) +{ + Q_D(QDBusAbstractInterface); + + if (!d->isValid || !d->canMakeCalls()) + return QDBusPendingCall::fromError(d->lastError); + + QDBusMessage msg = QDBusMessage::createMethodCall(service(), path(), interface(), method); + QDBusMessagePrivate::setParametersValidated(msg, true); + msg.setArguments(args); + return d->connection.asyncCall(msg); +} + +/*! + Places a call to the remote method specified by \a method + on this interface, using \a args as arguments. This function + returns immediately after queueing the call. The reply from + the remote function is delivered to the \a returnMethod on + object \a receiver. If an error occurs, the \a errorMethod + on object \a receiver is called instead. + + This function returns true if the queueing succeeds. It does + not indicate that the executed call succeeded. If it fails, + the \a errorMethod is called. If the queueing failed, this + function returns false and no slot will be called. + + The \a returnMethod must have as its parameters the types returned + by the function call. Optionally, it may have a QDBusMessage + parameter as its last or only parameter. The \a errorMethod must + have a QDBusError as its only parameter. + + \since 4.3 + \sa QDBusError, QDBusMessage + */ +bool QDBusAbstractInterface::callWithCallback(const QString &method, + const QList<QVariant> &args, + QObject *receiver, + const char *returnMethod, + const char *errorMethod) +{ + Q_D(QDBusAbstractInterface); + + if (!d->isValid || !d->canMakeCalls()) + return false; + + QDBusMessage msg = QDBusMessage::createMethodCall(service(), + path(), + interface(), + method); + QDBusMessagePrivate::setParametersValidated(msg, true); + msg.setArguments(args); + + d->lastError = 0; + return d->connection.callWithCallback(msg, + receiver, + returnMethod, + errorMethod); +} + +/*! + \overload + + This function is deprecated. Please use the overloaded version. + + Places a call to the remote method specified by \a method + on this interface, using \a args as arguments. This function + returns immediately after queueing the call. The reply from + the remote function or any errors emitted by it are 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::callWithCallback(const QString &method, + const QList<QVariant> &args, + QObject *receiver, + const char *slot) +{ + return callWithCallback(method, args, receiver, slot, 0); +} + +/*! + \internal + Catch signal connections. +*/ +void QDBusAbstractInterface::connectNotify(const char *signal) +{ + // someone connecting to one of our signals + Q_D(QDBusAbstractInterface); + if (!d->isValid) + return; + + // we end up recursing here, so optimize away + if (qstrcmp(signal + 1, "destroyed(QObject*)") == 0) + return; + + QDBusConnectionPrivate *conn = d->connectionPrivate(); + if (conn) { + conn->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); + if (!d->isValid) + return; + + QDBusConnectionPrivate *conn = d->connectionPrivate(); + if (conn) + conn->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 + + return property(propname); +} + +/*! + \internal + Set the value of the property \a propname to \a value. +*/ +void QDBusAbstractInterface::internalPropSet(const char *propname, const QVariant &value) +{ + setProperty(propname, value); +} + +/*! + 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 can be used with up to 8 parameters, passed in arguments \a arg1, \a arg2, + \a arg3, \a arg4, \a arg5, \a arg6, \a arg7 and \a arg8. If you need more than 8 + parameters or if you have a variable number of parameters to be passed, use + callWithArgumentList(). + + It can be used the following way: + + \snippet doc/src/snippets/code/src_qdbus_qdbusabstractinterface.cpp 0 + + 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). +*/ +QDBusMessage QDBusAbstractInterface::call(const QString &method, const QVariant &arg1, + const QVariant &arg2, + const QVariant &arg3, + const QVariant &arg4, + const QVariant &arg5, + const QVariant &arg6, + const QVariant &arg7, + const QVariant &arg8) +{ + return call(QDBus::AutoDetect, method, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); +} + +/*! + \overload + + Calls the method \a method on this interface and passes the + parameters to this function to the method. If \a mode is \c + NoWaitForReply, then this function will return immediately after + placing the call, without waiting for a reply from the remote + method. Otherwise, \a mode indicates whether this function should + activate the Qt Event Loop while waiting for the reply to arrive. + + This function can be used with up to 8 parameters, passed in arguments \a arg1, \a arg2, + \a arg3, \a arg4, \a arg5, \a arg6, \a arg7 and \a arg8. If you need more than 8 + parameters or if you have a variable number of parameters to be passed, use + callWithArgumentList(). + + If this function reenters the Qt event loop in order to wait for the + reply, it will exclude 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(). +*/ +QDBusMessage QDBusAbstractInterface::call(QDBus::CallMode mode, const QString &method, + const QVariant &arg1, + const QVariant &arg2, + const QVariant &arg3, + const QVariant &arg4, + const QVariant &arg5, + const QVariant &arg6, + const QVariant &arg7, + const QVariant &arg8) +{ + QList<QVariant> argList; + int count = 0 + arg1.isValid() + arg2.isValid() + arg3.isValid() + arg4.isValid() + + arg5.isValid() + arg6.isValid() + arg7.isValid() + arg8.isValid(); + + switch (count) { + case 8: + argList.prepend(arg8); + case 7: + argList.prepend(arg7); + case 6: + argList.prepend(arg6); + case 5: + argList.prepend(arg5); + case 4: + argList.prepend(arg4); + case 3: + argList.prepend(arg3); + case 2: + argList.prepend(arg2); + case 1: + argList.prepend(arg1); + } + + return callWithArgumentList(mode, method, argList); +} + + +/*! + \since 4.5 + 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. The returned QDBusPendingCall object can be used to find out information about + the reply. + + This function can be used with up to 8 parameters, passed in arguments \a arg1, \a arg2, + \a arg3, \a arg4, \a arg5, \a arg6, \a arg7 and \a arg8. If you need more than 8 + parameters or if you have a variable number of parameters to be passed, use + asyncCallWithArgumentList(). + + It can be used the following way: + + \snippet doc/src/snippets/code/src_qdbus_qdbusabstractinterface.cpp 1 + + 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). +*/ +QDBusPendingCall QDBusAbstractInterface::asyncCall(const QString &method, const QVariant &arg1, + const QVariant &arg2, + const QVariant &arg3, + const QVariant &arg4, + const QVariant &arg5, + const QVariant &arg6, + const QVariant &arg7, + const QVariant &arg8) +{ + QList<QVariant> argList; + int count = 0 + arg1.isValid() + arg2.isValid() + arg3.isValid() + arg4.isValid() + + arg5.isValid() + arg6.isValid() + arg7.isValid() + arg8.isValid(); + + switch (count) { + case 8: + argList.prepend(arg8); + case 7: + argList.prepend(arg7); + case 6: + argList.prepend(arg6); + case 5: + argList.prepend(arg5); + case 4: + argList.prepend(arg4); + case 3: + argList.prepend(arg3); + case 2: + argList.prepend(arg2); + case 1: + argList.prepend(arg1); + } + + return asyncCallWithArgumentList(method, argList); +} + +/*! + \internal +*/ +QDBusMessage QDBusAbstractInterface::internalConstCall(QDBus::CallMode mode, + const QString &method, + const QList<QVariant> &args) const +{ + // ### move the code here, and make the other functions call this + return const_cast<QDBusAbstractInterface*>(this)->callWithArgumentList(mode, method, args); +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS + +#include "moc_qdbusabstractinterface.cpp" diff --git a/src/dbus/qdbusabstractinterface.h b/src/dbus/qdbusabstractinterface.h new file mode 100644 index 0000000000..ec7cd8ed89 --- /dev/null +++ b/src/dbus/qdbusabstractinterface.h @@ -0,0 +1,165 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSABSTRACTINTERFACE_H +#define QDBUSABSTRACTINTERFACE_H + +#include <QtCore/qstring.h> +#include <QtCore/qvariant.h> +#include <QtCore/qlist.h> +#include <QtCore/qobject.h> + +#include <QtDBus/qdbusmessage.h> +#include <QtDBus/qdbusextratypes.h> +#include <QtDBus/qdbusconnection.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusError; +class QDBusPendingCall; + +class QDBusAbstractInterfacePrivate; + +class Q_DBUS_EXPORT QDBusAbstractInterfaceBase: public QObject +{ +public: + int qt_metacall(QMetaObject::Call, int, void**); +protected: + QDBusAbstractInterfaceBase(QDBusAbstractInterfacePrivate &dd, QObject *parent); +private: + Q_DECLARE_PRIVATE(QDBusAbstractInterface) +}; + +class Q_DBUS_EXPORT QDBusAbstractInterface: +#ifdef Q_QDOC + public QObject +#else + public QDBusAbstractInterfaceBase +#endif +{ + Q_OBJECT + +public: + virtual ~QDBusAbstractInterface(); + bool isValid() const; + + QDBusConnection connection() const; + + QString service() const; + QString path() const; + QString interface() const; + + QDBusError lastError() const; + + QDBusMessage call(const QString &method, + const QVariant &arg1 = QVariant(), + const QVariant &arg2 = QVariant(), + const QVariant &arg3 = QVariant(), + const QVariant &arg4 = QVariant(), + const QVariant &arg5 = QVariant(), + const QVariant &arg6 = QVariant(), + const QVariant &arg7 = QVariant(), + const QVariant &arg8 = QVariant()); + + QDBusMessage call(QDBus::CallMode mode, + const QString &method, + const QVariant &arg1 = QVariant(), + const QVariant &arg2 = QVariant(), + const QVariant &arg3 = QVariant(), + const QVariant &arg4 = QVariant(), + const QVariant &arg5 = QVariant(), + const QVariant &arg6 = QVariant(), + const QVariant &arg7 = QVariant(), + const QVariant &arg8 = QVariant()); + + QDBusMessage callWithArgumentList(QDBus::CallMode mode, + const QString &method, + const QList<QVariant> &args); + + bool callWithCallback(const QString &method, + const QList<QVariant> &args, + QObject *receiver, const char *member, const char *errorSlot); + bool callWithCallback(const QString &method, + const QList<QVariant> &args, + QObject *receiver, const char *member); + + QDBusPendingCall asyncCall(const QString &method, + const QVariant &arg1 = QVariant(), + const QVariant &arg2 = QVariant(), + const QVariant &arg3 = QVariant(), + const QVariant &arg4 = QVariant(), + const QVariant &arg5 = QVariant(), + const QVariant &arg6 = QVariant(), + const QVariant &arg7 = QVariant(), + const QVariant &arg8 = QVariant()); + QDBusPendingCall asyncCallWithArgumentList(const QString &method, + const QList<QVariant> &args); + +protected: + QDBusAbstractInterface(const QString &service, const QString &path, const char *interface, + const QDBusConnection &connection, QObject *parent); + QDBusAbstractInterface(QDBusAbstractInterfacePrivate &, QObject *parent); + + void connectNotify(const char *signal); + void disconnectNotify(const char *signal); + QVariant internalPropGet(const char *propname) const; + void internalPropSet(const char *propname, const QVariant &value); + QDBusMessage internalConstCall(QDBus::CallMode mode, + const QString &method, + const QList<QVariant> &args = QList<QVariant>()) const; + +private: + Q_DECLARE_PRIVATE(QDBusAbstractInterface) + Q_PRIVATE_SLOT(d_func(), void _q_serviceOwnerChanged(QString,QString,QString)) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusabstractinterface_p.h b/src/dbus/qdbusabstractinterface_p.h new file mode 100644 index 0000000000..fd6c69a51a --- /dev/null +++ b/src/dbus/qdbusabstractinterface_p.h @@ -0,0 +1,104 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// 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> +#include "qdbusconnection_p.h" +#include "private/qobject_p.h" + +#define ANNOTATION_NO_WAIT "org.freedesktop.DBus.Method.NoReply" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +class QDBusAbstractInterfacePrivate : public QObjectPrivate +{ +public: + Q_DECLARE_PUBLIC(QDBusAbstractInterface) + + mutable QDBusConnection connection; // mutable because we want to make calls from const functions + QString service; + QString currentOwner; + QString path; + QString interface; + mutable QDBusError lastError; + + // this is set during creation and never changed + // it can't be const because QDBusInterfacePrivate has one more check + bool isValid; + + QDBusAbstractInterfacePrivate(const QString &serv, const QString &p, + const QString &iface, const QDBusConnection& con, bool dynamic); + virtual ~QDBusAbstractInterfacePrivate() { } + bool canMakeCalls() const; + + // these functions do not check if the property is valid + void property(const QMetaProperty &mp, QVariant &where) const; + bool setProperty(const QMetaProperty &mp, const QVariant &value); + + // return conn's d pointer + inline QDBusConnectionPrivate *connectionPrivate() const + { return QDBusConnectionPrivate::d(connection); } + + void _q_serviceOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner); +}; + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusargument.cpp b/src/dbus/qdbusargument.cpp new file mode 100644 index 0000000000..806b7fec16 --- /dev/null +++ b/src/dbus/qdbusargument.cpp @@ -0,0 +1,1362 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusargument.h" + +#include <qatomic.h> +#include <qbytearray.h> +#include <qlist.h> +#include <qmap.h> +#include <qstring.h> +#include <qstringlist.h> +#include <qvariant.h> +#include <qdatetime.h> +#include <qrect.h> +#include <qline.h> + +#include "qdbusargument_p.h" +#include "qdbusmetatype_p.h" +#include "qdbusutil_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +QDBusArgumentPrivate::~QDBusArgumentPrivate() +{ + if (message) + q_dbus_message_unref(message); +} + +QByteArray QDBusArgumentPrivate::createSignature(int id) +{ + if (!qdbus_loadLibDBus()) + return ""; + + QByteArray signature; + QDBusMarshaller *marshaller = new QDBusMarshaller(0); + marshaller->ba = &signature; + + // run it + void *null = 0; + QVariant v(id, null); + QDBusArgument arg(marshaller); + QDBusMetaType::marshall(arg, v.userType(), v.constData()); + arg.d = 0; + + // delete it + bool ok = marshaller->ok; + delete marshaller; + + if (signature.isEmpty() || !ok || !QDBusUtil::isValidSingleSignature(QString::fromLatin1(signature))) { + qWarning("QDBusMarshaller: type `%s' produces invalid D-BUS signature `%s' " + "(Did you forget to call beginStructure() ?)", + QVariant::typeToName( QVariant::Type(id) ), + signature.isEmpty() ? "<empty>" : signature.constData()); + return ""; + } else if ((signature.at(0) != DBUS_TYPE_ARRAY && signature.at(0) != DBUS_STRUCT_BEGIN_CHAR) || + (signature.at(0) == DBUS_TYPE_ARRAY && (signature.at(1) == DBUS_TYPE_BYTE || + signature.at(1) == DBUS_TYPE_STRING))) { + qWarning("QDBusMarshaller: type `%s' attempts to redefine basic D-BUS type '%s' (%s) " + "(Did you forget to call beginStructure() ?)", + QVariant::typeToName( QVariant::Type(id) ), + signature.constData(), + QVariant::typeToName( QVariant::Type(QDBusMetaType::signatureToType(signature))) ); + return ""; + } + return signature; +} + +bool QDBusArgumentPrivate::checkWrite(QDBusArgumentPrivate *&d) +{ + if (!d) + return false; + if (d->direction == Marshalling) { + if (!d->marshaller()->ok) + return false; + + if (d->message && d->ref != 1) { + QDBusMarshaller *dd = new QDBusMarshaller(d->capabilities); + dd->message = q_dbus_message_copy(d->message); + q_dbus_message_iter_init_append(dd->message, &dd->iterator); + + if (!d->ref.deref()) + delete d; + d = dd; + } + return true; + } + +#ifdef QT_DEBUG + qFatal("QDBusArgument: write from a read-only object"); +#else + qWarning("QDBusArgument: write from a read-only object"); +#endif + return false; +} + +bool QDBusArgumentPrivate::checkRead(QDBusArgumentPrivate *d) +{ + if (!d) + return false; + if (d->direction == Demarshalling) + return true; + +#ifdef QT_DEBUG + qFatal("QDBusArgument: read from a write-only object"); +#else + qWarning("QDBusArgument: read from a write-only object"); +#endif + + return false; +} + +bool QDBusArgumentPrivate::checkReadAndDetach(QDBusArgumentPrivate *&d) +{ + if (!checkRead(d)) + return false; // don't bother + + if (d->ref == 1) + return true; // no need to detach + + QDBusDemarshaller *dd = new QDBusDemarshaller(d->capabilities); + dd->message = q_dbus_message_ref(d->message); + dd->iterator = static_cast<QDBusDemarshaller*>(d)->iterator; + + if (!d->ref.deref()) + delete d; + d = dd; + return true; +} + +/*! + \class QDBusArgument + \inmodule QtDBus + \since 4.2 + + \brief The QDBusArgument class is used to marshall and demarshall D-Bus arguments. + + The class is used to send arguments over D-Bus to remote + applications and to receive them back. D-Bus offers an extensible + type system, based on a few primitive types and associations of + them. See the \l {qdbustypesystem.html}{QtDBus type system} page + for more information on the type system. + + QDBusArgument is the central class in the QtDBus type system, + providing functions to marshall and demarshall the primitive + types. The compound types are then created by association of one + or more of the primitive types in arrays, dictionaries or + structures. + + The following example illustrates how a structure containing an + integer and a string can be constructed using the \l + {qdbustypesystem.html}{QtDBus type system}: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 0 + + The type has to be registered with qDBusRegisterMetaType() before + it can be used with QDBusArgument. Therefore, somewhere in your + program, you should add the following code: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 1 + + Once registered, a type can be used in outgoing method calls + (placed with QDBusAbstractInterface::call()), signal emissions + from registered objects or in incoming calls from remote + applications. + + It is important to note that the \c{operator<<} and \c{operator>>} + streaming functions must always produce the same number of entries + in case of structures, both in reading and in writing (marshalling + and demarshalling), otherwise calls and signals may start to + silently fail. + + The following example illustrates this wrong usage + in context of a class that may contain invalid data: + + \badcode + // Wrongly marshall the MyTime data into a D-Bus argument + QDBusArgument &operator<<(QDBusArgument &argument, const MyTime &mytime) + { + argument.beginStructure(); + if (mytime.isValid) + argument << true << mytime.hour + << mytime.minute << mytime.second; + else + argument << false; + argument.endStructure(); + return argument; + } + \endcode + + In this example, both the \c{operator<<} and the \c{operator>>} + functions may produce a different number of reads/writes. This can + confuse the QtDBus type system and should be avoided. + + \sa QDBusAbstractInterface, {qdbustypesystem.html}{The QtDBus type + system}, {usingadaptors.html}{Using Adaptors}, qdbus_cast() +*/ + +/*! + \enum QDBusArgument::ElementType + \since 4.5 + + This enum describes the type of element held by the argument. + + \value BasicType A basic element, which is understood by + QVariant. The following types are considered basic: bool, + byte, short, ushort, int, uint, qint64, quint64, double, + QString, QByteArray, QDBusObjectPath, QDBusSignature + + \value VariantType The variant element (QDBusVariant) + + \value ArrayType An array element, usually represented by QList<T> + or QVector<T>. Note: QByteArray and associative maps are not + considered arrays, even if the D-Bus protocol transports them as such. + + \value StructureType A custom type represented by a structure, + like QDateTime, QPoint, etc. + + \value MapType An associative container, like QMap<Key, Value> or + QHash<Key, Value> + + \value MapEntryType One entry in an associative container: both + the key and the value form one map-entry type. + + \value UnknownType The type is unknown or we have reached the end + of the list. + + \sa currentType() +*/ + +/*! + \fn qdbus_cast(const QDBusArgument &argument) + \relates QDBusArgument + \since 4.2 + + Attempts to demarshall the contents of \a argument into the type + \c{T}. For example: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 2 + + Note that it is equivalent to the following: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 3 +*/ + +/*! + Constructs an empty QDBusArgument argument. + + An empty QDBusArgument object does not allow either reading or + writing to be performed. +*/ +QDBusArgument::QDBusArgument() +{ + if (!qdbus_loadLibDBus()) { + d = 0; + return; + } + + QDBusMarshaller *dd = new QDBusMarshaller(0); + d = dd; + + // create a new message with any type, we won't sent it anyways + dd->message = q_dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL); + q_dbus_message_iter_init_append(dd->message, &dd->iterator); +} + +/*! + Constructs a copy of the \a other QDBusArgument object. + + Both objects will therefore contain the same state from this point + forward. QDBusArguments are explicitly shared and, therefore, any + modification to either copy will affect the other one too. +*/ +QDBusArgument::QDBusArgument(const QDBusArgument &other) + : d(other.d) +{ + if (d) + d->ref.ref(); +} + +/*! + \internal +*/ +QDBusArgument::QDBusArgument(QDBusArgumentPrivate *dd) + : d(dd) +{ +} + +/*! + Copies the \a other QDBusArgument object into this one. + + Both objects will therefore contain the same state from this point + forward. QDBusArguments are explicitly shared and, therefore, any + modification to either copy will affect the other one too. +*/ +QDBusArgument &QDBusArgument::operator=(const QDBusArgument &other) +{ + qAtomicAssign(d, other.d); + return *this; +} + +/*! + Disposes of the resources associated with this QDBusArgument + object. +*/ +QDBusArgument::~QDBusArgument() +{ + if (d && !d->ref.deref()) + delete d; +} + +/*! + Appends the primitive value \a arg of type \c{BYTE} to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(uchar arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the primitive value \a arg of type \c{BOOLEAN} to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(bool arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the primitive value \a arg of type \c{INT16} to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(short arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the primitive value \a arg of type \c{UINT16} to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(ushort arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the primitive value \a arg of type \c{INT32} to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(int arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the primitive value \a arg of type \c{UINT32} to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(uint arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the primitive value \a arg of type \c{INT64} to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(qlonglong arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the primitive value \a arg of type \c{UINT64} to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(qulonglong arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the primitive value \a arg of type \c{DOUBLE} (double-precision + floating-point) to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(double arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the primitive value \a arg of type \c{STRING} (Unicode character + string) to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(const QString &arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + \internal + Appends the primitive value \a arg of type \c{OBJECT_PATH} (path to a D-Bus + object) to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(const QDBusObjectPath &arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + \internal + Appends the primitive value \a arg of type \c{SIGNATURE} (D-Bus type + signature) to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(const QDBusSignature &arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + \since 4.8 + \internal + Appends the primitive value \a arg of type \c{UNIX_FILE_DESCRIPTOR} (Unix + File Descriptor) to the D-Bus stream. +*/ +QDBusArgument &QDBusArgument::operator<<(const QDBusUnixFileDescriptor &arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the primitive value \a arg of type \c{VARIANT} to the D-Bus stream. + + A D-Bus variant type can contain any type, including other + variants. It is similar to the Qt QVariant type. +*/ +QDBusArgument &QDBusArgument::operator<<(const QDBusVariant &arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the QStringList given by \a arg as \c{ARRAY of STRING} + to the D-Bus stream. + + QStringList and QByteArray are the only two non-primitive types + that are supported directly by QDBusArgument because of their + widespread usage in Qt applications. + + Other arrays are supported through compound types in QtDBus. +*/ +QDBusArgument &QDBusArgument::operator<<(const QStringList &arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \overload + Appends the QByteArray given by \a arg as \c{ARRAY of BYTE} + to the D-Bus stream. + + QStringList and QByteArray are the only two non-primitive types + that are supported directly by QDBusArgument because of their + widespread usage in Qt applications. + + Other arrays are supported through compound types in QtDBus. +*/ +QDBusArgument &QDBusArgument::operator<<(const QByteArray &arg) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->append(arg); + return *this; +} + +/*! + \internal + \since 4.5 + + Appends the variant \a v. + + \sa asVariant() +*/ +void QDBusArgument::appendVariant(const QVariant &v) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d->marshaller()->appendVariantInternal(v); +} + +/*! + \internal + Returns the type signature of the D-Bus type this QDBusArgument + object is currently pointing to. +*/ +QString QDBusArgument::currentSignature() const +{ + if (!d) + return QString(); + if (d->direction == QDBusArgumentPrivate::Demarshalling) + return d->demarshaller()->currentSignature(); + else + return d->marshaller()->currentSignature(); +} + +/*! + \since 4.5 + Returns the classification of the current element type. If an + error decoding the type occurs or if we're at the end of the + argument, this function returns QDBusArgument::UnknownType. + + This function only makes sense when demarshalling arguments. If it + is used while marshalling, it will always return UnknownType. +*/ +QDBusArgument::ElementType QDBusArgument::currentType() const +{ + if (!d) + return UnknownType; + if (d->direction == QDBusArgumentPrivate::Demarshalling) + return d->demarshaller()->currentType(); + return UnknownType; +} + +/*! + Extracts one D-BUS primitive argument of type \c{BYTE} from the + D-BUS stream and puts it into \a arg. +*/ +const QDBusArgument &QDBusArgument::operator>>(uchar &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toByte(); + return *this; +} + +/*! + \overload + Extracts one D-Bus primitive argument of type \c{BOOLEAN} from the + D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(bool &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toBool(); + return *this; +} + +/*! + \overload + Extracts one D-Bus primitive argument of type \c{UINT16} from the + D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(ushort &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toUShort(); + return *this; +} + +/*! + \overload + Extracts one D-Bus primitive argument of type \c{INT16} from the + D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(short &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toShort(); + return *this; +} + +/*! + \overload + Extracts one D-Bus primitive argument of type \c{INT32} from the + D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(int &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toInt(); + return *this; +} + +/*! + \overload + Extracts one D-Bus primitive argument of type \c{UINT32} from the + D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(uint &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toUInt(); + return *this; +} + +/*! + \overload + Extracts one D-Bus primitive argument of type \c{INT64} from the + D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(qlonglong &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toLongLong(); + return *this; +} + +/*! + \overload + Extracts one D-Bus primitive argument of type \c{UINT64} from the + D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(qulonglong &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toULongLong(); + return *this; +} + +/*! + \overload + Extracts one D-Bus primitive argument of type \c{DOUBLE} + (double-precision floating pount) from the D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(double &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toDouble(); + return *this; +} + +/*! + \overload + Extracts one D-Bus primitive argument of type \c{STRING} (Unicode + character string) from the D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(QString &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toString(); + return *this; +} + +/*! + \overload + \internal + Extracts one D-Bus primitive argument of type \c{OBJECT_PATH} + (D-Bus path to an object) from the D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(QDBusObjectPath &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toObjectPath(); + return *this; +} + +/*! + \overload + \internal + Extracts one D-Bus primitive argument of type \c{SIGNATURE} (D-Bus + type signature) from the D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(QDBusSignature &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toSignature(); + return *this; +} + +/*! + \overload + \since 4.8 + \internal + Extracts one D-Bus primitive argument of type \c{UNIX_FILE_DESCRIPTOR} + (Unix file descriptor) from the D-Bus stream. +*/ +const QDBusArgument &QDBusArgument::operator>>(QDBusUnixFileDescriptor &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toUnixFileDescriptor(); + return *this; +} + +/*! + \overload + Extracts one D-Bus primitive argument of type \c{VARIANT} from the + D-Bus stream. + + A D-Bus variant type can contain any type, including other + variants. It is similar to the Qt QVariant type. + + In case the variant contains a type not directly supported by + QDBusArgument, the value of the returned QDBusVariant will contain + another QDBusArgument. It is your responsibility to further + demarshall it into another type. +*/ +const QDBusArgument &QDBusArgument::operator>>(QDBusVariant &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toVariant(); + return *this; +} + +/*! + \overload + Extracts an array of strings from the D-Bus stream and return it + as a QStringList. + + QStringList and QByteArray are the only two non-primitive types + that are supported directly by QDBusArgument because of their + widespread usage in Qt applications. + + Other arrays are supported through compound types in QtDBus. +*/ +const QDBusArgument &QDBusArgument::operator>>(QStringList &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toStringList(); + return *this; +} + +/*! + \overload + Extracts an array of bytes from the D-Bus stream and return it + as a QByteArray. + + QStringList and QByteArray are the only two non-primitive types + that are supported directly by QDBusArgument because of their + widespread usage in Qt applications. + + Other arrays are supported through compound types in QtDBus. +*/ +const QDBusArgument &QDBusArgument::operator>>(QByteArray &arg) const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + arg = d->demarshaller()->toByteArray(); + return *this; +} + +/*! + Opens a new D-Bus structure suitable for appending new arguments. + + This function is used usually in \c{operator<<} streaming + operators, as in the following example: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 4 + + Structures can contain other structures, so the following code is + also valid: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 5 + + \sa endStructure(), beginArray(), beginMap() +*/ +void QDBusArgument::beginStructure() +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d = d->marshaller()->beginStructure(); +} + +/*! + Closes a D-Bus structure opened with beginStructure(). This function must be called + same number of times that beginStructure() is called. + + \sa beginStructure(), endArray(), endMap() +*/ +void QDBusArgument::endStructure() +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d = d->marshaller()->endStructure(); +} + +/*! + Opens a new D-Bus array suitable for appending elements of meta-type \a id. + + This function is used usually in \c{operator<<} streaming + operators, as in the following example: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 6 + + If the type you want to marshall is a QList, QVector or any of the + Qt's \l {Container Classes} that take one template parameter, + you need not declare an \c{operator<<} function for it, since + QtDBus provides generic templates to do the job of marshalling + the data. The same applies for STL's sequence containers, such + as \c {std::list}, \c {std::vector}, etc. + + \sa endArray(), beginStructure(), beginMap() +*/ +void QDBusArgument::beginArray(int id) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d = d->marshaller()->beginArray(id); +} + +/*! + Closes a D-Bus array opened with beginArray(). This function must be called + same number of times that beginArray() is called. + + \sa beginArray(), endStructure(), endMap() +*/ +void QDBusArgument::endArray() +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d = d->marshaller()->endArray(); +} + +/*! + Opens a new D-Bus map suitable for + appending elements. Maps are containers that associate one entry + (the key) to another (the value), such as Qt's QMap or QHash. The + ids of the map's key and value meta types must be passed in \a kid + and \a vid respectively. + + This function is used usually in \c{operator<<} streaming + operators, as in the following example: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 7 + + If the type you want to marshall is a QMap or QHash, you need not + declare an \c{operator<<} function for it, since QtDBus provides + generic templates to do the job of marshalling the data. + + \sa endMap(), beginStructure(), beginArray(), beginMapEntry() +*/ +void QDBusArgument::beginMap(int kid, int vid) +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d = d->marshaller()->beginMap(kid, vid); +} + +/*! + Closes a D-Bus map opened with beginMap(). This function must be called + same number of times that beginMap() is called. + + \sa beginMap(), endStructure(), endArray() +*/ +void QDBusArgument::endMap() +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d = d->marshaller()->endMap(); +} + +/*! + Opens a D-Bus map entry suitable for + appending the key and value entries. This function is only valid + when a map has been opened with beginMap(). + + See beginMap() for an example of usage of this function. + + \sa endMapEntry(), beginMap() +*/ +void QDBusArgument::beginMapEntry() +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d = d->marshaller()->beginMapEntry(); +} + +/*! + Closes a D-Bus map entry opened with beginMapEntry(). This function must be called + same number of times that beginMapEntry() is called. + + \sa beginMapEntry() +*/ +void QDBusArgument::endMapEntry() +{ + if (QDBusArgumentPrivate::checkWrite(d)) + d = d->marshaller()->endMapEntry(); +} + +/*! + Opens a D-Bus structure suitable for extracting elements. + + This function is used usually in \c{operator>>} streaming + operators, as in the following example: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 8 + + \sa endStructure(), beginArray(), beginMap() +*/ +void QDBusArgument::beginStructure() const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + d = d->demarshaller()->beginStructure(); +} + +/*! + Closes the D-Bus structure and allow extracting of the next element + after the structure. + + \sa beginStructure() +*/ +void QDBusArgument::endStructure() const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + d = d->demarshaller()->endStructure(); +} + +/*! + Recurses into the D-Bus array to allow extraction of + the array elements. + + This function is used usually in \c{operator>>} streaming + operators, as in the following example: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 9 + + If the type you want to demarshall is a QList, QVector or any of the + Qt's \l {Container Classes} that take one template parameter, you + need not declare an \c{operator>>} function for it, since QtDBus + provides generic templates to do the job of demarshalling the data. + The same applies for STL's sequence containers, such as \c {std::list}, + \c {std::vector}, etc. + + \sa atEnd(), beginStructure(), beginMap() +*/ +void QDBusArgument::beginArray() const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + d = d->demarshaller()->beginArray(); +} + +/*! + Closes the D-Bus array and allow extracting of the next element + after the array. + + \sa beginArray() +*/ +void QDBusArgument::endArray() const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + d = d->demarshaller()->endArray(); +} + +/*! + Recurses into the D-Bus map to allow extraction of + the map's elements. + + This function is used usually in \c{operator>>} streaming + operators, as in the following example: + + \snippet doc/src/snippets/code/src_qdbus_qdbusargument.cpp 10 + + If the type you want to demarshall is a QMap or QHash, you need not + declare an \c{operator>>} function for it, since QtDBus provides + generic templates to do the job of demarshalling the data. + + \sa endMap(), beginStructure(), beginArray(), beginMapEntry() +*/ +void QDBusArgument::beginMap() const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + d = d->demarshaller()->beginMap(); +} + +/*! + Closes the D-Bus map and allow extracting of the next element + after the map. + + \sa beginMap() +*/ +void QDBusArgument::endMap() const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + d = d->demarshaller()->endMap(); +} + +/*! + Recurses into the D-Bus map entry to allow extraction + of the key and value pair. + + See beginMap() for an example of how this function is usually used. + + \sa endMapEntry(), beginMap() +*/ +void QDBusArgument::beginMapEntry() const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + d = d->demarshaller()->beginMapEntry(); +} + +/*! + Closes the D-Bus map entry and allow extracting of the next element + on the map. + + \sa beginMapEntry() +*/ +void QDBusArgument::endMapEntry() const +{ + if (QDBusArgumentPrivate::checkReadAndDetach(d)) + d = d->demarshaller()->endMapEntry(); +} + +/*! + Returns true if there are no more elements to be extracted from + this QDBusArgument. This function is usually used in QDBusArgument + objects returned from beginMap() and beginArray(). +*/ +bool QDBusArgument::atEnd() const +{ + if (QDBusArgumentPrivate::checkRead(d)) + return d->demarshaller()->atEnd(); + + return true; // at least, stop reading +} + +/*! + \since 4.5 + + Returns the current argument in the form of a QVariant. Basic + types will be decoded and returned in the QVariant, but for + complex types, this function will return a QDBusArgument object in + the QVariant. It is the caller's responsibility to decode the + argument (for example, by calling asVariant() in it). + + For example, if the current argument is an INT32, this function + will return a QVariant with an argument of type QVariant::Int. For + an array of INT32, it will return a QVariant containing a + QDBusArgument. + + If an error occurs or if there are no more arguments to decode + (i.e., we are at the end of the argument list), this function will + return an invalid QVariant. + + \sa atEnd() +*/ +QVariant QDBusArgument::asVariant() const +{ + if (QDBusArgumentPrivate::checkRead(d)) + return d->demarshaller()->toVariantInternal(); + + return QVariant(); +} + +QT_END_NAMESPACE + +// for optimization purposes, we include the marshallers here +#include "qdbusmarshaller.cpp" +#include "qdbusdemarshaller.cpp" + +QT_BEGIN_NAMESPACE + +// QDBusArgument operators + +const QDBusArgument &operator>>(const QDBusArgument &a, QVariant &v) +{ + QDBusVariant dbv; + a >> dbv; + v = dbv.variant(); + return a; +} + +// QVariant types +#ifndef QDBUS_NO_SPECIALTYPES +const QDBusArgument &operator>>(const QDBusArgument &a, QDate &date) +{ + int y, m, d; + a.beginStructure(); + a >> y >> m >> d; + a.endStructure(); + + if (y != 0 && m != 0 && d != 0) + date.setYMD(y, m, d); + else + date = QDate(); + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QDate &date) +{ + a.beginStructure(); + if (date.isValid()) + a << date.year() << date.month() << date.day(); + else + a << 0 << 0 << 0; + a.endStructure(); + return a; +} + +const QDBusArgument &operator>>(const QDBusArgument &a, QTime &time) +{ + int h, m, s, ms; + a.beginStructure(); + a >> h >> m >> s >> ms; + a.endStructure(); + + if (h < 0) + time = QTime(); + else + time.setHMS(h, m, s, ms); + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QTime &time) +{ + a.beginStructure(); + if (time.isValid()) + a << time.hour() << time.minute() << time.second() << time.msec(); + else + a << -1 << -1 << -1 << -1; + a.endStructure(); + return a; +} + +const QDBusArgument &operator>>(const QDBusArgument &a, QDateTime &dt) +{ + QDate date; + QTime time; + int timespec; + + a.beginStructure(); + a >> date >> time >> timespec; + a.endStructure(); + + dt = QDateTime(date, time, Qt::TimeSpec(timespec)); + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QDateTime &dt) +{ + a.beginStructure(); + a << dt.date() << dt.time() << int(dt.timeSpec()); + a.endStructure(); + return a; +} + +const QDBusArgument &operator>>(const QDBusArgument &a, QRect &rect) +{ + int x, y, width, height; + a.beginStructure(); + a >> x >> y >> width >> height; + a.endStructure(); + + rect.setRect(x, y, width, height); + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QRect &rect) +{ + a.beginStructure(); + a << rect.x() << rect.y() << rect.width() << rect.height(); + a.endStructure(); + + return a; +} + +const QDBusArgument &operator>>(const QDBusArgument &a, QRectF &rect) +{ + double x, y, width, height; + a.beginStructure(); + a >> x >> y >> width >> height; + a.endStructure(); + + rect.setRect(qreal(x), qreal(y), qreal(width), qreal(height)); + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QRectF &rect) +{ + a.beginStructure(); + a << double(rect.x()) << double(rect.y()) << double(rect.width()) << double(rect.height()); + a.endStructure(); + + return a; +} + +const QDBusArgument &operator>>(const QDBusArgument &a, QSize &size) +{ + a.beginStructure(); + a >> size.rwidth() >> size.rheight(); + a.endStructure(); + + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QSize &size) +{ + a.beginStructure(); + a << size.width() << size.height(); + a.endStructure(); + + return a; +} + +const QDBusArgument &operator>>(const QDBusArgument &a, QSizeF &size) +{ + double width, height; + a.beginStructure(); + a >> width >> height; + a.endStructure(); + + size.setWidth(qreal(width)); + size.setHeight(qreal(height)); + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QSizeF &size) +{ + a.beginStructure(); + a << double(size.width()) << double(size.height()); + a.endStructure(); + + return a; +} + +const QDBusArgument &operator>>(const QDBusArgument &a, QPoint &pt) +{ + a.beginStructure(); + a >> pt.rx() >> pt.ry(); + a.endStructure(); + + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QPoint &pt) +{ + a.beginStructure(); + a << pt.x() << pt.y(); + a.endStructure(); + + return a; +} + +const QDBusArgument &operator>>(const QDBusArgument &a, QPointF &pt) +{ + double x, y; + a.beginStructure(); + a >> x >> y; + a.endStructure(); + + pt.setX(qreal(x)); + pt.setY(qreal(y)); + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QPointF &pt) +{ + a.beginStructure(); + a << double(pt.x()) << double(pt.y()); + a.endStructure(); + + return a; +} + +const QDBusArgument &operator>>(const QDBusArgument &a, QLine &line) +{ + QPoint p1, p2; + a.beginStructure(); + a >> p1 >> p2; + a.endStructure(); + + line = QLine(p1, p2); + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QLine &line) +{ + a.beginStructure(); + a << line.p1() << line.p2(); + a.endStructure(); + + return a; +} + +const QDBusArgument &operator>>(const QDBusArgument &a, QLineF &line) +{ + QPointF p1, p2; + a.beginStructure(); + a >> p1 >> p2; + a.endStructure(); + + line = QLineF(p1, p2); + return a; +} + +QDBusArgument &operator<<(QDBusArgument &a, const QLineF &line) +{ + a.beginStructure(); + a << line.p1() << line.p2(); + a.endStructure(); + + return a; +} +#endif + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusargument.h b/src/dbus/qdbusargument.h new file mode 100644 index 0000000000..f80723e6b4 --- /dev/null +++ b/src/dbus/qdbusargument.h @@ -0,0 +1,405 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSARGUMENT_H +#define QDBUSARGUMENT_H + +#include <QtCore/qbytearray.h> +#include <QtCore/qhash.h> +#include <QtCore/qglobal.h> +#include <QtCore/qlist.h> +#include <QtCore/qmap.h> +#include <QtCore/qstring.h> +#include <QtCore/qstringlist.h> +#include <QtCore/qvariant.h> +#include <QtDBus/qdbusextratypes.h> +#include <QtDBus/qdbusmacros.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusUnixFileDescriptor; + +class QDBusArgumentPrivate; +class QDBusDemarshaller; +class QDBusMarshaller; +class Q_DBUS_EXPORT QDBusArgument +{ +public: + enum ElementType { + BasicType, + VariantType, + ArrayType, + StructureType, + MapType, + MapEntryType, + UnknownType = -1 + }; + + QDBusArgument(); + QDBusArgument(const QDBusArgument &other); + QDBusArgument &operator=(const QDBusArgument &other); + ~QDBusArgument(); + + // used for marshalling (Qt -> D-BUS) + QDBusArgument &operator<<(uchar arg); + QDBusArgument &operator<<(bool arg); + QDBusArgument &operator<<(short arg); + QDBusArgument &operator<<(ushort arg); + QDBusArgument &operator<<(int arg); + QDBusArgument &operator<<(uint arg); + QDBusArgument &operator<<(qlonglong arg); + QDBusArgument &operator<<(qulonglong arg); + QDBusArgument &operator<<(double arg); + QDBusArgument &operator<<(const QString &arg); + QDBusArgument &operator<<(const QDBusVariant &arg); + QDBusArgument &operator<<(const QDBusObjectPath &arg); + QDBusArgument &operator<<(const QDBusSignature &arg); + QDBusArgument &operator<<(const QDBusUnixFileDescriptor &arg); + QDBusArgument &operator<<(const QStringList &arg); + QDBusArgument &operator<<(const QByteArray &arg); + + void beginStructure(); + void endStructure(); + void beginArray(int elementMetaTypeId); + void endArray(); + void beginMap(int keyMetaTypeId, int valueMetaTypeId); + void endMap(); + void beginMapEntry(); + void endMapEntry(); + + void appendVariant(const QVariant &v); + + // used for de-marshalling (D-BUS -> Qt) + QString currentSignature() const; + ElementType currentType() const; + + const QDBusArgument &operator>>(uchar &arg) const; + const QDBusArgument &operator>>(bool &arg) const; + const QDBusArgument &operator>>(short &arg) const; + const QDBusArgument &operator>>(ushort &arg) const; + const QDBusArgument &operator>>(int &arg) const; + const QDBusArgument &operator>>(uint &arg) const; + const QDBusArgument &operator>>(qlonglong &arg) const; + const QDBusArgument &operator>>(qulonglong &arg) const; + const QDBusArgument &operator>>(double &arg) const; + const QDBusArgument &operator>>(QString &arg) const; + const QDBusArgument &operator>>(QDBusVariant &arg) const; + const QDBusArgument &operator>>(QDBusObjectPath &arg) const; + const QDBusArgument &operator>>(QDBusSignature &arg) const; + const QDBusArgument &operator>>(QDBusUnixFileDescriptor &arg) const; + const QDBusArgument &operator>>(QStringList &arg) const; + const QDBusArgument &operator>>(QByteArray &arg) const; + + void beginStructure() const; + void endStructure() const; + void beginArray() const; + void endArray() const; + void beginMap() const; + void endMap() const; + void beginMapEntry() const; + void endMapEntry() const; + bool atEnd() const; + + QVariant asVariant() const; + +protected: + QDBusArgument(QDBusArgumentPrivate *d); + friend class QDBusArgumentPrivate; + mutable QDBusArgumentPrivate *d; +}; + +template<typename T> inline T qdbus_cast(const QDBusArgument &arg +#ifndef Q_QDOC +, T * = 0 +#endif + ) +{ + T item; + arg >> item; + return item; +} + +template<typename T> inline T qdbus_cast(const QVariant &v +#ifndef Q_QDOC +, T * = 0 +#endif + ) +{ + int id = v.userType(); + if (id == qMetaTypeId<QDBusArgument>()) + return qdbus_cast<T>(qvariant_cast<QDBusArgument>(v)); + else + return qvariant_cast<T>(v); +} + +// specialize for QVariant, allowing it to be used in place of QDBusVariant +template<> inline QVariant qdbus_cast<QVariant>(const QDBusArgument &arg, QVariant *) +{ + QDBusVariant item; + arg >> item; + return item.variant(); +} +template<> inline QVariant qdbus_cast<QVariant>(const QVariant &v, QVariant *) +{ + return qdbus_cast<QDBusVariant>(v).variant(); +} + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QVariant &v); + +// QVariant types +#ifndef QDBUS_NO_SPECIALTYPES + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QDate &date); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QDate &date); + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QTime &time); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QTime &time); + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QDateTime &dt); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QDateTime &dt); + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QRect &rect); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QRect &rect); + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QRectF &rect); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QRectF &rect); + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QSize &size); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QSize &size); + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QSizeF &size); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QSizeF &size); + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QPoint &pt); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QPoint &pt); + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QPointF &pt); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QPointF &pt); + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QLine &line); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QLine &line); + +Q_DBUS_EXPORT const QDBusArgument &operator>>(const QDBusArgument &a, QLineF &line); +Q_DBUS_EXPORT QDBusArgument &operator<<(QDBusArgument &a, const QLineF &line); +#endif + +template<template <typename> class Container, typename T> +inline QDBusArgument &operator<<(QDBusArgument &arg, const Container<T> &list) +{ + int id = qMetaTypeId<T>(); + arg.beginArray(id); + typename Container<T>::const_iterator it = list.begin(); + typename Container<T>::const_iterator end = list.end(); + for ( ; it != end; ++it) + arg << *it; + arg.endArray(); + return arg; +} + +template<template <typename> class Container, typename T> +inline const QDBusArgument &operator>>(const QDBusArgument &arg, Container<T> &list) +{ + arg.beginArray(); + list.clear(); + while (!arg.atEnd()) { + T item; + arg >> item; + list.push_back(item); + } + + arg.endArray(); + return arg; +} + +// QList specializations +template<typename T> +inline QDBusArgument &operator<<(QDBusArgument &arg, const QList<T> &list) +{ + int id = qMetaTypeId<T>(); + arg.beginArray(id); + typename QList<T>::ConstIterator it = list.constBegin(); + typename QList<T>::ConstIterator end = list.constEnd(); + for ( ; it != end; ++it) + arg << *it; + arg.endArray(); + return arg; +} + +template<typename T> +inline const QDBusArgument &operator>>(const QDBusArgument &arg, QList<T> &list) +{ + arg.beginArray(); + list.clear(); + while (!arg.atEnd()) { + T item; + arg >> item; + list.push_back(item); + } + arg.endArray(); + + return arg; +} + +inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantList &list) +{ + int id = qMetaTypeId<QDBusVariant>(); + arg.beginArray(id); + QVariantList::ConstIterator it = list.constBegin(); + QVariantList::ConstIterator end = list.constEnd(); + for ( ; it != end; ++it) + arg << QDBusVariant(*it); + arg.endArray(); + return arg; +} + +// QMap specializations +template<typename Key, typename T> +inline QDBusArgument &operator<<(QDBusArgument &arg, const QMap<Key, T> &map) +{ + int kid = qMetaTypeId<Key>(); + int vid = qMetaTypeId<T>(); + arg.beginMap(kid, vid); + typename QMap<Key, T>::ConstIterator it = map.constBegin(); + typename QMap<Key, T>::ConstIterator end = map.constEnd(); + for ( ; it != end; ++it) { + arg.beginMapEntry(); + arg << it.key() << it.value(); + arg.endMapEntry(); + } + arg.endMap(); + return arg; +} + +template<typename Key, typename T> +inline const QDBusArgument &operator>>(const QDBusArgument &arg, QMap<Key, T> &map) +{ + arg.beginMap(); + map.clear(); + while (!arg.atEnd()) { + Key key; + T value; + arg.beginMapEntry(); + arg >> key >> value; + map.insertMulti(key, value); + arg.endMapEntry(); + } + arg.endMap(); + return arg; +} + +inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantMap &map) +{ + arg.beginMap(QVariant::String, qMetaTypeId<QDBusVariant>()); + QVariantMap::ConstIterator it = map.constBegin(); + QVariantMap::ConstIterator end = map.constEnd(); + for ( ; it != end; ++it) { + arg.beginMapEntry(); + arg << it.key() << QDBusVariant(it.value()); + arg.endMapEntry(); + } + arg.endMap(); + return arg; +} + +// QHash specializations +template<typename Key, typename T> +inline QDBusArgument &operator<<(QDBusArgument &arg, const QHash<Key, T> &map) +{ + int kid = qMetaTypeId<Key>(); + int vid = qMetaTypeId<T>(); + arg.beginMap(kid, vid); + typename QHash<Key, T>::ConstIterator it = map.constBegin(); + typename QHash<Key, T>::ConstIterator end = map.constEnd(); + for ( ; it != end; ++it) { + arg.beginMapEntry(); + arg << it.key() << it.value(); + arg.endMapEntry(); + } + arg.endMap(); + return arg; +} + +template<typename Key, typename T> +inline const QDBusArgument &operator>>(const QDBusArgument &arg, QHash<Key, T> &map) +{ + arg.beginMap(); + map.clear(); + while (!arg.atEnd()) { + Key key; + T value; + arg.beginMapEntry(); + arg >> key >> value; + map.insertMulti(key, value); + arg.endMapEntry(); + } + arg.endMap(); + return arg; +} + +inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantHash &map) +{ + arg.beginMap(QVariant::String, qMetaTypeId<QDBusVariant>()); + QVariantHash::ConstIterator it = map.constBegin(); + QVariantHash::ConstIterator end = map.constEnd(); + for ( ; it != end; ++it) { + arg.beginMapEntry(); + arg << it.key() << QDBusVariant(it.value()); + arg.endMapEntry(); + } + arg.endMap(); + return arg; +} + + +QT_END_NAMESPACE + +Q_DECLARE_METATYPE(QDBusArgument) + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusargument_p.h b/src/dbus/qdbusargument_p.h new file mode 100644 index 0000000000..1c713a3433 --- /dev/null +++ b/src/dbus/qdbusargument_p.h @@ -0,0 +1,222 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSARGUMENT_P_H +#define QDBUSARGUMENT_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of the QLibrary class. This header file may change from +// version to version without notice, or even be removed. +// +// We mean it. +// + +#include <qdbusargument.h> +#include "qdbusunixfiledescriptor.h" +#include "qdbus_symbols_p.h" + +#ifndef QT_NO_DBUS + +#ifndef DBUS_TYPE_UNIX_FD +# define DBUS_TYPE_UNIX_FD int('h') +# define DBUS_TYPE_UNIX_FD_AS_STRING "h" +#endif + +QT_BEGIN_NAMESPACE + +class QDBusMarshaller; +class QDBusDemarshaller; +class QDBusArgumentPrivate +{ +public: + inline QDBusArgumentPrivate(int flags = 0) + : message(0), ref(1), capabilities(flags) + { } + ~QDBusArgumentPrivate(); + + static bool checkRead(QDBusArgumentPrivate *d); + static bool checkReadAndDetach(QDBusArgumentPrivate *&d); + static bool checkWrite(QDBusArgumentPrivate *&d); + + QDBusMarshaller *marshaller(); + QDBusDemarshaller *demarshaller(); + + static QByteArray createSignature(int id); + static inline QDBusArgument create(QDBusArgumentPrivate *d) + { + QDBusArgument q(d); + return q; + } + static inline QDBusArgumentPrivate *d(QDBusArgument &q) + { return q.d; } + +public: + DBusMessage *message; + QAtomicInt ref; + int capabilities; + enum Direction { + Marshalling, + Demarshalling + } direction; +}; + +class QDBusMarshaller: public QDBusArgumentPrivate +{ +public: + QDBusMarshaller(int flags) : QDBusArgumentPrivate(flags), parent(0), ba(0), closeCode(0), ok(true) + { direction = Marshalling; } + ~QDBusMarshaller(); + + QString currentSignature(); + + void append(uchar arg); + void append(bool arg); + void append(short arg); + void append(ushort arg); + void append(int arg); + void append(uint arg); + void append(qlonglong arg); + void append(qulonglong arg); + void append(double arg); + void append(const QString &arg); + void append(const QDBusObjectPath &arg); + void append(const QDBusSignature &arg); + void append(const QDBusUnixFileDescriptor &arg); + void append(const QStringList &arg); + void append(const QByteArray &arg); + bool append(const QDBusVariant &arg); // this one can fail + + QDBusMarshaller *beginStructure(); + QDBusMarshaller *endStructure(); + QDBusMarshaller *beginArray(int id); + QDBusMarshaller *endArray(); + QDBusMarshaller *beginMap(int kid, int vid); + QDBusMarshaller *endMap(); + QDBusMarshaller *beginMapEntry(); + QDBusMarshaller *endMapEntry(); + QDBusMarshaller *beginCommon(int code, const char *signature); + QDBusMarshaller *endCommon(); + void open(QDBusMarshaller &sub, int code, const char *signature); + void close(); + void error(const QString &message); + + bool appendVariantInternal(const QVariant &arg); + bool appendRegisteredType(const QVariant &arg); + bool appendCrossMarshalling(QDBusDemarshaller *arg); + +public: + DBusMessageIter iterator; + QDBusMarshaller *parent; + QByteArray *ba; + QString errorString; + char closeCode; + bool ok; + +private: + Q_DISABLE_COPY(QDBusMarshaller) +}; + +class QDBusDemarshaller: public QDBusArgumentPrivate +{ +public: + inline QDBusDemarshaller(int flags) : QDBusArgumentPrivate(flags), parent(0) + { direction = Demarshalling; } + ~QDBusDemarshaller(); + + QString currentSignature(); + + uchar toByte(); + bool toBool(); + ushort toUShort(); + short toShort(); + int toInt(); + uint toUInt(); + qlonglong toLongLong(); + qulonglong toULongLong(); + double toDouble(); + QString toString(); + QDBusObjectPath toObjectPath(); + QDBusSignature toSignature(); + QDBusUnixFileDescriptor toUnixFileDescriptor(); + QDBusVariant toVariant(); + QStringList toStringList(); + QByteArray toByteArray(); + + QDBusDemarshaller *beginStructure(); + QDBusDemarshaller *endStructure(); + QDBusDemarshaller *beginArray(); + QDBusDemarshaller *endArray(); + QDBusDemarshaller *beginMap(); + QDBusDemarshaller *endMap(); + QDBusDemarshaller *beginMapEntry(); + QDBusDemarshaller *endMapEntry(); + QDBusDemarshaller *beginCommon(); + QDBusDemarshaller *endCommon(); + QDBusArgument duplicate(); + inline void close() { } + + bool atEnd(); + + QVariant toVariantInternal(); + QDBusArgument::ElementType currentType(); + +public: + DBusMessageIter iterator; + QDBusDemarshaller *parent; + +private: + Q_DISABLE_COPY(QDBusDemarshaller) +}; + +inline QDBusMarshaller *QDBusArgumentPrivate::marshaller() +{ return static_cast<QDBusMarshaller *>(this); } + +inline QDBusDemarshaller *QDBusArgumentPrivate::demarshaller() +{ return static_cast<QDBusDemarshaller *>(this); } + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusconnection.cpp b/src/dbus/qdbusconnection.cpp new file mode 100644 index 0000000000..c8cf6eaf66 --- /dev/null +++ b/src/dbus/qdbusconnection.cpp @@ -0,0 +1,1154 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <qdebug.h> +#include <qcoreapplication.h> +#include <qstringlist.h> +#include <qthread.h> + +#include "qdbusconnection.h" +#include "qdbusconnectioninterface.h" +#include "qdbuserror.h" +#include "qdbusmessage.h" +#include "qdbusmessage_p.h" +#include "qdbusconnection_p.h" +#include "qdbusinterface_p.h" +#include "qdbusutil_p.h" +#include "qdbusconnectionmanager_p.h" + +#include "qdbusthreaddebug_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +Q_GLOBAL_STATIC(QDBusConnectionManager, _q_manager) + +QDBusConnectionPrivate *QDBusConnectionManager::sender() const +{ + QMutexLocker locker(&senderMutex); + return connection(senderName); +} + +void QDBusConnectionManager::setSender(const QDBusConnectionPrivate *s) +{ + QMutexLocker locker(&senderMutex); + senderName = (s ? s->name : QString()); +} + +QDBusConnectionPrivate *QDBusConnectionManager::connection(const QString &name) const +{ + return connectionHash.value(name, 0); +} + +void QDBusConnectionManager::removeConnection(const QString &name) +{ + QDBusConnectionPrivate *d = 0; + d = connectionHash.take(name); + if (d && !d->ref.deref()) + d->deleteYourself(); + + // Static objects may be keeping the connection open. + // However, it is harmless to have outstanding references to a connection that is + // closing as long as those references will be soon dropped without being used. + + // ### Output a warning if connections are being used after they have been removed. +} + +QDBusConnectionManager::~QDBusConnectionManager() +{ + for (QHash<QString, QDBusConnectionPrivate *>::const_iterator it = connectionHash.constBegin(); + it != connectionHash.constEnd(); ++it) { + QDBusConnectionPrivate *d = it.value(); + if (!d->ref.deref()) + d->deleteYourself(); + else + d->closeConnection(); + } + connectionHash.clear(); +} + +QDBusConnectionManager* QDBusConnectionManager::instance() +{ + return _q_manager(); +} + +Q_DBUS_EXPORT void qDBusBindToApplication(); +void qDBusBindToApplication() +{ +} + +void QDBusConnectionManager::setConnection(const QString &name, QDBusConnectionPrivate *c) +{ + connectionHash[name] = c; + c->name = name; +} + +/*! + \fn QDBusConnection &QDBusConnection::sessionBus() + \relates QDBusConnection + + Returns a QDBusConnection object opened with the session bus. The object + reference returned by this function is valid until the application terminates, + at which point the connection will be closed and the object deleted. +*/ +/*! + \fn QDBusConnection &QDBusConnection::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 + \inmodule QtDBus + \since 4.2 + + \brief The QDBusConnection class represents 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 connectToBus() 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 disconnectFromBus() + function. + + Once disconnected, calling connectToBus() will not reestablish a + connection, you must create a new QDBusConnection instance. + + As a convenience for the two most common connection types, the + sessionBus() and 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 connectToBus() 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, the "alias" for the bus that started the + service + + 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::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 ExportScriptableSlots export this object's scriptable slots + \value ExportScriptableSignals export this object's scriptable signals + \value ExportScriptableProperties export this object's scriptable properties + \value ExportScriptableInvokables export this object's scriptable invokables + \value ExportScriptableContents shorthand form for ExportScriptableSlots | + ExportScriptableSignals | + ExportScriptableProperties + + \value ExportNonScriptableSlots export this object's non-scriptable slots + \value ExportNonScriptableSignals export this object's non-scriptable signals + \value ExportNonScriptableProperties export this object's non-scriptable properties + \value ExportNonScriptableInvokables export this object's non-scriptable invokables + \value ExportNonScriptableContents shorthand form for ExportNonScriptableSlots | + ExportNonScriptableSignals | + ExportNonScriptableProperties + + \value ExportAllSlots export all of this object's slots + \value ExportAllSignals export all of this object's signals + \value ExportAllProperties export all of this object's properties + \value ExportAllInvokables export all of this object's invokables + \value ExportAllContents export all of this object's contents + \value ExportChildObjects export this object's child objects + + \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. +*/ + +/*! + \since 4.8 + \enum QDBusConnection::ConnectionCapabilities + The available capabilities for a D-Bus connection. + + \value UnixFileDescriptorPassing passing of Unix file descriptors to other processes + (see QDBusUnixFileDescriptor) + + \sa connectionCapabilities() +*/ + +/*! + Creates a QDBusConnection object attached to the connection with name \a name. + + This does not open the connection. You have to call connectToBus() to open it. +*/ +QDBusConnection::QDBusConnection(const QString &name) +{ + if (name.isEmpty()) { + d = 0; + } else { + QMutexLocker locker(&_q_manager()->mutex); + d = _q_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(); +} + +/*! + \internal + Creates a connection object with the given \a dd as private object. +*/ +QDBusConnection::QDBusConnection(QDBusConnectionPrivate *dd) +{ + d = dd; + if (d) + d->ref.ref(); +} + +/*! + Disposes of this object. This does not close the connection: you + have to call disconnectFromBus() to do that. +*/ +QDBusConnection::~QDBusConnection() +{ + if (d && !d->ref.deref()) + d->deleteYourself(); +} + +/*! + Creates a copy of the connection \a other in this object. Note + that the connection this object referenced before the copy, is not + spontaneously disconnected. + + \sa disconnectFromBus() +*/ +QDBusConnection &QDBusConnection::operator=(const QDBusConnection &other) +{ + if (other.d) + other.d->ref.ref(); + if (d && !d->ref.deref()) + d->deleteYourself(); + d = other.d; + 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::connectToBus(BusType type, const QString &name) +{ +// Q_ASSERT_X(QCoreApplication::instance(), "QDBusConnection::addConnection", +// "Cannot create connection without a Q[Core]Application instance"); + if (!qdbus_loadLibDBus()) { + QDBusConnectionPrivate *d = 0; + return QDBusConnection(d); + } + + QMutexLocker locker(&_q_manager()->mutex); + + QDBusConnectionPrivate *d = _q_manager()->connection(name); + if (d || name.isEmpty()) + return QDBusConnection(d); + + d = new QDBusConnectionPrivate; + DBusConnection *c = 0; + QDBusErrorInternal error; + switch (type) { + case SystemBus: + c = q_dbus_bus_get_private(DBUS_BUS_SYSTEM, error); + break; + case SessionBus: + c = q_dbus_bus_get_private(DBUS_BUS_SESSION, error); + break; + case ActivationBus: + c = q_dbus_bus_get_private(DBUS_BUS_STARTER, error); + break; + } + d->setConnection(c, error); //setConnection does the error handling for us + + _q_manager()->setConnection(name, d); + + QDBusConnection retval(d); + + // create the bus service + // will lock in QDBusConnectionPrivate::connectRelay() + d->setBusService(retval); + + return retval; +} + +/*! + Opens a connection to a private bus on address \a address and associate with it the + connection name \a name. Returns a QDBusConnection object associated with that connection. +*/ +QDBusConnection QDBusConnection::connectToBus(const QString &address, + const QString &name) +{ +// Q_ASSERT_X(QCoreApplication::instance(), "QDBusConnection::addConnection", +// "Cannot create connection without a Q[Core]Application instance"); + if (!qdbus_loadLibDBus()) { + QDBusConnectionPrivate *d = 0; + return QDBusConnection(d); + } + + QMutexLocker locker(&_q_manager()->mutex); + + QDBusConnectionPrivate *d = _q_manager()->connection(name); + if (d || name.isEmpty()) + return QDBusConnection(d); + + d = new QDBusConnectionPrivate; + // setConnection does the error handling for us + QDBusErrorInternal error; + DBusConnection *c = q_dbus_connection_open_private(address.toUtf8().constData(), error); + if (c) { + if (!q_dbus_bus_register(c, error)) { + q_dbus_connection_unref(c); + c = 0; + } + } + d->setConnection(c, error); + _q_manager()->setConnection(name, d); + + QDBusConnection retval(d); + + // create the bus service + // will lock in QDBusConnectionPrivate::connectRelay() + d->setBusService(retval); + + return retval; +} +/*! + \since 4.8 + + 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::connectToPeer(const QString &address, + const QString &name) +{ +// Q_ASSERT_X(QCoreApplication::instance(), "QDBusConnection::addConnection", +// "Cannot create connection without a Q[Core]Application instance"); + if (!qdbus_loadLibDBus()) { + QDBusConnectionPrivate *d = 0; + return QDBusConnection(d); + } + + QMutexLocker locker(&_q_manager()->mutex); + + QDBusConnectionPrivate *d = _q_manager()->connection(name); + if (d || name.isEmpty()) + return QDBusConnection(d); + + d = new QDBusConnectionPrivate; + // setPeer does the error handling for us + QDBusErrorInternal error; + DBusConnection *c = q_dbus_connection_open_private(address.toUtf8().constData(), error); + + d->setPeer(c, error); + _q_manager()->setConnection(name, d); + + QDBusConnection retval(d); + + return retval; +} + +/*! + Closes the bus 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 constructor. +*/ +void QDBusConnection::disconnectFromBus(const QString &name) +{ + if (_q_manager()) { + QMutexLocker locker(&_q_manager()->mutex); + QDBusConnectionPrivate *d = _q_manager()->connection(name); + if (d && d->mode != QDBusConnectionPrivate::ClientMode) + return; + _q_manager()->removeConnection(name); + } +} + +/*! + \since 4.8 + + Closes the peer 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 constructor. +*/ +void QDBusConnection::disconnectFromPeer(const QString &name) +{ + if (_q_manager()) { + QMutexLocker locker(&_q_manager()->mutex); + QDBusConnectionPrivate *d = _q_manager()->connection(name); + if (d && d->mode != QDBusConnectionPrivate::PeerMode) + return; + _q_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) { + QDBusError err = QDBusError(QDBusError::Disconnected, + QLatin1String("Not connected to D-BUS server")); + if (d) + d->lastError = err; + return false; + } + return d->send(message) != 0; +} + +/*! + Sends the \a message over this connection and returns immediately. + When the reply is received, the method \a returnMethod is called in + the \a receiver object. If an error occurs, the method \a errorMethod + will be called instead. + + If no reply is received within \a timeout milliseconds, an automatic + error will be delivered indicating the expiration of the call. + The default \a timeout is -1, which will be replaced with an + implementation-defined value that is suitable for inter-process + communications (generally, 25 seconds). + + This function is suitable for method calls only. It is guaranteed + that the slot will be called exactly once with the reply, as long + as the parameter types match and no error occurs. + + Returns true if the message was sent, or false if the message could + not be sent. +*/ +bool QDBusConnection::callWithCallback(const QDBusMessage &message, QObject *receiver, + const char *returnMethod, const char *errorMethod, + int timeout) const +{ + if (!d || !d->connection) { + QDBusError err = QDBusError(QDBusError::Disconnected, + QLatin1String("Not connected to D-BUS server")); + if (d) + d->lastError = err; + return false; + } + return d->sendWithReplyAsync(message, receiver, returnMethod, errorMethod, timeout) != 0; +} + +/*! + \overload + \deprecated + Sends the \a message over this connection and returns immediately. + When the reply is received, the method \a returnMethod is called in + the \a receiver object. + + This function is suitable for method calls only. It is guaranteed + that the slot will be called exactly once with the reply, as long + as the parameter types match and no error occurs. + + This function is dangerous because it cannot report errors, including + the expiration of the timeout. + + Returns true if the message was sent, or false if the message could + not be sent. +*/ +bool QDBusConnection::callWithCallback(const QDBusMessage &message, QObject *receiver, + const char *returnMethod, int timeout) const +{ + return callWithCallback(message, receiver, returnMethod, 0, timeout); +} + +/*! + Sends the \a message over this connection and blocks, waiting for + a reply, for at most \a timeout milliseconds. 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. + + If no reply is received within \a timeout milliseconds, an automatic + error will be delivered indicating the expiration of the call. + The default \a timeout is -1, which will be replaced with an + implementation-defined value that is suitable for inter-process + communications (generally, 25 seconds). + + See the QDBusInterface::call() function for a more friendly way + of placing calls. + + \warning If \a mode is QDBus::BlockWithGui, 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 call(). +*/ +QDBusMessage QDBusConnection::call(const QDBusMessage &message, QDBus::CallMode mode, int timeout) const +{ + if (!d || !d->connection) { + QDBusError err = QDBusError(QDBusError::Disconnected, + QLatin1String("Not connected to D-Bus server")); + if (d) + d->lastError = err; + + return QDBusMessage::createError(err); + } + + if (mode != QDBus::NoBlock) + return d->sendWithReply(message, mode, timeout); + + d->send(message); + QDBusMessage retval; + retval << QVariant(); // add one argument (to avoid .at(0) problems) + return retval; +} + +/*! + \since 4.5 + Sends the \a message over this connection and returns + immediately. This function is suitable for method calls only. It + returns an object of type QDBusPendingCall which can be used to + track the status of the reply. + + If no reply is received within \a timeout milliseconds, an automatic + error will be delivered indicating the expiration of the call. The + default \a timeout is -1, which will be replaced with an + implementation-defined value that is suitable for inter-process + communications (generally, 25 seconds). This timeout is also the + upper limit for waiting in QDBusPendingCall::waitForFinished(). + + See the QDBusInterface::asyncCall() function for a more friendly way + of placing calls. +*/ +QDBusPendingCall QDBusConnection::asyncCall(const QDBusMessage &message, int timeout) const +{ + if (!d || !d->connection) { + return QDBusPendingCall(0); // null pointer -> disconnected + } + + QDBusPendingCallPrivate *priv = d->sendWithReplyAsync(message, timeout); + return QDBusPendingCall(priv); +} + +/*! + 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, QStringList(), QString(), receiver, slot); +} + +/*! + \overload + + Connects the signal to the slot \a slot in object \a + receiver. Unlike the previous 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. + + Returns true if the connection was successful. + + \note This function verifies that the signal signature matches the + slot's parameters, but it does not verify that the actual + signal exists with the given signature in the remote + service. +*/ +bool QDBusConnection::connect(const QString &service, const QString &path, const QString& interface, + const QString &name, const QString &signature, + QObject *receiver, const char *slot) +{ + return connect(service, path, interface, name, QStringList(), signature, receiver, slot); +} + +/*! + \overload + \since 4.6 + + Connects the signal to the slot \a slot in object \a + receiver. Unlike the previous 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. + + The \a argumentMatch parameter lists the string parameters to be matched, + in sequential order. Note that, to match an empty string, you need to + pass a QString that is empty but not null (i.e., QString("")). A null + QString skips matching at that position. + + Returns true if the connection was successful. + + \note This function verifies that the signal signature matches the + slot's parameters, but it does not verify that the actual + signal exists with the given signature in the remote + service. +*/ +bool QDBusConnection::connect(const QString &service, const QString &path, const QString& interface, + const QString &name, const QStringList &argumentMatch, const QString &signature, + QObject *receiver, const char *slot) +{ + + if (!receiver || !slot || !d || !d->connection) + return false; + if (interface.isEmpty() && name.isEmpty()) + return false; + if (!interface.isEmpty() && !QDBusUtil::isValidInterfaceName(interface)) { +#ifndef QT_NO_DEBUG + qWarning("QDBusConnection::connect: interface name '%s' is not valid", interface.toLatin1().constData()); +#endif + return false; + } + if (!service.isEmpty() && !QDBusUtil::isValidBusName(service)) { +#ifndef QT_NO_DEBUG + qWarning("QDBusConnection::connect: service name '%s' is not valid", service.toLatin1().constData()); +#endif + return false; + } + if (!path.isEmpty() && !QDBusUtil::isValidObjectPath(path)) { +#ifndef QT_NO_DEBUG + qWarning("QDBusConnection::connect: object path '%s' is not valid", path.toLatin1().constData()); +#endif + return false; + } + + QDBusWriteLocker locker(ConnectAction, d); + return d->connectSignal(service, path, interface, name, argumentMatch, signature, receiver, slot); +} + +/*! + Disconnects the signal specified by the \a service, \a path, \a interface + and \a name parameters from the slot \a slot in object \a receiver. The + arguments must be the same as passed to the connect() function. + + Returns true if the disconnection was successful. +*/ +bool QDBusConnection::disconnect(const QString &service, const QString &path, const QString &interface, + const QString &name, QObject *receiver, const char *slot) +{ + return disconnect(service, path, interface, name, QStringList(), QString(), receiver, slot); +} + +/*! + \overload + + Disconnects the signal specified by the \a service, \a path, \a + interface, \a name, and \a signature parameters from the slot \a slot in + object \a receiver. The arguments must be the same as passed to the + connect() function. + + Returns true if the disconnection was successful. +*/ +bool QDBusConnection::disconnect(const QString &service, const QString &path, const QString& interface, + const QString &name, const QString &signature, + QObject *receiver, const char *slot) +{ + return disconnect(service, path, interface, name, QStringList(), signature, receiver, slot); +} + +/*! + \overload + \since 4.6 + + Disconnects the signal specified by the \a service, \a path, \a + interface, \a name, \a argumentMatch, and \a signature parameters from + the slot \a slot in object \a receiver. The arguments must be the same as + passed to the connect() function. + + Returns true if the disconnection was successful. +*/ +bool QDBusConnection::disconnect(const QString &service, const QString &path, const QString& interface, + const QString &name, const QStringList &argumentMatch, const QString &signature, + QObject *receiver, const char *slot) +{ + if (!receiver || !slot || !d || !d->connection) + return false; + if (!interface.isEmpty() && !QDBusUtil::isValidInterfaceName(interface)) + return false; + if (interface.isEmpty() && name.isEmpty()) + return false; + + QDBusWriteLocker locker(DisconnectAction, d); + return d->disconnectSignal(service, path, interface, name, argumentMatch, signature, receiver, slot); +} + +/*! + 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) +{ + Q_ASSERT_X(QDBusUtil::isValidObjectPath(path), "QDBusConnection::registerObject", + "Invalid object path given"); + if (!d || !d->connection || !object || !options || !QDBusUtil::isValidObjectPath(path)) + return false; + + QStringList pathComponents = path.split(QLatin1Char('/')); + if (pathComponents.last().isEmpty()) + pathComponents.removeLast(); + QDBusWriteLocker locker(RegisterObjectAction, d); + + // 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 + QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator it = + qLowerBound(node->children.begin(), node->children.end(), pathComponents.at(i)); + if (it != node->children.end() && it->name == pathComponents.at(i)) { + // match: this node exists + node = it; + + // 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 + node = node->children.insert(it, pathComponents.at(i)); + } + + // 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('/')); + QDBusWriteLocker locker(UnregisterObjectAction, d); + QDBusConnectionPrivate::ObjectTreeNode *node = &d->rootNode; + int i = 1; + + // find the object + while (node) { + if (pathComponents.count() == i || !path.compare(QLatin1String("/"))) { + // found it + node->obj = 0; + node->flags = 0; + + if (mode == UnregisterTree) { + // clear the sub-tree as well + node->children.clear(); // can't disconnect the objects because we really don't know if they can + // be found somewhere else in the path too + } + + return; + } + + QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator it = + qLowerBound(node->children.begin(), node->children.end(), pathComponents.at(i)); + if (it == node->children.end() || it->name != pathComponents.at(i)) + break; // node not found + + node = it; + ++i; + } +} + +/*! + Return the object that was registered with the registerObject() at the object path given by + \a path. +*/ +QObject *QDBusConnection::objectRegisteredAt(const QString &path) const +{ + Q_ASSERT_X(QDBusUtil::isValidObjectPath(path), "QDBusConnection::registeredObject", + "Invalid object path given"); + if (!d || !d->connection || !QDBusUtil::isValidObjectPath(path)) + return false; + + QStringList pathComponents = path.split(QLatin1Char('/')); + if (pathComponents.last().isEmpty()) + pathComponents.removeLast(); + + // lower-bound search for where this object should enter in the tree + QDBusReadLocker lock(ObjectRegisteredAtAction, d); + const QDBusConnectionPrivate::ObjectTreeNode *node = &d->rootNode; + + int i = 1; + while (node) { + if (pathComponents.count() == i) + return node->obj; + + QDBusConnectionPrivate::ObjectTreeNode::DataList::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; + ++i; + } + return 0; +} + +/*! + Returns a QDBusConnectionInterface object that represents the + D-Bus server interface on this connection. +*/ +QDBusConnectionInterface *QDBusConnection::interface() const +{ + if (!d) + return 0; + return d->busService; +} + +/*! + \internal + \since 4.8 + + Returns the internal, implementation-defined pointer for this + connection. Currently, this returns a DBusConnection* pointer, + without changing the reference count. It is the responsibility of + the caller to call dbus_connection_ref if it wants to store the + pointer. +*/ +void *QDBusConnection::internalPointer() const +{ + return d ? d->connection : 0; +} + +/*! + Returns true if this QDBusConnection object is connected. +*/ +bool QDBusConnection::isConnected() const +{ + return d && d->connection && q_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->baseService : QString(); +} + +/*! + \since 4.5 + + Returns the connection name for this connection, as given as the + name parameter to connectToBus(). + + The connection name can be used to uniquely identify actual + underlying connections to buses. Copies made from a single + connection will always implicitly share the underlying connection, + and hence will have the same connection name. + + Inversely, two connections having different connection names will + always either be connected to different buses, or have a different + unique name (as returned by baseService()) on that bus. + + \sa connectToBus(), disconnectFromBus() +*/ +QString QDBusConnection::name() const +{ + return d ? d->name : QString(); +} + +/*! + \since 4.8 + + Returns the capabilities of this connection as negotiated with the bus + server or peer. If this QDBusConnection is not connected, this function + returns no capabilities. +*/ +QDBusConnection::ConnectionCapabilities QDBusConnection::connectionCapabilities() const +{ + return d ? d->capabilities : ConnectionCapabilities(0); +} + +/*! + Attempts to register the \a serviceName on the D-Bus server and + returns true if the registration succeeded. The registration will + fail if the name is already registered by another application. + + \sa unregisterService(), QDBusConnectionInterface::registerService() +*/ +bool QDBusConnection::registerService(const QString &serviceName) +{ + if (interface() && interface()->registerService(serviceName)) { + if (d) d->registerService(serviceName); + return true; + } + return false; +} + +/*! + Unregisters the service \a serviceName that was previously + registered with registerService() and returns true if it + succeeded. + + \sa registerService(), QDBusConnectionInterface::unregisterService() +*/ +bool QDBusConnection::unregisterService(const QString &serviceName) +{ + if (interface()->unregisterService(serviceName)) { + if (d) d->unregisterService(serviceName); + return true; + } + return false; +} + +static const char _q_sessionBusName[] = "qt_default_session_bus"; +static const char _q_systemBusName[] = "qt_default_system_bus"; + +class QDBusDefaultConnection: public QDBusConnection +{ + const char *ownName; +public: + inline QDBusDefaultConnection(BusType type, const char *name) + : QDBusConnection(connectToBus(type, QString::fromLatin1(name))), ownName(name) + { + // make sure this connection is running on the main thread + QCoreApplication *instance = QCoreApplication::instance(); + if (!instance) { + qWarning("QDBusConnection: %s D-Bus connection created before QCoreApplication. Application may misbehave.", + type == SessionBus ? "session" : type == SystemBus ? "system" : "generic"); + } else { + QDBusConnectionPrivate::d(*this)->moveToThread(instance->thread()); + } + } + + inline ~QDBusDefaultConnection() + { disconnectFromBus(QString::fromLatin1(ownName)); } +}; + +Q_GLOBAL_STATIC_WITH_ARGS(QDBusDefaultConnection, _q_sessionBus, + (QDBusConnection::SessionBus, _q_sessionBusName)) +Q_GLOBAL_STATIC_WITH_ARGS(QDBusDefaultConnection, _q_systemBus, + (QDBusConnection::SystemBus, _q_systemBusName)) + +QDBusConnection QDBusConnection::sessionBus() +{ + return *_q_sessionBus(); +} + +QDBusConnection QDBusConnection::systemBus() +{ + return *_q_systemBus(); +} + +/*! + \nonreentrant + + Returns the connection that sent the signal, if called in a slot activated + by QDBus; otherwise it returns 0. + + \note Please avoid this function. This function is not thread-safe, so if + there's any other thread delivering a D-Bus call, this function may return + the wrong connection. In new code, please use QDBusContext::connection() + (see that class for a description on how to use it). +*/ +QDBusConnection QDBusConnection::sender() +{ + return QDBusConnection(_q_manager()->sender()); +} + +/*! + \internal +*/ +void QDBusConnectionPrivate::setSender(const QDBusConnectionPrivate *s) +{ + _q_manager()->setSender(s); +} + +/*! + \internal +*/ +void QDBusConnectionPrivate::setBusService(const QDBusConnection &connection) +{ + busService = new QDBusConnectionInterface(connection, this); + ref.deref(); // busService has increased the refcounting to us + // avoid cyclic refcounting + + QObject::connect(this, SIGNAL(callWithCallbackFailed(QDBusError,QDBusMessage)), + busService, SIGNAL(callWithCallbackFailed(QDBusError,QDBusMessage)), + Qt::QueuedConnection); +} + +/*! + \namespace QDBus + \inmodule QtDBus + + \brief The QDBus namespace contains miscellaneous identifiers used + throughout the QtDBus library. +*/ + +/*! + \enum QDBus::CallMode + + This enum describes the various ways of placing a function call. The valid modes are: + + \value NoBlock Place the call but don't wait for the reply (the reply's contents + will be discarded). + \value Block Don't use an event loop to wait for a reply, but instead block on + network operations while waiting. This means the + user-interface may not be updated until the function returns. + \value BlockWithGui Use the Qt event loop to wait for a reply. This means that the + user-interface will stay responsive (processing input events), + but it also means other events may happen, like signal delivery + and other D-Bus method calls. + \value AutoDetect Automatically detect if the called function has a reply. + + When using BlockWithGui, applications must be prepared for reentrancy in any function. +*/ + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusconnection.h b/src/dbus/qdbusconnection.h new file mode 100644 index 0000000000..15e08a780b --- /dev/null +++ b/src/dbus/qdbusconnection.h @@ -0,0 +1,199 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSCONNECTION_H +#define QDBUSCONNECTION_H + +#include <QtDBus/qdbusmacros.h> +#include <QtCore/qstring.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +namespace QDBus +{ + enum CallMode { + NoBlock, + Block, + BlockWithGui, + AutoDetect + }; +} + +class QDBusAbstractInterfacePrivate; +class QDBusInterface; +class QDBusError; +class QDBusMessage; +class QDBusPendingCall; +class QDBusConnectionInterface; +class QObject; + +class QDBusConnectionPrivate; +class Q_DBUS_EXPORT QDBusConnection +{ + Q_GADGET + Q_ENUMS(BusType UnregisterMode) + Q_FLAGS(RegisterOptions) +public: + enum BusType { SessionBus, SystemBus, ActivationBus }; + enum RegisterOption { + ExportAdaptors = 0x01, + + ExportScriptableSlots = 0x10, + ExportScriptableSignals = 0x20, + ExportScriptableProperties = 0x40, + ExportScriptableInvokables = 0x80, + ExportScriptableContents = 0xf0, + + ExportNonScriptableSlots = 0x100, + ExportNonScriptableSignals = 0x200, + ExportNonScriptableProperties = 0x400, + ExportNonScriptableInvokables = 0x800, + ExportNonScriptableContents = 0xf00, + + ExportAllSlots = ExportScriptableSlots|ExportNonScriptableSlots, + ExportAllSignals = ExportScriptableSignals|ExportNonScriptableSignals, + ExportAllProperties = ExportScriptableProperties|ExportNonScriptableProperties, + ExportAllInvokables = ExportScriptableInvokables|ExportNonScriptableInvokables, + ExportAllContents = ExportScriptableContents|ExportNonScriptableContents, + +#ifndef Q_QDOC + // Qt 4.2 had a misspelling here + ExportAllSignal = ExportAllSignals, +#endif + + ExportChildObjects = 0x1000 + }; + enum UnregisterMode { + UnregisterNode, + UnregisterTree + }; + Q_DECLARE_FLAGS(RegisterOptions, RegisterOption) + + enum ConnectionCapability { + UnixFileDescriptorPassing = 0x0001 + }; + Q_DECLARE_FLAGS(ConnectionCapabilities, ConnectionCapability) + + QDBusConnection(const QString &name); + QDBusConnection(const QDBusConnection &other); + ~QDBusConnection(); + + QDBusConnection &operator=(const QDBusConnection &other); + + bool isConnected() const; + QString baseService() const; + QDBusError lastError() const; + QString name() const; + ConnectionCapabilities connectionCapabilities() const; + + bool send(const QDBusMessage &message) const; + bool callWithCallback(const QDBusMessage &message, QObject *receiver, + const char *returnMethod, const char *errorMethod, + int timeout = -1) const; + bool callWithCallback(const QDBusMessage &message, QObject *receiver, + const char *slot, int timeout = -1) const; + QDBusMessage call(const QDBusMessage &message, QDBus::CallMode mode = QDBus::Block, + int timeout = -1) const; + QDBusPendingCall asyncCall(const QDBusMessage &message, int timeout = -1) 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 connect(const QString &service, const QString &path, const QString &interface, + const QString &name, const QStringList &argumentMatch, const QString& signature, + QObject *receiver, const char *slot); + + bool disconnect(const QString &service, const QString &path, const QString &interface, + const QString &name, QObject *receiver, const char *slot); + bool disconnect(const QString &service, const QString &path, const QString &interface, + const QString &name, const QString& signature, + QObject *receiver, const char *slot); + bool disconnect(const QString &service, const QString &path, const QString &interface, + const QString &name, const QStringList &argumentMatch, 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); + QObject *objectRegisteredAt(const QString &path) const; + + bool registerService(const QString &serviceName); + bool unregisterService(const QString &serviceName); + + QDBusConnectionInterface *interface() const; + + void *internalPointer() const; + + static QDBusConnection connectToBus(BusType type, const QString &name); + static QDBusConnection connectToBus(const QString &address, const QString &name); + static QDBusConnection connectToPeer(const QString &address, const QString &name); + static void disconnectFromBus(const QString &name); + static void disconnectFromPeer(const QString &name); + + static QDBusConnection sessionBus(); + static QDBusConnection systemBus(); + + static QDBusConnection sender(); + +protected: + explicit QDBusConnection(QDBusConnectionPrivate *dd); + +private: + friend class QDBusConnectionPrivate; + QDBusConnectionPrivate *d; +}; + +Q_DECLARE_OPERATORS_FOR_FLAGS(QDBusConnection::RegisterOptions) + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusconnection_p.h b/src/dbus/qdbusconnection_p.h new file mode 100644 index 0000000000..355a6e6d94 --- /dev/null +++ b/src/dbus/qdbusconnection_p.h @@ -0,0 +1,347 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// 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 <qdbusconnection.h> + +#include <QtCore/qatomic.h> +#include <QtCore/qhash.h> +#include <QtCore/qmutex.h> +#include <QtCore/qobject.h> +#include <QtCore/qpointer.h> +#include <QtCore/qreadwritelock.h> +#include <QtCore/qstringlist.h> +#include <QtCore/qvarlengtharray.h> +#include <QtCore/qvector.h> + +#include "qdbus_symbols_p.h" + +#include <qdbusmessage.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +class QDBusMessage; +class QSocketNotifier; +class QTimerEvent; +class QDBusObjectPrivate; +class QDBusCallDeliveryEvent; +class QDBusActivateObjectEvent; +class QMetaMethod; +class QDBusInterfacePrivate; +struct QDBusMetaObject; +class QDBusAbstractInterface; +class QDBusConnectionInterface; +class QDBusPendingCallPrivate; + +class QDBusErrorInternal +{ + mutable DBusError error; + Q_DISABLE_COPY(QDBusErrorInternal) +public: + inline QDBusErrorInternal() { q_dbus_error_init(&error); } + inline ~QDBusErrorInternal() { q_dbus_error_free(&error); } + inline bool operator !() const { return !q_dbus_error_is_set(&error); } + inline operator DBusError *() { q_dbus_error_free(&error); return &error; } + inline operator QDBusError() const { QDBusError err(&error); q_dbus_error_free(&error); return err; } +}; + +// QDBusConnectionPrivate holds the DBusConnection and +// can have many QDBusConnection objects referring to it + +class QDBusConnectionPrivate: public QObject +{ + Q_OBJECT +public: + // structs and enums + enum ConnectionMode { InvalidMode, ServerMode, ClientMode, PeerMode }; // LocalMode + + struct Watcher + { + Watcher(): watch(0), read(0), write(0) {} + DBusWatch *watch; + QSocketNotifier *read; + QSocketNotifier *write; + }; + + struct SignalHook + { + inline SignalHook() : obj(0), midx(-1) { } + QString service, path, signature; + QObject* obj; + int midx; + QList<int> params; + QStringList argumentMatch; + QByteArray matchRule; + }; + + struct ObjectTreeNode + { + typedef QVector<ObjectTreeNode> DataList; + + inline ObjectTreeNode() : obj(0), flags(0) { } + inline ObjectTreeNode(const QString &n) // intentionally implicit + : name(n), obj(0), flags(0) { } + inline ~ObjectTreeNode() { } + inline bool operator<(const QString &other) const + { return name < other; } + inline bool operator<(const QStringRef &other) const + { return QStringRef(&name) < other; } + + QString name; + QObject* obj; + int flags; + DataList children; + }; + +public: + // typedefs + typedef QMultiHash<int, Watcher> WatcherHash; + typedef QHash<int, DBusTimeout *> TimeoutHash; + typedef QList<QPair<DBusTimeout *, int> > PendingTimeoutList; + + typedef QMultiHash<QString, SignalHook> SignalHookHash; + typedef QHash<QString, QDBusMetaObject* > MetaObjectHash; + typedef QHash<QByteArray, int> MatchRefCountHash; + + struct WatchedServiceData { + WatchedServiceData() : refcount(0) {} + WatchedServiceData(const QString &owner, int refcount = 0) + : owner(owner), refcount(refcount) + {} + QString owner; + int refcount; + }; + typedef QHash<QString, WatchedServiceData> WatchedServicesHash; + +public: + // public methods are entry points from other objects + explicit QDBusConnectionPrivate(QObject *parent = 0); + ~QDBusConnectionPrivate(); + void deleteYourself(); + + void setBusService(const QDBusConnection &connection); + void setPeer(DBusConnection *connection, const QDBusErrorInternal &error); + void setConnection(DBusConnection *connection, const QDBusErrorInternal &error); + void setServer(DBusServer *server, const QDBusErrorInternal &error); + void closeConnection(); + + QString getNameOwner(const QString &service); + + int send(const QDBusMessage &message); + QDBusMessage sendWithReply(const QDBusMessage &message, int mode, int timeout = -1); + QDBusMessage sendWithReplyLocal(const QDBusMessage &message); + QDBusPendingCallPrivate *sendWithReplyAsync(const QDBusMessage &message, int timeout = -1); + int sendWithReplyAsync(const QDBusMessage &message, QObject *receiver, + const char *returnMethod, const char *errorMethod, int timeout = -1); + bool connectSignal(const QString &service, const QString &path, const QString& interface, + const QString &name, const QStringList &argumentMatch, const QString &signature, + QObject *receiver, const char *slot); + void connectSignal(const QString &key, const SignalHook &hook); + SignalHookHash::Iterator disconnectSignal(SignalHookHash::Iterator &it); + bool disconnectSignal(const QString &service, const QString &path, const QString& interface, + const QString &name, const QStringList &argumentMatch, const QString &signature, + QObject *receiver, const char *slot); + 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); + void registerService(const QString &serviceName); + void unregisterService(const QString &serviceName); + + bool handleMessage(const QDBusMessage &msg); + void waitForFinished(QDBusPendingCallPrivate *pcall); + + QDBusMetaObject *findMetaObject(const QString &service, const QString &path, + const QString &interface, QDBusError &error); + + void postEventToThread(int action, QObject *target, QEvent *event); + + inline void serverConnection(const QDBusConnection &connection) + { emit newServerConnection(connection); } + +private: + void checkThread(); + bool handleError(const QDBusErrorInternal &error); + + void handleSignal(const QString &key, const QDBusMessage &msg); + void handleSignal(const QDBusMessage &msg); + void handleObjectCall(const QDBusMessage &message); + + void activateSignal(const SignalHook& hook, const QDBusMessage &msg); + void activateObject(ObjectTreeNode &node, const QDBusMessage &msg, int pathStartPos); + bool activateInternalFilters(const ObjectTreeNode &node, const QDBusMessage &msg); + bool activateCall(QObject *object, int flags, const QDBusMessage &msg); + + void sendError(const QDBusMessage &msg, QDBusError::ErrorType code); + void deliverCall(QObject *object, int flags, const QDBusMessage &msg, + const QList<int> &metaTypes, int slotIdx); + + bool isServiceRegisteredByThread(const QString &serviceName) const; + + QString getNameOwnerNoCache(const QString &service); + +protected: + void customEvent(QEvent *e); + void timerEvent(QTimerEvent *e); + +public slots: + // public slots + void doDispatch(); + void socketRead(int); + void socketWrite(int); + void objectDestroyed(QObject *o); + void relaySignal(QObject *obj, const QMetaObject *, int signalId, const QVariantList &args); + +private slots: + void serviceOwnerChangedNoLock(const QString &name, const QString &oldOwner, const QString &newOwner); + void registerServiceNoLock(const QString &serviceName); + void unregisterServiceNoLock(const QString &serviceName); + +signals: + void serviceOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner); + void callWithCallbackFailed(const QDBusError &error, const QDBusMessage &message); + void newServerConnection(const QDBusConnection &connection); + +public: + QAtomicInt ref; + QDBusConnection::ConnectionCapabilities capabilities; + QString name; // this connection's name + QString baseService; // this connection's base service + + ConnectionMode mode; + + // members accessed in unlocked mode (except for deletion) + // connection and server provide their own locking mechanisms + // busService doesn't have state to be changed + DBusConnection *connection; + DBusServer *server; + QDBusConnectionInterface *busService; + + // watchers and timeouts are accessed from any thread + // but the corresponding timer and QSocketNotifier must be handled + // only in the object's thread + QMutex watchAndTimeoutLock; + WatcherHash watchers; + TimeoutHash timeouts; + PendingTimeoutList timeoutsPendingAdd; + + // members accessed through a lock + QMutex dispatchLock; + QReadWriteLock lock; + QDBusError lastError; + + QStringList serviceNames; + WatchedServicesHash watchedServices; + SignalHookHash signalHooks; + MatchRefCountHash matchRefCounts; + ObjectTreeNode rootNode; + MetaObjectHash cachedMetaObjects; + + QMutex callDeliveryMutex; + QDBusCallDeliveryEvent *callDeliveryState; // protected by the callDeliveryMutex mutex + +public: + // static methods + 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, + const QStringList &argMatch, + QObject *receiver, const char *signal, int minMIdx, + bool buildSignature); + static DBusHandlerResult messageFilter(DBusConnection *, DBusMessage *, void *); + static bool checkReplyForDelivery(QDBusConnectionPrivate *target, QObject *object, + int idx, const QList<int> &metaTypes, + const QDBusMessage &msg); + static QDBusCallDeliveryEvent *prepareReply(QDBusConnectionPrivate *target, QObject *object, + int idx, const QList<int> &metaTypes, + const QDBusMessage &msg); + static void processFinishedCall(QDBusPendingCallPrivate *call); + + static QDBusConnectionPrivate *d(const QDBusConnection& q) { return q.d; } + static QDBusConnection q(QDBusConnectionPrivate *connection) { return QDBusConnection(connection); } + + static void setSender(const QDBusConnectionPrivate *s); + + friend class QDBusActivateObjectEvent; + friend class QDBusCallDeliveryEvent; +}; + +// in qdbusmisc.cpp +extern int qDBusParametersForMethod(const QMetaMethod &mm, QList<int>& metaTypes); +extern int qDBusNameToTypeId(const char *name); +extern bool qDBusCheckAsyncTag(const char *tag); +extern bool qDBusInterfaceInObject(QObject *obj, const QString &interface_name); +extern QString qDBusInterfaceFromMetaObject(const QMetaObject *mo); + +// in qdbusinternalfilters.cpp +extern QString qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode &node); +extern QDBusMessage qDBusPropertyGet(const QDBusConnectionPrivate::ObjectTreeNode &node, + const QDBusMessage &msg); +extern QDBusMessage qDBusPropertySet(const QDBusConnectionPrivate::ObjectTreeNode &node, + const QDBusMessage &msg); +extern QDBusMessage qDBusPropertyGetAll(const QDBusConnectionPrivate::ObjectTreeNode &node, + const QDBusMessage &msg); + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusconnectioninterface.cpp b/src/dbus/qdbusconnectioninterface.cpp new file mode 100644 index 0000000000..92263356c3 --- /dev/null +++ b/src/dbus/qdbusconnectioninterface.cpp @@ -0,0 +1,419 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusconnectioninterface.h" + +#include <QtCore/QByteArray> +#include <QtCore/QList> +#include <QtCore/QMap> +#include <QtCore/QString> +#include <QtCore/QStringList> +#include <QtCore/QVariant> +#include <QtCore/QDebug> + +#include "qdbus_symbols_p.h" // for the DBUS_* constants + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +/* + * Implementation of interface class QDBusConnectionInterface + */ + +/*! + \class QDBusConnectionInterface + \inmodule QtDBus + \since 4.2 + + \brief The QDBusConnectionInterface class provides access to the D-Bus bus daemon service. + + The D-Bus bus server daemon provides one special interface \c + org.freedesktop.DBus that allows clients to access certain + properties of the bus, such as the current list of clients + connected. The QDBusConnectionInterface class provides access to that + interface. + + The most common uses of this class are to register and unregister + service names on the bus using the registerService() and + unregisterService() functions, query about existing names using + the isServiceRegistered(), registeredServiceNames() and + serviceOwner() functions, and to receive notification that a + client has registered or de-registered through the + serviceRegistered(), serviceUnregistered() and serviceOwnerChanged() + signals. +*/ + +/*! + \enum QDBusConnectionInterface::ServiceQueueOptions + + Flags for determining how a service registration should behave, in + case the service name is already registered. + + \value DontQueueService If an application requests a name that + is already owned, no queueing will be + performed. The registeredService() + call will simply fail. + This is the default. + + \value QueueService Attempts to register the requested + service, but do not try to replace it + if another application already has it + registered. Instead, simply put this + application in queue, until it is + given up. The serviceRegistered() + signal will be emitted when that + happens. + + \value ReplaceExistingService If another application already has + the service name registered, attempt + to replace it. + + \sa ServiceReplacementOptions +*/ + +/*! + \enum QDBusConnectionInterface::ServiceReplacementOptions + + Flags for determining if the D-Bus server should allow another + application to replace a name that this application has registered + with the ReplaceExistingService option. + + The possible values are: + + \value DontAllowReplacement Do not allow another application to + replace us. The service must be + explicitly unregistered with + unregisterService() for another + application to acquire it. + This is the default. + + \value AllowReplacement Allow other applications to replace us + with the ReplaceExistingService option + to registerService() without + intervention. If that happens, the + serviceUnregistered() signal will be + emitted. + + \sa ServiceQueueOptions +*/ + +/*! + \enum QDBusConnectionInterface::RegisterServiceReply + + The possible return values from registerService(): + + \value ServiceNotRegistered The call failed and the service name was not registered. + \value ServiceRegistered The caller is now the owner of the service name. + \value ServiceQueued The caller specified the QueueService flag and the + service was already registered, so we are in queue. + + The serviceRegistered() signal will be emitted when the service is + acquired by this application. +*/ + +/*! + \internal +*/ +const char *QDBusConnectionInterface::staticInterfaceName() +{ return "org.freedesktop.DBus"; } + +/*! + \internal +*/ +QDBusConnectionInterface::QDBusConnectionInterface(const QDBusConnection &connection, + QObject *parent) + : QDBusAbstractInterface(QLatin1String(DBUS_SERVICE_DBUS), + QLatin1String(DBUS_PATH_DBUS), + DBUS_INTERFACE_DBUS, connection, parent) +{ + connect(this, SIGNAL(NameAcquired(QString)), this, SIGNAL(serviceRegistered(QString))); + connect(this, SIGNAL(NameLost(QString)), this, SIGNAL(serviceUnregistered(QString))); + connect(this, SIGNAL(NameOwnerChanged(QString,QString,QString)), + this, SIGNAL(serviceOwnerChanged(QString,QString,QString))); +} + +/*! + \internal +*/ +QDBusConnectionInterface::~QDBusConnectionInterface() +{ +} + +/*! + 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 \c org.freedesktop.DBus.Error.NameHasNoOwner error. +*/ +QDBusReply<QString> QDBusConnectionInterface::serviceOwner(const QString &name) const +{ + return internalConstCall(QDBus::AutoDetect, QLatin1String("GetNameOwner"), QList<QVariant>() << name); +} + +/*! + \property QDBusConnectionInterface::registeredServiceNames + \brief holds the registered service names + + Lists all names currently registered on the bus. +*/ +QDBusReply<QStringList> QDBusConnectionInterface::registeredServiceNames() const +{ + return internalConstCall(QDBus::AutoDetect, QLatin1String("ListNames")); +} + +/*! + Returns true if the service name \a serviceName has is currently + registered. +*/ +QDBusReply<bool> QDBusConnectionInterface::isServiceRegistered(const QString &serviceName) const +{ + return internalConstCall(QDBus::AutoDetect, QLatin1String("NameHasOwner"), + QList<QVariant>() << serviceName); +} + +/*! + Returns the Unix Process ID (PID) for the process currently + holding the bus service \a serviceName. +*/ +QDBusReply<uint> QDBusConnectionInterface::servicePid(const QString &serviceName) const +{ + return internalConstCall(QDBus::AutoDetect, QLatin1String("GetConnectionUnixProcessID"), + QList<QVariant>() << serviceName); +} + +/*! + Returns the Unix User ID (UID) for the process currently holding + the bus service \a serviceName. +*/ +QDBusReply<uint> QDBusConnectionInterface::serviceUid(const QString &serviceName) const +{ + return internalConstCall(QDBus::AutoDetect, QLatin1String("GetConnectionUnixUser"), + QList<QVariant>() << serviceName); +} + +/*! + Requests that the bus start the service given by the name \a name. +*/ +QDBusReply<void> QDBusConnectionInterface::startService(const QString &name) +{ + return call(QLatin1String("StartServiceByName"), name, uint(0)); +} + +/*! + Requests to register the service name \a serviceName on the + bus. The \a qoption flag specifies how the D-Bus server should behave + if \a serviceName is already registered. The \a roption flag + specifies if the server should allow another application to + replace our registered name. + + If the service registration succeeds, the serviceRegistered() + signal will be emitted. If we are placed in queue, the signal will + be emitted when we obtain the name. If \a roption is + AllowReplacement, the serviceUnregistered() signal will be emitted + if another application replaces this one. + + \sa unregisterService() +*/ +QDBusReply<QDBusConnectionInterface::RegisterServiceReply> +QDBusConnectionInterface::registerService(const QString &serviceName, + ServiceQueueOptions qoption, + ServiceReplacementOptions roption) +{ + // reconstruct the low-level flags + uint flags = 0; + switch (qoption) { + case DontQueueService: + flags = DBUS_NAME_FLAG_DO_NOT_QUEUE; + break; + case QueueService: + flags = 0; + break; + case ReplaceExistingService: + flags = DBUS_NAME_FLAG_DO_NOT_QUEUE | DBUS_NAME_FLAG_REPLACE_EXISTING; + break; + } + + switch (roption) { + case DontAllowReplacement: + break; + case AllowReplacement: + flags |= DBUS_NAME_FLAG_ALLOW_REPLACEMENT; + break; + } + + QDBusMessage reply = call(QLatin1String("RequestName"), serviceName, flags); +// qDebug() << "QDBusConnectionInterface::registerService" << serviceName << "Reply:" << reply; + + // convert the low-level flags to something that we can use + if (reply.type() == QDBusMessage::ReplyMessage) { + uint code = 0; + + switch (reply.arguments().at(0).toUInt()) { + case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER: + case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER: + code = uint(ServiceRegistered); + break; + + case DBUS_REQUEST_NAME_REPLY_EXISTS: + code = uint(ServiceNotRegistered); + break; + + case DBUS_REQUEST_NAME_REPLY_IN_QUEUE: + code = uint(ServiceQueued); + break; + } + + reply.setArguments(QVariantList() << code); + } + + return reply; +} + +/*! + Releases the claim on the bus service name \a serviceName, that + had been previously registered with registerService(). 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<bool> +QDBusConnectionInterface::unregisterService(const QString &serviceName) +{ + QDBusMessage reply = call(QLatin1String("ReleaseName"), serviceName); + if (reply.type() == QDBusMessage::ReplyMessage) { + bool success = reply.arguments().at(0).toUInt() == DBUS_RELEASE_NAME_REPLY_RELEASED; + reply.setArguments(QVariantList() << success); + } + return reply; +} + +/*! + \internal +*/ +void QDBusConnectionInterface::connectNotify(const char *signalName) +{ + // translate the signal names to what we really want + // this avoids setting hooks for signals that don't exist on the bus + if (qstrcmp(signalName, SIGNAL(serviceRegistered(QString))) == 0) + QDBusAbstractInterface::connectNotify(SIGNAL(NameAcquired(QString))); + + else if (qstrcmp(signalName, SIGNAL(serviceUnregistered(QString))) == 0) + QDBusAbstractInterface::connectNotify(SIGNAL(NameLost(QString))); + + else if (qstrcmp(signalName, SIGNAL(serviceOwnerChanged(QString,QString,QString))) == 0) { + static bool warningPrinted = false; + if (!warningPrinted) { + qWarning("Connecting to deprecated signal QDBusConnectionInterface::serviceOwnerChanged(QString,QString,QString)"); + warningPrinted = true; + } + QDBusAbstractInterface::connectNotify(SIGNAL(NameOwnerChanged(QString,QString,QString))); + } +} + +/*! + \internal +*/ +void QDBusConnectionInterface::disconnectNotify(const char *signalName) +{ + // translate the signal names to what we really want + // this avoids setting hooks for signals that don't exist on the bus + if (qstrcmp(signalName, SIGNAL(serviceRegistered(QString))) == 0) + QDBusAbstractInterface::disconnectNotify(SIGNAL(NameAcquired(QString))); + + else if (qstrcmp(signalName, SIGNAL(serviceUnregistered(QString))) == 0) + QDBusAbstractInterface::disconnectNotify(SIGNAL(NameLost(QString))); + + else if (qstrcmp(signalName, SIGNAL(serviceOwnerChanged(QString,QString,QString))) == 0) + QDBusAbstractInterface::disconnectNotify(SIGNAL(NameOwnerChanged(QString,QString,QString))); +} + +// signals +/*! + \fn QDBusConnectionInterface::serviceRegistered(const QString &serviceName) + + This signal is emitted by the D-Bus server when the bus service + name (unique connection name or well-known service name) given by + \a serviceName is acquired by this application. + + Acquisition happens after this application has requested a name using + registerService(). +*/ + +/*! + \fn QDBusConnectionInterface::serviceUnregistered(const QString &serviceName) + + This signal is emitted by the D-Bus server when this application + loses ownership of the bus service name given by \a serviceName. +*/ + +/*! + \fn QDBusConnectionInterface::serviceOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner) + + This signal is emitted by the D-Bus server whenever a service + 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 and is + no longer available. + + \note connecting to this signal will make the application listen for and + receive every single service ownership change on the bus. Depending on + how many services are running, this make the application be activated to + receive more signals than it needs. To avoid this problem, use the + QDBusServiceWatcher class, which can listen for specific changes. +*/ + +/*! + \fn void QDBusConnectionInterface::callWithCallbackFailed(const QDBusError &error, const QDBusMessage &call) + + This signal is emitted when there is an error during a + QDBusConnection::callWithCallback(). \a error specifies the error. + \a call is the message that couldn't be delivered. + + \sa QDBusConnection::callWithCallback() + */ + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusconnectioninterface.h b/src/dbus/qdbusconnectioninterface.h new file mode 100644 index 0000000000..3e94500ef5 --- /dev/null +++ b/src/dbus/qdbusconnectioninterface.h @@ -0,0 +1,132 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSBUS_H +#define QDBUSBUS_H + +#include <QtCore/qstringlist.h> + +#include <QtDBus/qdbusabstractinterface.h> +#include <QtDBus/qdbusreply.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusConnection; +class QString; +class QByteArray; + +/* + * Proxy class for interface org.freedesktop.DBus + */ +class Q_DBUS_EXPORT QDBusConnectionInterface: public QDBusAbstractInterface +{ + Q_OBJECT + Q_ENUMS(ServiceQueueOptions ServiceReplacementOptions RegisterServiceReply) + friend class QDBusConnectionPrivate; + static inline const char *staticInterfaceName(); + + explicit QDBusConnectionInterface(const QDBusConnection &connection, QObject *parent); + ~QDBusConnectionInterface(); + + Q_PROPERTY(QDBusReply<QStringList> registeredServiceNames READ registeredServiceNames) + +public: + enum ServiceQueueOptions { + DontQueueService, + QueueService, + ReplaceExistingService + }; + enum ServiceReplacementOptions { + DontAllowReplacement, + AllowReplacement + }; + enum RegisterServiceReply { + ServiceNotRegistered = 0, + ServiceRegistered, + ServiceQueued + }; + +public Q_SLOTS: + QDBusReply<QStringList> registeredServiceNames() const; + QDBusReply<bool> isServiceRegistered(const QString &serviceName) const; + QDBusReply<QString> serviceOwner(const QString &name) const; + QDBusReply<bool> unregisterService(const QString &serviceName); + QDBusReply<QDBusConnectionInterface::RegisterServiceReply> registerService(const QString &serviceName, + ServiceQueueOptions qoption = DontQueueService, + ServiceReplacementOptions roption = DontAllowReplacement); + + QDBusReply<uint> servicePid(const QString &serviceName) const; + QDBusReply<uint> serviceUid(const QString &serviceName) const; + + QDBusReply<void> startService(const QString &name); + +Q_SIGNALS: + void serviceRegistered(const QString &service); + void serviceUnregistered(const QString &service); + void serviceOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner); + void callWithCallbackFailed(const QDBusError &error, const QDBusMessage &call); + +#ifndef Q_QDOC + // internal signals + // do not use + void NameAcquired(const QString &); + void NameLost(const QString &); + void NameOwnerChanged(const QString &, const QString &, const QString &); +protected: + void connectNotify(const char *); + void disconnectNotify(const char *); +#endif +}; + +QT_END_NAMESPACE + +Q_DECLARE_BUILTIN_METATYPE(QDBusConnectionInterface::RegisterServiceReply, UInt) + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusconnectionmanager_p.h b/src/dbus/qdbusconnectionmanager_p.h new file mode 100644 index 0000000000..dd8b4aad64 --- /dev/null +++ b/src/dbus/qdbusconnectionmanager_p.h @@ -0,0 +1,88 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// 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 QDBUSCONNECTIONMANAGER_P_H +#define QDBUSCONNECTIONMANAGER_P_H + +#include "qdbusconnection_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +class QDBusConnectionManager +{ +public: + QDBusConnectionManager() {} + ~QDBusConnectionManager(); + static QDBusConnectionManager* instance(); + + QDBusConnectionPrivate *connection(const QString &name) const; + void removeConnection(const QString &name); + void setConnection(const QString &name, QDBusConnectionPrivate *c); + + QDBusConnectionPrivate *sender() const; + void setSender(const QDBusConnectionPrivate *s); + + mutable QMutex mutex; +private: + QHash<QString, QDBusConnectionPrivate *> connectionHash; + + mutable QMutex senderMutex; + QString senderName; // internal; will probably change +}; + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbuscontext.cpp b/src/dbus/qdbuscontext.cpp new file mode 100644 index 0000000000..f3f3e69caf --- /dev/null +++ b/src/dbus/qdbuscontext.cpp @@ -0,0 +1,208 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusmessage.h" +#include "qdbusconnection.h" +#include "qdbusabstractadaptor.h" + +#include "qdbuscontext.h" +#include "qdbuscontext_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +QDBusContextPrivate *QDBusContextPrivate::set(QObject *obj, QDBusContextPrivate *newContext) +{ + // determine if this is an adaptor or not + if (qobject_cast<QDBusAbstractAdaptor *>(obj)) + obj = obj->parent(); + + Q_ASSERT(obj); + + void *ptr = obj->qt_metacast("QDBusContext"); + QDBusContext *q_ptr = reinterpret_cast<QDBusContext *>(ptr); + if (q_ptr) { + QDBusContextPrivate *old = q_ptr->d_ptr; + q_ptr->d_ptr = newContext; + return old; + } + + return 0; +} + +/*! + \since 4.3 + \class QDBusContext + \inmodule QtDBus + + \brief The QDBusContext class allows slots to determine the D-Bus context of the calls. + + When a slot is called in an object due to a signal delivery or due + to a remote method call, it is sometimes necessary to know the + context in which that happened. In particular, if the slot + determines that it wants to send the reply at a later opportunity + or if it wants to reply with an error, the context is needed. + + The QDBusContext class is an alternative to accessing the context + that doesn't involve modifying the code generated by the \l + {QtDBus XML Compiler (qdbusxml2cpp)}. + + QDBusContext is used by subclassing it from the objects being + exported using QDBusConnection::registerObject(). The following + example illustrates the usage: + + \snippet doc/src/snippets/code/src_qdbus_qdbuscontext.cpp 0 + + The example illustrates the two typical uses, that of sending + error replies and that of delayed replies. + + Note: do not subclass QDBusContext and QDBusAbstractAdaptor at the + same time. QDBusContext should appear in the real object, not the + adaptor. If it's necessary from the adaptor code to determine the + context, use a public inheritance and access the functions via + QObject::parent(). +*/ + +/*! + Constructs an empty QDBusContext. + */ +QDBusContext::QDBusContext() + : d_ptr(0) +{ +} + +/*! + An empty destructor. + */ +QDBusContext::~QDBusContext() +{ +} + +/*! + Returns true if we are processing a D-Bus call. If this function + returns true, the rest of the functions in this class are + available. + + Accessing those functions when this function returns false is + undefined and may lead to crashes. +*/ +bool QDBusContext::calledFromDBus() const +{ + return d_ptr; +} + +/*! + Returns the connection from which this call was received. +*/ +QDBusConnection QDBusContext::connection() const +{ + return d_ptr->connection; +} + +/*! + Returns the message that generated this call. +*/ +const QDBusMessage &QDBusContext::message() const +{ + return d_ptr->message; +} + +/*! + Returns true if this call will have a delayed reply. + + \sa setDelayedReply() +*/ +bool QDBusContext::isDelayedReply() const +{ + return message().isDelayedReply(); +} + +/*! + Sets whether this call will have a delayed reply or not. + + If \a enable is false, QtDBus will automatically generate a reply + back to the caller, if needed, as soon as the called slot returns. + + If \a enable is true, QtDBus will not generate automatic + replies. It will also ignore the return value from the slot and + any output parameters. Instead, the called object is responsible + for storing the incoming message and send a reply or error at a + later time. + + Failing to send a reply will result in an automatic timeout error + being generated by D-Bus. +*/ +void QDBusContext::setDelayedReply(bool enable) const +{ + message().setDelayedReply(enable); +} + +/*! + Sends an error \a name as a reply to the caller. The optional \a + msg parameter is a human-readable text explaining the failure. + + If an error is sent, the return value and any output parameters + from the called slot will be ignored by QtDBus. +*/ +void QDBusContext::sendErrorReply(const QString &name, const QString &msg) const +{ + setDelayedReply(true); + connection().send(message().createErrorReply(name, msg)); +} + +/*! + \overload + Sends an error \a type as a reply to the caller. The optional \a + msg parameter is a human-readable text explaining the failure. + + If an error is sent, the return value and any output parameters + from the called slot will be ignored by QtDBus. +*/ +void QDBusContext::sendErrorReply(QDBusError::ErrorType type, const QString &msg) const +{ + setDelayedReply(true); + connection().send(message().createErrorReply(type, msg)); +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbuscontext.h b/src/dbus/qdbuscontext.h new file mode 100644 index 0000000000..d7777488ed --- /dev/null +++ b/src/dbus/qdbuscontext.h @@ -0,0 +1,87 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSCONTEXT_H +#define QDBUSCONTEXT_H + +#include <QtCore/qstring.h> +#include <QtDBus/qdbuserror.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusConnection; +class QDBusMessage; + +class QDBusContextPrivate; +class Q_DBUS_EXPORT QDBusContext +{ +public: + QDBusContext(); + ~QDBusContext(); + + bool calledFromDBus() const; + QDBusConnection connection() const; + const QDBusMessage &message() const; + + // convenience methods + bool isDelayedReply() const; + // yes, they are const, so that you can use them even from const methods + void setDelayedReply(bool enable) const; + void sendErrorReply(const QString &name, const QString &msg = QString()) const; + void sendErrorReply(QDBusError::ErrorType type, const QString &msg = QString()) const; + +private: + QDBusContextPrivate *d_ptr; + friend class QDBusContextPrivate; +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbuscontext_p.h b/src/dbus/qdbuscontext_p.h new file mode 100644 index 0000000000..53ff9d08d1 --- /dev/null +++ b/src/dbus/qdbuscontext_p.h @@ -0,0 +1,83 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// 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 QDBUSCONTEXT_P_H +#define QDBUSCONTEXT_P_H + +#include <QtCore/qglobal.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +class QDBusMessage; +class QDBusConnection; + +class QDBusContext; +class QDBusContextPrivate +{ +public: + inline QDBusContextPrivate(const QDBusConnection &conn, const QDBusMessage &msg) + : connection(conn), message(msg) {} + + QDBusConnection connection; + const QDBusMessage &message; + + static QDBusContextPrivate *set(QObject *obj, QDBusContextPrivate *newContext); +}; + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif + diff --git a/src/dbus/qdbusdemarshaller.cpp b/src/dbus/qdbusdemarshaller.cpp new file mode 100644 index 0000000000..3910381284 --- /dev/null +++ b/src/dbus/qdbusdemarshaller.cpp @@ -0,0 +1,364 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusargument_p.h" +#include "qdbusconnection.h" +#include <stdlib.h> + +QT_BEGIN_NAMESPACE + +template <typename T> +static inline T qIterGet(DBusMessageIter *it) +{ + T t; + q_dbus_message_iter_get_basic(it, &t); + q_dbus_message_iter_next(it); + return t; +} + +QDBusDemarshaller::~QDBusDemarshaller() +{ +} + +inline QString QDBusDemarshaller::currentSignature() +{ + char *sig = q_dbus_message_iter_get_signature(&iterator); + QString retval = QString::fromUtf8(sig); + q_dbus_free(sig); + + return retval; +} + +inline uchar QDBusDemarshaller::toByte() +{ + return qIterGet<uchar>(&iterator); +} + +inline bool QDBusDemarshaller::toBool() +{ + return bool(qIterGet<dbus_bool_t>(&iterator)); +} + +inline ushort QDBusDemarshaller::toUShort() +{ + return qIterGet<dbus_uint16_t>(&iterator); +} + +inline short QDBusDemarshaller::toShort() +{ + return qIterGet<dbus_int16_t>(&iterator); +} + +inline int QDBusDemarshaller::toInt() +{ + return qIterGet<dbus_int32_t>(&iterator); +} + +inline uint QDBusDemarshaller::toUInt() +{ + return qIterGet<dbus_uint32_t>(&iterator); +} + +inline qlonglong QDBusDemarshaller::toLongLong() +{ + return qIterGet<qlonglong>(&iterator); +} + +inline qulonglong QDBusDemarshaller::toULongLong() +{ + return qIterGet<qulonglong>(&iterator); +} + +inline double QDBusDemarshaller::toDouble() +{ + return qIterGet<double>(&iterator); +} + +inline QString QDBusDemarshaller::toString() +{ + return QString::fromUtf8(qIterGet<char *>(&iterator)); +} + +inline QDBusObjectPath QDBusDemarshaller::toObjectPath() +{ + return QDBusObjectPath(QString::fromUtf8(qIterGet<char *>(&iterator))); +} + +inline QDBusSignature QDBusDemarshaller::toSignature() +{ + return QDBusSignature(QString::fromUtf8(qIterGet<char *>(&iterator))); +} + +inline QDBusUnixFileDescriptor QDBusDemarshaller::toUnixFileDescriptor() +{ + QDBusUnixFileDescriptor fd; + fd.giveFileDescriptor(qIterGet<dbus_int32_t>(&iterator)); + return fd; +} + +inline QDBusVariant QDBusDemarshaller::toVariant() +{ + QDBusDemarshaller sub(capabilities); + sub.message = q_dbus_message_ref(message); + q_dbus_message_iter_recurse(&iterator, &sub.iterator); + q_dbus_message_iter_next(&iterator); + + return QDBusVariant( sub.toVariantInternal() ); +} + +QDBusArgument::ElementType QDBusDemarshaller::currentType() +{ + switch (q_dbus_message_iter_get_arg_type(&iterator)) { + case DBUS_TYPE_BYTE: + case DBUS_TYPE_INT16: + case DBUS_TYPE_UINT16: + case DBUS_TYPE_INT32: + case DBUS_TYPE_UINT32: + case DBUS_TYPE_INT64: + case DBUS_TYPE_UINT64: + case DBUS_TYPE_BOOLEAN: + case DBUS_TYPE_DOUBLE: + case DBUS_TYPE_STRING: + case DBUS_TYPE_OBJECT_PATH: + case DBUS_TYPE_SIGNATURE: + return QDBusArgument::BasicType; + + case DBUS_TYPE_VARIANT: + return QDBusArgument::VariantType; + + case DBUS_TYPE_ARRAY: + switch (q_dbus_message_iter_get_element_type(&iterator)) { + case DBUS_TYPE_BYTE: + case DBUS_TYPE_STRING: + // QByteArray and QStringList + return QDBusArgument::BasicType; + case DBUS_TYPE_DICT_ENTRY: + return QDBusArgument::MapType; + default: + return QDBusArgument::ArrayType; + } + + case DBUS_TYPE_STRUCT: + return QDBusArgument::StructureType; + case DBUS_TYPE_DICT_ENTRY: + return QDBusArgument::MapEntryType; + + case DBUS_TYPE_UNIX_FD: + return capabilities & QDBusConnection::UnixFileDescriptorPassing ? + QDBusArgument::BasicType : QDBusArgument::UnknownType; + + case DBUS_TYPE_INVALID: + return QDBusArgument::UnknownType; + +// default: +// qWarning("QDBusDemarshaller: Found unknown D-Bus type %d '%c'", +// q_dbus_message_iter_get_arg_type(&iterator), +// q_dbus_message_iter_get_arg_type(&iterator)); + } + return QDBusArgument::UnknownType; +} + +QVariant QDBusDemarshaller::toVariantInternal() +{ + switch (q_dbus_message_iter_get_arg_type(&iterator)) { + case DBUS_TYPE_BYTE: + return QVariant::fromValue(toByte()); + case DBUS_TYPE_INT16: + return QVariant::fromValue(toShort()); + case DBUS_TYPE_UINT16: + return QVariant::fromValue(toUShort()); + case DBUS_TYPE_INT32: + return toInt(); + case DBUS_TYPE_UINT32: + return toUInt(); + case DBUS_TYPE_DOUBLE: + return toDouble(); + case DBUS_TYPE_BOOLEAN: + return toBool(); + case DBUS_TYPE_INT64: + return toLongLong(); + case DBUS_TYPE_UINT64: + return toULongLong(); + case DBUS_TYPE_STRING: + return toString(); + case DBUS_TYPE_OBJECT_PATH: + return QVariant::fromValue(toObjectPath()); + case DBUS_TYPE_SIGNATURE: + return QVariant::fromValue(toSignature()); + case DBUS_TYPE_VARIANT: + return QVariant::fromValue(toVariant()); + + case DBUS_TYPE_ARRAY: + switch (q_dbus_message_iter_get_element_type(&iterator)) { + case DBUS_TYPE_BYTE: + // QByteArray + return toByteArray(); + case DBUS_TYPE_STRING: + return toStringList(); + case DBUS_TYPE_DICT_ENTRY: + return QVariant::fromValue(duplicate()); + + default: + return QVariant::fromValue(duplicate()); + } + + case DBUS_TYPE_STRUCT: + return QVariant::fromValue(duplicate()); + + case DBUS_TYPE_UNIX_FD: + if (capabilities & QDBusConnection::UnixFileDescriptorPassing) + return qVariantFromValue(toUnixFileDescriptor()); + // fall through + + default: +// qWarning("QDBusDemarshaller: Found unknown D-Bus type %d '%c'", +// q_dbus_message_iter_get_arg_type(&iterator), +// q_dbus_message_iter_get_arg_type(&iterator)); + char *ptr = 0; + ptr += q_dbus_message_iter_get_arg_type(&iterator); + q_dbus_message_iter_next(&iterator); + + // I hope you never dereference this pointer! + return QVariant::fromValue<void *>(ptr); + break; + }; +} + +QStringList QDBusDemarshaller::toStringList() +{ + QStringList list; + + QDBusDemarshaller sub(capabilities); + q_dbus_message_iter_recurse(&iterator, &sub.iterator); + q_dbus_message_iter_next(&iterator); + while (!sub.atEnd()) + list.append(sub.toString()); + + return list; +} + +QByteArray QDBusDemarshaller::toByteArray() +{ + DBusMessageIter sub; + q_dbus_message_iter_recurse(&iterator, &sub); + q_dbus_message_iter_next(&iterator); + int len; + char* data; + q_dbus_message_iter_get_fixed_array(&sub,&data,&len); + return QByteArray(data,len); +} + +bool QDBusDemarshaller::atEnd() +{ + // dbus_message_iter_has_next is broken if the list has one single element + return q_dbus_message_iter_get_arg_type(&iterator) == DBUS_TYPE_INVALID; +} + +inline QDBusDemarshaller *QDBusDemarshaller::beginStructure() +{ + return beginCommon(); +} + +inline QDBusDemarshaller *QDBusDemarshaller::beginArray() +{ + return beginCommon(); +} + +inline QDBusDemarshaller *QDBusDemarshaller::beginMap() +{ + return beginCommon(); +} + +inline QDBusDemarshaller *QDBusDemarshaller::beginMapEntry() +{ + return beginCommon(); +} + +QDBusDemarshaller *QDBusDemarshaller::beginCommon() +{ + QDBusDemarshaller *d = new QDBusDemarshaller(capabilities); + d->parent = this; + d->message = q_dbus_message_ref(message); + + // recurse + q_dbus_message_iter_recurse(&iterator, &d->iterator); + q_dbus_message_iter_next(&iterator); + return d; +} + +inline QDBusDemarshaller *QDBusDemarshaller::endStructure() +{ + return endCommon(); +} + +inline QDBusDemarshaller *QDBusDemarshaller::endArray() +{ + return endCommon(); +} + +inline QDBusDemarshaller *QDBusDemarshaller::endMap() +{ + return endCommon(); +} + +inline QDBusDemarshaller *QDBusDemarshaller::endMapEntry() +{ + return endCommon(); +} + +QDBusDemarshaller *QDBusDemarshaller::endCommon() +{ + QDBusDemarshaller *retval = parent; + delete this; + return retval; +} + +QDBusArgument QDBusDemarshaller::duplicate() +{ + QDBusDemarshaller *d = new QDBusDemarshaller(capabilities); + d->iterator = iterator; + d->message = q_dbus_message_ref(message); + + q_dbus_message_iter_next(&iterator); + return QDBusArgumentPrivate::create(d); +} + +QT_END_NAMESPACE diff --git a/src/dbus/qdbuserror.cpp b/src/dbus/qdbuserror.cpp new file mode 100644 index 0000000000..7b314fd661 --- /dev/null +++ b/src/dbus/qdbuserror.cpp @@ -0,0 +1,368 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbuserror.h" + +#include <qdebug.h> +#include <qvarlengtharray.h> + +#include "qdbus_symbols_p.h" +#include "qdbusmessage.h" +#include "qdbusmessage_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +/* + * Use the following Perl script to generate the error string index list: +===== PERL SCRIPT ==== +print "static const char errorMessages_string[] =\n"; +$counter = 0; +$i = 0; +while (<STDIN>) { + chomp; + print " \"$_\\0\"\n"; + $sizes[$i++] = $counter; + $counter += 1 + length $_; +} +print " \"\\0\";\n\nstatic const int errorMessages_indices[] = {\n "; +for ($j = 0; $j < $i; ++$j) { + printf "$sizes[$j], "; +} +print "0\n};\n"; +===== PERL SCRIPT ==== + + * The input data is as follows: +other +org.freedesktop.DBus.Error.Failed +org.freedesktop.DBus.Error.NoMemory +org.freedesktop.DBus.Error.ServiceUnknown +org.freedesktop.DBus.Error.NoReply +org.freedesktop.DBus.Error.BadAddress +org.freedesktop.DBus.Error.NotSupported +org.freedesktop.DBus.Error.LimitsExceeded +org.freedesktop.DBus.Error.AccessDenied +org.freedesktop.DBus.Error.NoServer +org.freedesktop.DBus.Error.Timeout +org.freedesktop.DBus.Error.NoNetwork +org.freedesktop.DBus.Error.AddressInUse +org.freedesktop.DBus.Error.Disconnected +org.freedesktop.DBus.Error.InvalidArgs +org.freedesktop.DBus.Error.UnknownMethod +org.freedesktop.DBus.Error.TimedOut +org.freedesktop.DBus.Error.InvalidSignature +org.freedesktop.DBus.Error.UnknownInterface +com.trolltech.QtDBus.Error.InternalError +org.freedesktop.DBus.Error.UnknownObject +com.trolltech.QtDBus.Error.InvalidService +com.trolltech.QtDBus.Error.InvalidObjectPath +com.trolltech.QtDBus.Error.InvalidInterface +com.trolltech.QtDBus.Error.InvalidMember +*/ + +// in the same order as KnownErrors! +static const char errorMessages_string[] = + "other\0" + "org.freedesktop.DBus.Error.Failed\0" + "org.freedesktop.DBus.Error.NoMemory\0" + "org.freedesktop.DBus.Error.ServiceUnknown\0" + "org.freedesktop.DBus.Error.NoReply\0" + "org.freedesktop.DBus.Error.BadAddress\0" + "org.freedesktop.DBus.Error.NotSupported\0" + "org.freedesktop.DBus.Error.LimitsExceeded\0" + "org.freedesktop.DBus.Error.AccessDenied\0" + "org.freedesktop.DBus.Error.NoServer\0" + "org.freedesktop.DBus.Error.Timeout\0" + "org.freedesktop.DBus.Error.NoNetwork\0" + "org.freedesktop.DBus.Error.AddressInUse\0" + "org.freedesktop.DBus.Error.Disconnected\0" + "org.freedesktop.DBus.Error.InvalidArgs\0" + "org.freedesktop.DBus.Error.UnknownMethod\0" + "org.freedesktop.DBus.Error.TimedOut\0" + "org.freedesktop.DBus.Error.InvalidSignature\0" + "org.freedesktop.DBus.Error.UnknownInterface\0" + "com.trolltech.QtDBus.Error.InternalError\0" + "org.freedesktop.DBus.Error.UnknownObject\0" + "com.trolltech.QtDBus.Error.InvalidService\0" + "com.trolltech.QtDBus.Error.InvalidObjectPath\0" + "com.trolltech.QtDBus.Error.InvalidInterface\0" + "com.trolltech.QtDBus.Error.InvalidMember\0" + "\0"; + +static const int errorMessages_indices[] = { + 0, 6, 40, 76, 118, 153, 191, 231, + 273, 313, 349, 384, 421, 461, 501, 540, + 581, 617, 661, 705, 746, 787, 829, 874, + 918, 0 +}; + +static const int errorMessages_count = sizeof errorMessages_indices / + sizeof errorMessages_indices[0]; + +static inline const char *get(QDBusError::ErrorType code) +{ + int intcode = qBound(0, int(code) - int(QDBusError::Other), errorMessages_count); + return errorMessages_string + errorMessages_indices[intcode]; +} + +static inline QDBusError::ErrorType get(const char *name) +{ + if (!name || !*name) + return QDBusError::NoError; + for (int i = 0; i < errorMessages_count; ++i) + if (strcmp(name, errorMessages_string + errorMessages_indices[i]) == 0) + return QDBusError::ErrorType(i + int(QDBusError::Other)); + return QDBusError::Other; +} + +/*! + \class QDBusError + \inmodule QtDBus + \since 4.2 + + \brief The QDBusError class 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::createError() and + QDBusConnection::send(). + + \sa QDBusConnection::send(), QDBusMessage, QDBusReply +*/ + +/*! + \enum QDBusError::ErrorType + + 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 \e {Documentation doesn't say what this is for} + (\c org.freedesktop.DBus.Error.NoServer) + \value Timeout \e {Documentation doesn't say what this is for or how it's used} + (\c org.freedesktop.DBus.Error.Timeout) + \value NoNetwork \e {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 \e {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) + + \value InvalidObjectPath The object path provided is invalid. + + \value InvalidService The service requested is invalid. + + \value InvalidMember The member is invalid. + + \value InvalidInterface The interface is invalid. + + \value UnknownObject The remote object could not be found. +*/ + +/*! + \internal + Constructs a QDBusError from a DBusError structure. +*/ +QDBusError::QDBusError(const DBusError *error) + : code(NoError) +{ + if (!error || !q_dbus_error_is_set(error)) + return; + + code = ::get(error->name); + msg = QString::fromUtf8(error->message); + nm = QString::fromUtf8(error->name); +} + +/*! + \internal + Constructs a QDBusError from a QDBusMessage. +*/ +QDBusError::QDBusError(const QDBusMessage &qdmsg) + : code(NoError) +{ + if (qdmsg.type() != QDBusMessage::ErrorMessage) + return; + + code = ::get(qdmsg.errorName().toUtf8().constData()); + nm = qdmsg.errorName(); + msg = qdmsg.errorMessage(); +} + +/*! + \internal + Constructs a QDBusError from a well-known error code +*/ +QDBusError::QDBusError(ErrorType error, const QString &mess) + : code(error) +{ + nm = QLatin1String(::get(error)); + msg = mess; +} + +/*! + \internal + Constructs a QDBusError from another QDBusError object +*/ +QDBusError::QDBusError(const QDBusError &other) + : code(other.code), msg(other.msg), nm(other.nm) +{ +} + +/*! + \internal + Assignment operator +*/ + +QDBusError &QDBusError::operator=(const QDBusError &other) +{ + code = other.code; + msg = other.msg; + nm = other.nm; + return *this; +} + +/*! + Returns this error's ErrorType. + + \sa ErrorType +*/ + +QDBusError::ErrorType QDBusError::type() const +{ + return code; +} + +/*! + Returns this error's name. Error names are similar to D-Bus Interface names, like + \c org.freedesktop.DBus.InvalidArgs. + + \sa type() +*/ + +QString QDBusError::name() const +{ + return nm; +} + +/*! + 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. +*/ + +QString QDBusError::message() const +{ + return msg; +} + +/*! + Returns true if this is a valid error condition (i.e., if there was an error), + otherwise false. +*/ + +bool QDBusError::isValid() const +{ + return (code != NoError); +} + +/*! + \since 4.3 + Returns the error name associated with error condition \a error. +*/ +QString QDBusError::errorString(ErrorType error) +{ + return QLatin1String(::get(error)); +} + +#ifndef QT_NO_DEBUG_STREAM +QDebug operator<<(QDebug dbg, const QDBusError &msg) +{ + dbg.nospace() << "QDBusError(" << msg.name() << ", " << msg.message() << ')'; + return dbg.space(); +} +#endif + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbuserror.h b/src/dbus/qdbuserror.h new file mode 100644 index 0000000000..cd11d66932 --- /dev/null +++ b/src/dbus/qdbuserror.h @@ -0,0 +1,126 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSERROR_H +#define QDBUSERROR_H + +#include <QtDBus/qdbusmacros.h> +#include <QtCore/qstring.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +struct DBusError; + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusMessage; + +class Q_DBUS_EXPORT QDBusError +{ +public: + enum ErrorType { + NoError = 0, + Other = 1, + Failed, + NoMemory, + ServiceUnknown, + NoReply, + BadAddress, + NotSupported, + LimitsExceeded, + AccessDenied, + NoServer, + Timeout, + NoNetwork, + AddressInUse, + Disconnected, + InvalidArgs, + UnknownMethod, + TimedOut, + InvalidSignature, + UnknownInterface, + InternalError, + UnknownObject, + InvalidService, + InvalidObjectPath, + InvalidInterface, + InvalidMember, + +#ifndef Q_QDOC + // don't use this one! + LastErrorType = InvalidMember +#endif + }; + + QDBusError(const DBusError *error = 0); + QDBusError(const QDBusMessage& msg); + QDBusError(ErrorType error, const QString &message); + QDBusError(const QDBusError &other); + QDBusError &operator=(const QDBusError &other); + + ErrorType type() const; + QString name() const; + QString message() const; + bool isValid() const; + + static QString errorString(ErrorType error); + +private: + ErrorType code; + QString msg; + QString nm; + void *unused; +}; + +#ifndef QT_NO_DEBUG_STREAM +Q_DBUS_EXPORT QDebug operator<<(QDebug, const QDBusError &); +#endif + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusextratypes.cpp b/src/dbus/qdbusextratypes.cpp new file mode 100644 index 0000000000..bd7d506d34 --- /dev/null +++ b/src/dbus/qdbusextratypes.cpp @@ -0,0 +1,242 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusextratypes.h" +#include "qdbusutil_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +void QDBusObjectPath::check() +{ + if (!QDBusUtil::isValidObjectPath(*this)) { + qWarning("QDBusObjectPath: invalid path \"%s\"", qPrintable(*this)); + clear(); + } +} + +void QDBusSignature::check() +{ + if (!QDBusUtil::isValidSignature(*this)) { + qWarning("QDBusSignature: invalid signature \"%s\"", qPrintable(*this)); + clear(); + } +} + +/*! + \class QDBusVariant + \inmodule QtDBus + \since 4.2 + + \brief The QDBusVariant class enables the programmer to identify + the variant type provided by the D-Bus typesystem. + + A D-Bus function that takes an integer, a D-Bus variant and a string as parameters + can be called with the following argument list (see QDBusMessage::setArguments()): + + \snippet doc/src/snippets/qdbusextratypes/qdbusextratypes.cpp 0 + + When a D-Bus function returns a D-Bus variant, it can be retrieved as follows: + + \snippet doc/src/snippets/qdbusextratypes/qdbusextratypes.cpp 1 + + The QVariant within a QDBusVariant is required to distinguish between a normal + D-Bus value and a value within a D-Bus variant. + + \sa {The QtDBus type system} +*/ + +/*! + \fn QDBusVariant::QDBusVariant() + + Constructs a new D-Bus variant. +*/ + +/*! + \fn QDBusVariant::QDBusVariant(const QVariant &variant) + + Constructs a new D-Bus variant from the given Qt \a variant. + + \sa setVariant() +*/ + +/*! + \fn QVariant QDBusVariant::variant() const + + Returns this D-Bus variant as a QVariant object. + + \sa setVariant() +*/ + +/*! + \fn void QDBusVariant::setVariant(const QVariant &variant) + + Assigns the value of the given Qt \a variant to this D-Bus variant. + + \sa variant() +*/ + +/*! + \class QDBusObjectPath + \inmodule QtDBus + \since 4.2 + + \brief The QDBusObjectPath class enables the programmer to + identify the OBJECT_PATH type provided by the D-Bus typesystem. + + \sa {The QtDBus type system} +*/ + +/*! + \fn QDBusObjectPath::QDBusObjectPath() + + Constructs a new object path. +*/ + +/*! + \fn QDBusObjectPath::QDBusObjectPath(const char *path) + + Constructs a new object path from the given \a path. + + \sa setPath() +*/ + +/*! + \fn QDBusObjectPath::QDBusObjectPath(const QLatin1String &path) + + Constructs a new object path from the given \a path. +*/ + +/*! + \fn QDBusObjectPath::QDBusObjectPath(const QString &path) + + Constructs a new object path from the given \a path. +*/ + +/*! + \fn QString QDBusObjectPath::path() const + + Returns this object path. + + \sa setPath() +*/ + +/*! + \fn void QDBusObjectPath::setPath(const QString &path) + + Assigns the value of the given \a path to this object path. + + \sa path() +*/ + +/*! + \fn QDBusObjectPath &QDBusObjectPath::operator=(const QDBusObjectPath &path) + + Assigns the value of the given \a path to this object path. + + \sa setPath() +*/ + + +/*! + \class QDBusSignature + \inmodule QtDBus + \since 4.2 + + \brief The QDBusSignature class enables the programmer to + identify the SIGNATURE type provided by the D-Bus typesystem. + + \sa {The QtDBus type system} +*/ + +/*! + \fn QDBusSignature::QDBusSignature() + + Constructs a new signature. + + \sa setSignature() +*/ + +/*! + \fn QDBusSignature::QDBusSignature(const char *signature) + + Constructs a new signature from the given \a signature. +*/ + +/*! + \fn QDBusSignature::QDBusSignature(const QLatin1String &signature) + + Constructs a new signature from the given \a signature. +*/ + +/*! + \fn QDBusSignature::QDBusSignature(const QString &signature) + + Constructs a new signature from the given \a signature. +*/ + +/*! + \fn QString QDBusSignature::signature() const + + Returns this signature. + + \sa setSignature() +*/ + +/*! + \fn void QDBusSignature::setSignature(const QString &signature) + + Assigns the value of the given \a signature to this signature. + \sa signature() +*/ + +/*! + \fn QDBusSignature &QDBusSignature::operator=(const QDBusSignature &signature) + + Assigns the value of the given \a signature to this signature. + + \sa setSignature() +*/ + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusextratypes.h b/src/dbus/qdbusextratypes.h new file mode 100644 index 0000000000..f800062781 --- /dev/null +++ b/src/dbus/qdbusextratypes.h @@ -0,0 +1,193 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSEXTRATYPES_H +#define QDBUSEXTRATYPES_H + +// define some useful types for D-BUS + +#include <QtCore/qvariant.h> +#include <QtCore/qstring.h> +#include <QtDBus/qdbusmacros.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +// defined in qhash.cpp +Q_CORE_EXPORT uint qHash(const QString &key); + +class Q_DBUS_EXPORT QDBusObjectPath : private QString +{ +public: + inline QDBusObjectPath() { } + + inline explicit QDBusObjectPath(const char *path); + inline explicit QDBusObjectPath(const QLatin1String &path); + inline explicit QDBusObjectPath(const QString &path); + inline QDBusObjectPath &operator=(const QDBusObjectPath &path); + + inline void setPath(const QString &path); + + inline QString path() const + { return *this; } + +private: + void check(); +}; + +inline QDBusObjectPath::QDBusObjectPath(const char *objectPath) + : QString(QString::fromLatin1(objectPath)) +{ check(); } + +inline QDBusObjectPath::QDBusObjectPath(const QLatin1String &objectPath) + : QString(objectPath) +{ check(); } + +inline QDBusObjectPath::QDBusObjectPath(const QString &objectPath) + : QString(objectPath) +{ check(); } + +inline QDBusObjectPath &QDBusObjectPath::operator=(const QDBusObjectPath &_path) +{ QString::operator=(_path); check(); return *this; } + +inline void QDBusObjectPath::setPath(const QString &objectPath) +{ QString::operator=(objectPath); check(); } + +inline bool operator==(const QDBusObjectPath &lhs, const QDBusObjectPath &rhs) +{ return lhs.path() == rhs.path(); } + +inline bool operator!=(const QDBusObjectPath &lhs, const QDBusObjectPath &rhs) +{ return lhs.path() != rhs.path(); } + +inline bool operator<(const QDBusObjectPath &lhs, const QDBusObjectPath &rhs) +{ return lhs.path() < rhs.path(); } + +inline uint qHash(const QDBusObjectPath &objectPath) +{ return qHash(objectPath.path()); } + + +class Q_DBUS_EXPORT QDBusSignature : private QString +{ +public: + inline QDBusSignature() { } + + inline explicit QDBusSignature(const char *signature); + inline explicit QDBusSignature(const QLatin1String &signature); + inline explicit QDBusSignature(const QString &signature); + inline QDBusSignature &operator=(const QDBusSignature &signature); + + inline void setSignature(const QString &signature); + + inline QString signature() const + { return *this; } + +private: + void check(); +}; + +inline QDBusSignature::QDBusSignature(const char *dBusSignature) + : QString(QString::fromAscii(dBusSignature)) +{ check(); } + +inline QDBusSignature::QDBusSignature(const QLatin1String &dBusSignature) + : QString(dBusSignature) +{ check(); } + +inline QDBusSignature::QDBusSignature(const QString &dBusSignature) + : QString(dBusSignature) +{ check(); } + +inline QDBusSignature &QDBusSignature::operator=(const QDBusSignature &dbusSignature) +{ QString::operator=(dbusSignature); check(); return *this; } + +inline void QDBusSignature::setSignature(const QString &dBusSignature) +{ QString::operator=(dBusSignature); check(); } + +inline bool operator==(const QDBusSignature &lhs, const QDBusSignature &rhs) +{ return lhs.signature() == rhs.signature(); } + +inline bool operator!=(const QDBusSignature &lhs, const QDBusSignature &rhs) +{ return lhs.signature() != rhs.signature(); } + +inline bool operator<(const QDBusSignature &lhs, const QDBusSignature &rhs) +{ return lhs.signature() < rhs.signature(); } + +inline uint qHash(const QDBusSignature &signature) +{ return qHash(signature.signature()); } + +class QDBusVariant : private QVariant +{ +public: + inline QDBusVariant() { } + inline explicit QDBusVariant(const QVariant &variant); + + inline void setVariant(const QVariant &variant); + + inline QVariant variant() const + { return *this; } +}; + +inline QDBusVariant::QDBusVariant(const QVariant &dBusVariant) + : QVariant(dBusVariant) { } + +inline void QDBusVariant::setVariant(const QVariant &dBusVariant) +{ QVariant::operator=(dBusVariant); } + +inline bool operator==(const QDBusVariant &v1, const QDBusVariant &v2) +{ return v1.variant() == v2.variant(); } + +QT_END_NAMESPACE + +Q_DECLARE_METATYPE(QDBusVariant) +Q_DECLARE_METATYPE(QDBusObjectPath) +Q_DECLARE_METATYPE(QList<QDBusObjectPath>) +Q_DECLARE_METATYPE(QDBusSignature) +Q_DECLARE_METATYPE(QList<QDBusSignature>) + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusintegrator.cpp b/src/dbus/qdbusintegrator.cpp new file mode 100644 index 0000000000..b2095c747e --- /dev/null +++ b/src/dbus/qdbusintegrator.cpp @@ -0,0 +1,2411 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <qcoreapplication.h> +#include <qdebug.h> +#include <qmetaobject.h> +#include <qobject.h> +#include <qsocketnotifier.h> +#include <qstringlist.h> +#include <qtimer.h> +#include <qthread.h> + +#include "qdbusargument.h" +#include "qdbusconnection_p.h" +#include "qdbusinterface_p.h" +#include "qdbusmessage.h" +#include "qdbusmetatype.h" +#include "qdbusmetatype_p.h" +#include "qdbusabstractadaptor.h" +#include "qdbusabstractadaptor_p.h" +#include "qdbusutil_p.h" +#include "qdbusmessage_p.h" +#include "qdbuscontext_p.h" +#include "qdbuspendingcall_p.h" +#include "qdbusintegrator_p.h" + +#include "qdbusthreaddebug_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +static bool isDebugging; +#define qDBusDebug if (!::isDebugging); else qDebug + +Q_GLOBAL_STATIC_WITH_ARGS(const QString, orgFreedesktopDBusString, (QLatin1String(DBUS_SERVICE_DBUS))) + +static inline QString dbusServiceString() +{ return *orgFreedesktopDBusString(); } +static inline QString dbusInterfaceString() +{ + // it's the same string, but just be sure + Q_ASSERT(*orgFreedesktopDBusString() == QLatin1String(DBUS_INTERFACE_DBUS)); + return *orgFreedesktopDBusString(); +} + +static inline QDebug operator<<(QDebug dbg, const QThread *th) +{ + dbg.nospace() << "QThread(ptr=" << (void*)th; + if (th && !th->objectName().isEmpty()) + dbg.nospace() << ", name=" << th->objectName(); + dbg.nospace() << ')'; + return dbg.space(); +} + +#if QDBUS_THREAD_DEBUG +static inline QDebug operator<<(QDebug dbg, const QDBusConnectionPrivate *conn) +{ + dbg.nospace() << "QDBusConnection(" + << "ptr=" << (void*)conn + << ", name=" << conn->name + << ", baseService=" << conn->baseService + << ", thread="; + if (conn->thread() == QThread::currentThread()) + dbg.nospace() << "same thread"; + else + dbg.nospace() << conn->thread(); + dbg.nospace() << ')'; + return dbg.space(); +} + +Q_AUTOTEST_EXPORT void qdbusDefaultThreadDebug(int action, int condition, QDBusConnectionPrivate *conn) +{ + qDBusDebug() << QThread::currentThread() + << "QtDBus threading action" << action + << (condition == QDBusLockerBase::BeforeLock ? "before lock" : + condition == QDBusLockerBase::AfterLock ? "after lock" : + condition == QDBusLockerBase::BeforeUnlock ? "before unlock" : + condition == QDBusLockerBase::AfterUnlock ? "after unlock" : + condition == QDBusLockerBase::BeforePost ? "before event posting" : + condition == QDBusLockerBase::AfterPost ? "after event posting" : + condition == QDBusLockerBase::BeforeDeliver ? "before event delivery" : + condition == QDBusLockerBase::AfterDeliver ? "after event delivery" : + condition == QDBusLockerBase::BeforeAcquire ? "before acquire" : + condition == QDBusLockerBase::AfterAcquire ? "after acquire" : + condition == QDBusLockerBase::BeforeRelease ? "before release" : + condition == QDBusLockerBase::AfterRelease ? "after release" : + "condition unknown") + << "in connection" << conn; +} +Q_AUTOTEST_EXPORT qdbusThreadDebugFunc qdbusThreadDebug = 0; +#endif + +typedef void (*QDBusSpyHook)(const QDBusMessage&); +typedef QVarLengthArray<QDBusSpyHook, 4> QDBusSpyHookList; +Q_GLOBAL_STATIC(QDBusSpyHookList, qDBusSpyHookList) + +extern "C" { + + // libdbus-1 callbacks + +static bool qDBusRealAddTimeout(QDBusConnectionPrivate *d, DBusTimeout *timeout, int ms); +static dbus_bool_t qDBusAddTimeout(DBusTimeout *timeout, void *data) +{ + Q_ASSERT(timeout); + Q_ASSERT(data); + + // qDebug("addTimeout %d", q_dbus_timeout_get_interval(timeout)); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + + if (!q_dbus_timeout_get_enabled(timeout)) + return true; + + QDBusWatchAndTimeoutLocker locker(AddTimeoutAction, d); + if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) { + // correct thread + return qDBusRealAddTimeout(d, timeout, q_dbus_timeout_get_interval(timeout)); + } else { + // wrong thread: sync back + QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent; + ev->subtype = QDBusConnectionCallbackEvent::AddTimeout; + d->timeoutsPendingAdd.append(qMakePair(timeout, q_dbus_timeout_get_interval(timeout))); + d->postEventToThread(AddTimeoutAction, d, ev); + return true; + } +} + +static bool qDBusRealAddTimeout(QDBusConnectionPrivate *d, DBusTimeout *timeout, int ms) +{ + Q_ASSERT(d->timeouts.keys(timeout).isEmpty()); + + int timerId = d->startTimer(ms); + 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); + + QDBusWatchAndTimeoutLocker locker(RemoveTimeoutAction, d); + + // is it pending addition? + QDBusConnectionPrivate::PendingTimeoutList::iterator pit = d->timeoutsPendingAdd.begin(); + while (pit != d->timeoutsPendingAdd.end()) { + if (pit->first == timeout) + pit = d->timeoutsPendingAdd.erase(pit); + else + ++pit; + } + + // is it a running timer? + bool correctThread = QCoreApplication::instance() && QThread::currentThread() == d->thread(); + QDBusConnectionPrivate::TimeoutHash::iterator it = d->timeouts.begin(); + while (it != d->timeouts.end()) { + if (it.value() == timeout) { + if (correctThread) { + // correct thread + d->killTimer(it.key()); + } else { + // incorrect thread or no application, post an event for later + QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent; + ev->subtype = QDBusConnectionCallbackEvent::KillTimer; + ev->timerId = it.key(); + d->postEventToThread(KillTimerAction, d, ev); + } + it = d->timeouts.erase(it); + break; + } else { + ++it; + } + } +} + +static void qDBusToggleTimeout(DBusTimeout *timeout, void *data) +{ + Q_ASSERT(timeout); + Q_ASSERT(data); + + //qDebug("ToggleTimeout"); + + qDBusRemoveTimeout(timeout, data); + qDBusAddTimeout(timeout, data); +} + +static bool qDBusRealAddWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int flags, int fd); +static dbus_bool_t qDBusAddWatch(DBusWatch *watch, void *data) +{ + Q_ASSERT(watch); + Q_ASSERT(data); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + + int flags = q_dbus_watch_get_flags(watch); + int fd = q_dbus_watch_get_fd(watch); + + if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) { + return qDBusRealAddWatch(d, watch, flags, fd); + } else { + QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent; + ev->subtype = QDBusConnectionCallbackEvent::AddWatch; + ev->watch = watch; + ev->fd = fd; + ev->extra = flags; + d->postEventToThread(AddWatchAction, d, ev); + return true; + } +} + +static bool qDBusRealAddWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int flags, int fd) +{ + QDBusConnectionPrivate::Watcher watcher; + + QDBusWatchAndTimeoutLocker locker(AddWatchAction, d); + if (flags & DBUS_WATCH_READABLE) { + //qDebug("addReadWatch %d", fd); + watcher.watch = watch; + if (QCoreApplication::instance()) { + watcher.read = new QSocketNotifier(fd, QSocketNotifier::Read, d); + watcher.read->setEnabled(q_dbus_watch_get_enabled(watch)); + d->connect(watcher.read, SIGNAL(activated(int)), SLOT(socketRead(int))); + } + } + if (flags & DBUS_WATCH_WRITABLE) { + //qDebug("addWriteWatch %d", fd); + watcher.watch = watch; + if (QCoreApplication::instance()) { + watcher.write = new QSocketNotifier(fd, QSocketNotifier::Write, d); + watcher.write->setEnabled(q_dbus_watch_get_enabled(watch)); + d->connect(watcher.write, SIGNAL(activated(int)), SLOT(socketWrite(int))); + } + } + d->watchers.insertMulti(fd, watcher); + + return true; +} + +static void qDBusRemoveWatch(DBusWatch *watch, void *data) +{ + Q_ASSERT(watch); + Q_ASSERT(data); + + //qDebug("remove watch"); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + int fd = q_dbus_watch_get_fd(watch); + + QDBusWatchAndTimeoutLocker locker(RemoveWatchAction, d); + QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd); + while (i != d->watchers.end() && i.key() == fd) { + if (i.value().watch == watch) { + if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) { + // correct thread, delete the socket notifiers + delete i.value().read; + delete i.value().write; + } else { + // incorrect thread or no application, use delete later + if (i->read) + i->read->deleteLater(); + if (i->write) + i->write->deleteLater(); + } + i = d->watchers.erase(i); + } else { + ++i; + } + } +} + +static void qDBusRealToggleWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int fd); +static void qDBusToggleWatch(DBusWatch *watch, void *data) +{ + Q_ASSERT(watch); + Q_ASSERT(data); + + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + int fd = q_dbus_watch_get_fd(watch); + + if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) { + qDBusRealToggleWatch(d, watch, fd); + } else { + QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent; + ev->subtype = QDBusConnectionCallbackEvent::ToggleWatch; + ev->watch = watch; + ev->fd = fd; + d->postEventToThread(ToggleWatchAction, d, ev); + } +} + +static void qDBusRealToggleWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int fd) +{ + QDBusWatchAndTimeoutLocker locker(ToggleWatchAction, d); + + QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd); + while (i != d->watchers.end() && i.key() == fd) { + if (i.value().watch == watch) { + bool enabled = q_dbus_watch_get_enabled(watch); + int flags = q_dbus_watch_get_flags(watch); + + //qDebug("toggle watch %d to %d (write: %d, read: %d)", q_dbus_watch_get_fd(watch), enabled, flags & DBUS_WATCH_WRITABLE, flags & DBUS_WATCH_READABLE); + + if (flags & DBUS_WATCH_READABLE && i.value().read) + i.value().read->setEnabled(enabled); + if (flags & DBUS_WATCH_WRITABLE && i.value().write) + i.value().write->setEnabled(enabled); + return; + } + ++i; + } +} + +static void qDBusUpdateDispatchStatus(DBusConnection *connection, DBusDispatchStatus new_status, void *data) +{ + Q_ASSERT(connection); + Q_UNUSED(connection); + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + + static int slotId; // 0 is QObject::deleteLater() + if (!slotId) { + // it's ok to do this: there's no race condition because the store is atomic + // and we always set to the same value + slotId = QDBusConnectionPrivate::staticMetaObject.indexOfSlot("doDispatch()"); + } + + //qDBusDebug() << "Updating dispatcher status" << slotId; + if (new_status == DBUS_DISPATCH_DATA_REMAINS) + QDBusConnectionPrivate::staticMetaObject.method(slotId). + invoke(d, Qt::QueuedConnection); +} + +static void qDBusNewConnection(DBusServer *server, DBusConnection *connection, void *data) +{ + // ### We may want to separate the server from the QDBusConnectionPrivate + Q_ASSERT(server); Q_UNUSED(server); + Q_ASSERT(connection); + Q_ASSERT(data); + + // keep the connection alive + q_dbus_connection_ref(connection); + QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data); + + // setPeer does the error handling for us + QDBusErrorInternal error; + d->setPeer(connection, error); + + QDBusConnection retval = QDBusConnectionPrivate::q(d); + + // make QDBusServer emit the newConnection signal + d->serverConnection(retval); +} + +} // extern "C" + +static QByteArray buildMatchRule(const QString &service, + const QString &objectPath, const QString &interface, + const QString &member, const QStringList &argMatch, const QString & /*signature*/) +{ + QString result = QLatin1String("type='signal',"); + QString keyValue = QLatin1String("%1='%2',"); + + if (!service.isEmpty()) + result += keyValue.arg(QLatin1String("sender"), service); + if (!objectPath.isEmpty()) + result += keyValue.arg(QLatin1String("path"), objectPath); + if (!interface.isEmpty()) + result += keyValue.arg(QLatin1String("interface"), interface); + if (!member.isEmpty()) + result += keyValue.arg(QLatin1String("member"), member); + + // add the argument string-matching now + if (!argMatch.isEmpty()) { + keyValue = QLatin1String("arg%1='%2',"); + for (int i = 0; i < argMatch.count(); ++i) + if (!argMatch.at(i).isNull()) + result += keyValue.arg(i).arg(argMatch.at(i)); + } + + result.chop(1); // remove ending comma + return result.toLatin1(); +} + +static bool findObject(const QDBusConnectionPrivate::ObjectTreeNode *root, + const QString &fullpath, int &usedLength, + QDBusConnectionPrivate::ObjectTreeNode &result) +{ + if (!fullpath.compare(QLatin1String("/")) && root->obj) { + usedLength = 1; + result = *root; + return root; + } + int start = 0; + int length = fullpath.length(); + if (fullpath.at(0) == QLatin1Char('/')) + start = 1; + + // walk the object tree + const QDBusConnectionPrivate::ObjectTreeNode *node = root; + while (start < length && node && !(node->flags & QDBusConnection::ExportChildObjects)) { + int end = fullpath.indexOf(QLatin1Char('/'), start); + end = (end == -1 ? length : end); + QStringRef pathComponent(&fullpath, start, end - start); + + QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it = + qLowerBound(node->children.constBegin(), node->children.constEnd(), pathComponent); + if (it != node->children.constEnd() && it->name == pathComponent) + // match + node = it; + else + node = 0; + + start = end + 1; + } + + // found our object + usedLength = (start > length ? length : start); + if (node) { + if (node->obj || !node->children.isEmpty()) + result = *node; + else + // there really is no object here + // we're just looking at an unused space in the QVector + node = 0; + } + return node; +} + +static QObject *findChildObject(const QDBusConnectionPrivate::ObjectTreeNode *root, + const QString &fullpath, int start) +{ + int length = fullpath.length(); + + // any object in the tree can tell us to switch to its own object tree: + const QDBusConnectionPrivate::ObjectTreeNode *node = root; + if (node && node->flags & QDBusConnection::ExportChildObjects) { + QObject *obj = node->obj; + + while (obj) { + if (start >= length) + // we're at the correct level + return obj; + + int pos = fullpath.indexOf(QLatin1Char('/'), start); + pos = (pos == -1 ? length : pos); + QStringRef pathComponent(&fullpath, start, pos - start); + + const QObjectList children = obj->children(); + + // find a child with the proper name + QObject *next = 0; + QObjectList::ConstIterator it = children.constBegin(); + QObjectList::ConstIterator end = children.constEnd(); + for ( ; it != end; ++it) + if ((*it)->objectName() == pathComponent) { + next = *it; + break; + } + + if (!next) + break; + + obj = next; + start = pos + 1; + } + } + + // object not found + return 0; +} + +static bool shouldWatchService(const QString &service) +{ + return !service.isEmpty() && !service.startsWith(QLatin1Char(':')); +} + +extern Q_DBUS_EXPORT void qDBusAddSpyHook(QDBusSpyHook); +void qDBusAddSpyHook(QDBusSpyHook hook) +{ + qDBusSpyHookList()->append(hook); +} + +extern "C" { +static DBusHandlerResult +qDBusSignalFilter(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 = QDBusMessagePrivate::fromDBusMessage(message, d->capabilities); + qDBusDebug() << d << "got message (signal):" << amsg; + + return d->handleMessage(amsg) ? + DBUS_HANDLER_RESULT_HANDLED : + DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} +} + +bool QDBusConnectionPrivate::handleMessage(const QDBusMessage &amsg) +{ + const QDBusSpyHookList *list = qDBusSpyHookList(); + for (int i = 0; i < list->size(); ++i) { + qDBusDebug() << "calling the message spy hook"; + (*(*list)[i])(amsg); + } + + if (!ref) + return false; + + switch (amsg.type()) { + case QDBusMessage::SignalMessage: + handleSignal(amsg); + // if there are any other filters in this DBusConnection, + // let them see the signal too + return false; + case QDBusMessage::MethodCallMessage: + handleObjectCall(amsg); + return true; + case QDBusMessage::ReplyMessage: + case QDBusMessage::ErrorMessage: + case QDBusMessage::InvalidMessage: + return false; // we don't handle those here + } + + return false; +} + +static void huntAndDestroy(QObject *needle, QDBusConnectionPrivate::ObjectTreeNode &haystack) +{ + QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator it = haystack.children.begin(); + QDBusConnectionPrivate::ObjectTreeNode::DataList::Iterator end = haystack.children.end(); + for ( ; it != end; ++it) + huntAndDestroy(needle, *it); + + if (needle == haystack.obj) { + haystack.obj = 0; + haystack.flags = 0; + } +} + +static void huntAndEmit(DBusConnection *connection, DBusMessage *msg, + QObject *needle, const QDBusConnectionPrivate::ObjectTreeNode &haystack, + bool isScriptable, bool isAdaptor, const QString &path = QString()) +{ + QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it = haystack.children.constBegin(); + QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator end = haystack.children.constEnd(); + for ( ; it != end; ++it) + huntAndEmit(connection, msg, needle, *it, isScriptable, isAdaptor, path + QLatin1Char('/') + it->name); + + if (needle == haystack.obj) { + // is this a signal we should relay? + if (isAdaptor && (haystack.flags & QDBusConnection::ExportAdaptors) == 0) + return; // no: it comes from an adaptor and we're not exporting adaptors + else if (!isAdaptor) { + int mask = isScriptable + ? QDBusConnection::ExportScriptableSignals + : QDBusConnection::ExportNonScriptableSignals; + if ((haystack.flags & mask) == 0) + return; // signal was not exported + } + + QByteArray p = path.toLatin1(); + if (p.isEmpty()) + p = "/"; + qDBusDebug() << QThread::currentThread() << "emitting signal at" << p; + DBusMessage *msg2 = q_dbus_message_copy(msg); + q_dbus_message_set_path(msg2, p); + q_dbus_connection_send(connection, msg2, 0); + q_dbus_message_unref(msg2); + } +} + +static int findSlot(const QMetaObject *mo, const QByteArray &name, int flags, + const QString &signature_, QList<int>& metaTypes) +{ + QByteArray msgSignature = signature_.toLatin1(); + + for (int idx = mo->methodCount() - 1 ; idx >= QObject::staticMetaObject.methodCount(); --idx) { + QMetaMethod mm = mo->method(idx); + + // check access: + if (mm.access() != QMetaMethod::Public) + continue; + + // check type: + if (mm.methodType() != QMetaMethod::Slot && mm.methodType() != QMetaMethod::Method) + continue; + + // check name: + QByteArray slotname = mm.signature(); + int paren = slotname.indexOf('('); + if (paren != name.length() || !slotname.startsWith(name)) + continue; + + int returnType = qDBusNameToTypeId(mm.typeName()); + bool isAsync = qDBusCheckAsyncTag(mm.tag()); + bool isScriptable = mm.attributes() & QMetaMethod::Scriptable; + + // consistency check: + if (isAsync && returnType != QMetaType::Void) + continue; + + int inputCount = qDBusParametersForMethod(mm, metaTypes); + if (inputCount == -1) + continue; // problem parsing + + metaTypes[0] = returnType; + bool hasMessage = false; + if (inputCount > 0 && + metaTypes.at(inputCount) == QDBusMetaTypeId::message) { + // "no input parameters" is allowed as long as the message meta type is there + hasMessage = true; + --inputCount; + } + + // try to match the parameters + int i; + QByteArray reconstructedSignature; + for (i = 1; i <= inputCount; ++i) { + const char *typeSignature = QDBusMetaType::typeToSignature( metaTypes.at(i) ); + if (!typeSignature) + break; // invalid + + reconstructedSignature += typeSignature; + if (!msgSignature.startsWith(reconstructedSignature)) + break; + } + + if (reconstructedSignature != msgSignature) + continue; // we didn't match them all + + if (hasMessage) + ++i; + + // make sure that the output parameters have signatures too + if (returnType != 0 && QDBusMetaType::typeToSignature(returnType) == 0) + continue; + + bool ok = true; + for (int j = i; ok && j < metaTypes.count(); ++j) + if (QDBusMetaType::typeToSignature(metaTypes.at(i)) == 0) + ok = false; + if (!ok) + continue; + + // consistency check: + if (isAsync && metaTypes.count() > i + 1) + continue; + + if (mm.methodType() == QMetaMethod::Slot) { + if (isScriptable && (flags & QDBusConnection::ExportScriptableSlots) == 0) + continue; // scriptable slots not exported + if (!isScriptable && (flags & QDBusConnection::ExportNonScriptableSlots) == 0) + continue; // non-scriptable slots not exported + } else { + if (isScriptable && (flags & QDBusConnection::ExportScriptableInvokables) == 0) + continue; // scriptable invokables not exported + if (!isScriptable && (flags & QDBusConnection::ExportNonScriptableInvokables) == 0) + continue; // non-scriptable invokables not exported + } + + // if we got here, this slot matched + return idx; + } + + // no slot matched + return -1; +} + +static QDBusCallDeliveryEvent * const DIRECT_DELIVERY = (QDBusCallDeliveryEvent *)1; + +QDBusCallDeliveryEvent* QDBusConnectionPrivate::prepareReply(QDBusConnectionPrivate *target, + QObject *object, int idx, + const QList<int> &metaTypes, + const QDBusMessage &msg) +{ + Q_ASSERT(object); + Q_UNUSED(object); + + int n = metaTypes.count() - 1; + if (metaTypes[n] == QDBusMetaTypeId::message) + --n; + + if (msg.arguments().count() < n) + return 0; // too few arguments + + // check that types match + for (int i = 0; i < n; ++i) + if (metaTypes.at(i + 1) != msg.arguments().at(i).userType() && + msg.arguments().at(i).userType() != qMetaTypeId<QDBusArgument>()) + return 0; // no match + + // we can deliver + // prepare for the call + if (target == object) + return DIRECT_DELIVERY; + return new QDBusCallDeliveryEvent(QDBusConnection(target), idx, target, msg, metaTypes); +} + +void 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) + QDBusCallDeliveryEvent *call = prepareReply(this, hook.obj, hook.midx, hook.params, msg); + if (call == DIRECT_DELIVERY) { + // short-circuit delivery + Q_ASSERT(this == hook.obj); + deliverCall(this, 0, msg, hook.params, hook.midx); + return; + } + if (call) + postEventToThread(ActivateSignalAction, hook.obj, call); +} + +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 member + // - ALL of the message's types are found in slot's parameter list + // - optionally has one more parameter of type QDBusMessage + // If none match, then the slot of the same name as the message target and with + // the first type of QDBusMessage is delivered. + // + // The D-Bus specification requires that all MethodCall messages be replied to, unless the + // caller specifically waived this requirement. This means that we inspect if the user slot + // generated a reply and, if it didn't, we will. Obviously, if the user slot doesn't take a + // QDBusMessage parameter, it cannot generate a reply. + // + // When a return message is generated, the slot's return type, if any, will be placed + // in the message's first position. If there are non-const reference parameters to the + // slot, they must appear at the end and will be placed in the subsequent message + // positions. + + static const char cachePropertyName[] = "_qdbus_slotCache"; + + if (!object) + return false; + +#ifndef QT_NO_PROPERTIES + Q_ASSERT_X(QThread::currentThread() == object->thread(), + "QDBusConnection: internal threading error", + "function called for an object that is in another thread!!"); + + QDBusSlotCache slotCache = + qvariant_cast<QDBusSlotCache>(object->property(cachePropertyName)); + QString cacheKey = msg.member(), signature = msg.signature(); + if (!signature.isEmpty()) { + cacheKey.reserve(cacheKey.length() + 1 + signature.length()); + cacheKey += QLatin1Char('.'); + cacheKey += signature; + } + + QDBusSlotCache::Hash::ConstIterator cacheIt = slotCache.hash.constFind(cacheKey); + while (cacheIt != slotCache.hash.constEnd() && cacheIt->flags != flags && + cacheIt.key() == cacheKey) + ++cacheIt; + if (cacheIt == slotCache.hash.constEnd() || cacheIt.key() != cacheKey) + { + // not cached, analyze the meta object + const QMetaObject *mo = object->metaObject(); + QByteArray memberName = msg.member().toUtf8(); + + // find a slot that matches according to the rules above + QDBusSlotCache::Data slotData; + slotData.flags = flags; + slotData.slotIdx = ::findSlot(mo, memberName, flags, msg.signature(), slotData.metaTypes); + if (slotData.slotIdx == -1) { + // ### this is where we want to add the connection as an arg too + // try with no parameters, but with a QDBusMessage + slotData.slotIdx = ::findSlot(mo, memberName, flags, QString(), slotData.metaTypes); + if (slotData.metaTypes.count() != 2 || + slotData.metaTypes.at(1) != QDBusMetaTypeId::message) { + // not found + // save the negative lookup + slotData.slotIdx = -1; + slotData.metaTypes.clear(); + slotCache.hash.insert(cacheKey, slotData); + object->setProperty(cachePropertyName, QVariant::fromValue(slotCache)); + return false; + } + } + + // save to the cache + slotCache.hash.insert(cacheKey, slotData); + object->setProperty(cachePropertyName, QVariant::fromValue(slotCache)); + + // found the slot to be called + deliverCall(object, flags, msg, slotData.metaTypes, slotData.slotIdx); + return true; + } else if (cacheIt->slotIdx == -1) { + // negative cache + return false; + } else { + // use the cache + deliverCall(object, flags, msg, cacheIt->metaTypes, cacheIt->slotIdx); + return true; + } +#endif // QT_NO_PROPERTIES + return false; +} + +void QDBusConnectionPrivate::deliverCall(QObject *object, int /*flags*/, const QDBusMessage &msg, + const QList<int> &metaTypes, int slotIdx) +{ + Q_ASSERT_X(!object || QThread::currentThread() == object->thread(), + "QDBusConnection: internal threading error", + "function called for an object that is in another thread!!"); + + QVarLengthArray<void *, 10> params; + params.reserve(metaTypes.count()); + + QVariantList auxParameters; + // let's create the parameter list + + // first one is the return type -- add it below + params.append(0); + + // add the input parameters + int i; + int pCount = qMin(msg.arguments().count(), metaTypes.count() - 1); + for (i = 1; i <= pCount; ++i) { + int id = metaTypes[i]; + if (id == QDBusMetaTypeId::message) + break; + + const QVariant &arg = msg.arguments().at(i - 1); + if (arg.userType() == id) + // no conversion needed + params.append(const_cast<void *>(arg.constData())); + else if (arg.userType() == qMetaTypeId<QDBusArgument>()) { + // convert to what the function expects + void *null = 0; + auxParameters.append(QVariant(id, null)); + + const QDBusArgument &in = + *reinterpret_cast<const QDBusArgument *>(arg.constData()); + QVariant &out = auxParameters[auxParameters.count() - 1]; + + if (!QDBusMetaType::demarshall(in, out.userType(), out.data())) + qFatal("Internal error: demarshalling function for type '%s' (%d) failed!", + out.typeName(), out.userType()); + + params.append(const_cast<void *>(out.constData())); + } else { + qFatal("Internal error: got invalid meta type %d (%s) " + "when trying to convert to meta type %d (%s)", + arg.userType(), QMetaType::typeName(arg.userType()), + id, QMetaType::typeName(id)); + } + } + + bool takesMessage = false; + if (metaTypes.count() > i && metaTypes[i] == QDBusMetaTypeId::message) { + 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 (!object) { + fail = true; + } else { + // FIXME: save the old sender! + QDBusContextPrivate context(QDBusConnection(this), msg); + QDBusContextPrivate *old = QDBusContextPrivate::set(object, &context); + QDBusConnectionPrivate::setSender(this); + + QPointer<QObject> ptr = object; + fail = object->qt_metacall(QMetaObject::InvokeMetaMethod, + slotIdx, params.data()) >= 0; + QDBusConnectionPrivate::setSender(0); + // the object might be deleted in the slot + if (!ptr.isNull()) + QDBusContextPrivate::set(object, old); + } + + // do we create a reply? Only if the caller is waiting for a reply and one hasn't been sent + // yet. + if (msg.isReplyRequired() && !msg.isDelayedReply()) { + if (!fail) { + // normal reply + qDBusDebug() << this << "Automatically sending reply:" << outputArgs; + send(msg.createReply(outputArgs)); + } else { + // generate internal error + qWarning("Internal error: Failed to deliver message"); + send(msg.createErrorReply(QDBusError::InternalError, + QLatin1String("Failed to deliver message"))); + } + } + + return; +} + +extern bool qDBusInitThreads(); + +QDBusConnectionPrivate::QDBusConnectionPrivate(QObject *p) + : QObject(p), ref(1), capabilities(0), mode(InvalidMode), connection(0), server(0), busService(0), + watchAndTimeoutLock(QMutex::Recursive), + rootNode(QString(QLatin1Char('/'))) +{ + static const bool threads = q_dbus_threads_init_default(); + static const int debugging = qgetenv("QDBUS_DEBUG").toInt(); + ::isDebugging = debugging; + Q_UNUSED(threads) + Q_UNUSED(debugging) + +#ifdef QDBUS_THREAD_DEBUG + if (debugging > 1) + qdbusThreadDebug = qdbusDefaultThreadDebug; +#endif + + QDBusMetaTypeId::init(); + + rootNode.flags = 0; + + // prepopulate watchedServices: + // we know that the owner of org.freedesktop.DBus is itself + watchedServices.insert(dbusServiceString(), WatchedServiceData(dbusServiceString(), 1)); + + // prepopulate matchRefCounts: + // we know that org.freedesktop.DBus will never change owners + matchRefCounts.insert("type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',arg0='org.freedesktop.DBus'", 1); +} + +QDBusConnectionPrivate::~QDBusConnectionPrivate() +{ + if (thread() && thread() != QThread::currentThread()) + qWarning("QDBusConnection(name=\"%s\")'s last reference in not in its creation thread! " + "Timer and socket errors will follow and the program will probably crash", + qPrintable(name)); + + closeConnection(); + rootNode.children.clear(); // free resources + qDeleteAll(cachedMetaObjects); + + if (server) + q_dbus_server_unref(server); + if (connection) + q_dbus_connection_unref(connection); + + connection = 0; + server = 0; +} + +void QDBusConnectionPrivate::deleteYourself() +{ + if (thread() && thread() != QThread::currentThread()) { + // last reference dropped while not in the correct thread + // ask the correct thread to delete + + // note: since we're posting an event to another thread, we + // must consider deleteLater() to take effect immediately + deleteLater(); + } else { + delete this; + } +} + +void QDBusConnectionPrivate::closeConnection() +{ + QDBusWriteLocker locker(CloseConnectionAction, this); + ConnectionMode oldMode = mode; + mode = InvalidMode; // prevent reentrancy + baseService.clear(); + + if (server) + q_dbus_server_disconnect(server); + + if (oldMode == ClientMode || oldMode == PeerMode) { + if (connection) { + q_dbus_connection_close(connection); + // send the "close" message + while (q_dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS) + ; + } + } +} + +void QDBusConnectionPrivate::checkThread() +{ + if (!thread()) { + if (QCoreApplication::instance()) + moveToThread(QCoreApplication::instance()->thread()); + else + qWarning("The thread that had QDBusConnection('%s') has died and there is no main thread", + qPrintable(name)); + } +} + +bool QDBusConnectionPrivate::handleError(const QDBusErrorInternal &error) +{ + if (!error) + return false; // no error + + //lock.lockForWrite(); + lastError = error; + //lock.unlock(); + return true; +} + +void QDBusConnectionPrivate::timerEvent(QTimerEvent *e) +{ + { + QDBusWatchAndTimeoutLocker locker(TimerEventAction, this); + DBusTimeout *timeout = timeouts.value(e->timerId(), 0); + if (timeout) + q_dbus_timeout_handle(timeout); + } + + doDispatch(); +} + +void QDBusConnectionPrivate::customEvent(QEvent *e) +{ + Q_ASSERT(e->type() == QEvent::User); + + QDBusConnectionCallbackEvent *ev = static_cast<QDBusConnectionCallbackEvent *>(e); + QDBusLockerBase::reportThreadAction(int(AddTimeoutAction) + int(ev->subtype), + QDBusLockerBase::BeforeDeliver, this); + switch (ev->subtype) + { + case QDBusConnectionCallbackEvent::AddTimeout: { + QDBusWatchAndTimeoutLocker locker(RealAddTimeoutAction, this); + while (!timeoutsPendingAdd.isEmpty()) { + QPair<DBusTimeout *, int> entry = timeoutsPendingAdd.takeFirst(); + qDBusRealAddTimeout(this, entry.first, entry.second); + } + break; + } + + case QDBusConnectionCallbackEvent::KillTimer: + killTimer(ev->timerId); + break; + + case QDBusConnectionCallbackEvent::AddWatch: + qDBusRealAddWatch(this, ev->watch, ev->extra, ev->fd); + break; + + case QDBusConnectionCallbackEvent::ToggleWatch: + qDBusRealToggleWatch(this, ev->watch, ev->fd); + break; + } + QDBusLockerBase::reportThreadAction(int(AddTimeoutAction) + int(ev->subtype), + QDBusLockerBase::AfterDeliver, this); +} + +void QDBusConnectionPrivate::doDispatch() +{ + QDBusDispatchLocker locker(DoDispatchAction, this); + if (mode == ClientMode || mode == PeerMode) + while (q_dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS) ; +} + +void QDBusConnectionPrivate::socketRead(int fd) +{ + QVarLengthArray<DBusWatch *, 2> pendingWatches; + + { + QDBusWatchAndTimeoutLocker locker(SocketReadAction, this); + WatcherHash::ConstIterator it = watchers.constFind(fd); + while (it != watchers.constEnd() && it.key() == fd) { + if (it->watch && it->read && it->read->isEnabled()) + pendingWatches.append(it.value().watch); + ++it; + } + } + + for (int i = 0; i < pendingWatches.size(); ++i) + if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_READABLE)) + qDebug("OUT OF MEM"); + doDispatch(); +} + +void QDBusConnectionPrivate::socketWrite(int fd) +{ + QVarLengthArray<DBusWatch *, 2> pendingWatches; + + { + QDBusWatchAndTimeoutLocker locker(SocketWriteAction, this); + WatcherHash::ConstIterator it = watchers.constFind(fd); + while (it != watchers.constEnd() && it.key() == fd) { + if (it->watch && it->write && it->write->isEnabled()) + pendingWatches.append(it.value().watch); + ++it; + } + } + + for (int i = 0; i < pendingWatches.size(); ++i) + if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_WRITABLE)) + qDebug("OUT OF MEM"); +} + +void QDBusConnectionPrivate::objectDestroyed(QObject *obj) +{ + QDBusWriteLocker locker(ObjectDestroyedAction, this); + huntAndDestroy(obj, rootNode); + + SignalHookHash::iterator sit = signalHooks.begin(); + while (sit != signalHooks.end()) { + if (static_cast<QObject *>(sit.value().obj) == obj) + sit = disconnectSignal(sit); + else + ++sit; + } + + obj->disconnect(this); +} + +void QDBusConnectionPrivate::relaySignal(QObject *obj, const QMetaObject *mo, int signalId, + const QVariantList &args) +{ + QString interface = qDBusInterfaceFromMetaObject(mo); + + QMetaMethod mm = mo->method(signalId); + QByteArray memberName = mm.signature(); + memberName.truncate(memberName.indexOf('(')); + + // check if it's scriptable + bool isScriptable = mm.attributes() & QMetaMethod::Scriptable; + bool isAdaptor = false; + for ( ; mo; mo = mo->superClass()) + if (mo == &QDBusAbstractAdaptor::staticMetaObject) { + isAdaptor = true; + break; + } + + QDBusReadLocker locker(RelaySignalAction, this); + QDBusMessage message = QDBusMessage::createSignal(QLatin1String("/"), interface, + QLatin1String(memberName)); + QDBusMessagePrivate::setParametersValidated(message, true); + message.setArguments(args); + QDBusError error; + DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &error); + if (!msg) { + qWarning("QDBusConnection: Could not emit signal %s.%s: %s", qPrintable(interface), memberName.constData(), + qPrintable(error.message())); + lastError = error; + return; + } + + //qDBusDebug() << "Emitting signal" << message; + //qDBusDebug() << "for paths:"; + q_dbus_message_set_no_reply(msg, true); // the reply would not be delivered to anything + huntAndEmit(connection, msg, obj, rootNode, isScriptable, isAdaptor); + q_dbus_message_unref(msg); +} + +void QDBusConnectionPrivate::serviceOwnerChangedNoLock(const QString &name, + const QString &oldOwner, const QString &newOwner) +{ + Q_UNUSED(oldOwner); +// QDBusWriteLocker locker(UpdateSignalHookOwnerAction, this); + WatchedServicesHash::Iterator it = watchedServices.find(name); + if (it == watchedServices.end()) + return; + if (oldOwner != it->owner) + qWarning("QDBusConnection: name '%s' had owner '%s' but we thought it was '%s'", + qPrintable(name), qPrintable(oldOwner), qPrintable(it->owner)); + + qDBusDebug() << this << "Updating name" << name << "from" << oldOwner << "to" << newOwner; + it->owner = newOwner; +} + +int QDBusConnectionPrivate::findSlot(QObject* obj, const QByteArray &normalizedName, + QList<int> ¶ms) +{ + int midx = obj->metaObject()->indexOfMethod(normalizedName); + if (midx == -1) + return -1; + + int inputCount = qDBusParametersForMethod(obj->metaObject()->method(midx), params); + if ( inputCount == -1 || inputCount + 1 != params.count() ) + return -1; // failed to parse or invalid arguments or output arguments + + return midx; +} + +bool QDBusConnectionPrivate::prepareHook(QDBusConnectionPrivate::SignalHook &hook, QString &key, + const QString &service, + const QString &path, const QString &interface, const QString &name, + const QStringList &argMatch, + QObject *receiver, const char *signal, int minMIdx, + bool buildSignature) +{ + QByteArray normalizedName = signal + 1; + hook.midx = findSlot(receiver, signal + 1, hook.params); + if (hook.midx == -1) { + normalizedName = QMetaObject::normalizedSignature(signal + 1); + hook.midx = findSlot(receiver, normalizedName, hook.params); + } + if (hook.midx < minMIdx) { + if (hook.midx == -1) + {} + return false; + } + + hook.service = service; + hook.path = path; + hook.obj = receiver; + hook.argumentMatch = argMatch; + + // build the D-Bus signal name and signature + // This should not happen for QDBusConnection::connect, use buildSignature here, since + // QDBusConnection::connect passes false and everything else uses true + QString mname = name; + if (buildSignature && mname.isNull()) { + normalizedName.truncate(normalizedName.indexOf('(')); + mname = QString::fromUtf8(normalizedName); + } + key = mname; + key.reserve(interface.length() + 1 + mname.length()); + key += QLatin1Char(':'); + key += interface; + + if (buildSignature) { + hook.signature.clear(); + for (int i = 1; i < hook.params.count(); ++i) + if (hook.params.at(i) != QDBusMetaTypeId::message) + hook.signature += QLatin1String( QDBusMetaType::typeToSignature( hook.params.at(i) ) ); + } + + hook.matchRule = buildMatchRule(service, path, interface, mname, argMatch, hook.signature); + return true; // connect to this signal +} + +void QDBusConnectionPrivate::sendError(const QDBusMessage &msg, QDBusError::ErrorType code) +{ + if (code == QDBusError::UnknownMethod) { + QString interfaceMsg; + if (msg.interface().isEmpty()) + interfaceMsg = QLatin1String("any interface"); + else + interfaceMsg = QString::fromLatin1("interface '%1'").arg(msg.interface()); + + send(msg.createErrorReply(code, + QString::fromLatin1("No such method '%1' in %2 at object path '%3' " + "(signature '%4')") + .arg(msg.member(), interfaceMsg, msg.path(), msg.signature()))); + } else if (code == QDBusError::UnknownInterface) { + send(msg.createErrorReply(QDBusError::UnknownInterface, + QString::fromLatin1("No such interface '%1' at object path '%2'") + .arg(msg.interface(), msg.path()))); + } else if (code == QDBusError::UnknownObject) { + send(msg.createErrorReply(QDBusError::UnknownObject, + QString::fromLatin1("No such object path '%1'").arg(msg.path()))); + } +} + +bool QDBusConnectionPrivate::activateInternalFilters(const ObjectTreeNode &node, + const QDBusMessage &msg) +{ + // object may be null + const QString interface = msg.interface(); + + if (interface.isEmpty() || interface == QLatin1String(DBUS_INTERFACE_INTROSPECTABLE)) { + if (msg.member() == QLatin1String("Introspect") && msg.signature().isEmpty()) { + //qDebug() << "QDBusConnectionPrivate::activateInternalFilters introspect" << msg.d_ptr->msg; + QDBusMessage reply = msg.createReply(qDBusIntrospectObject(node)); + send(reply); + return true; + } + + if (!interface.isEmpty()) { + sendError(msg, QDBusError::UnknownMethod); + return true; + } + } + + if (node.obj && (interface.isEmpty() || + interface == QLatin1String(DBUS_INTERFACE_PROPERTIES))) { + //qDebug() << "QDBusConnectionPrivate::activateInternalFilters properties" << msg.d_ptr->msg; + if (msg.member() == QLatin1String("Get") && msg.signature() == QLatin1String("ss")) { + QDBusMessage reply = qDBusPropertyGet(node, msg); + send(reply); + return true; + } else if (msg.member() == QLatin1String("Set") && msg.signature() == QLatin1String("ssv")) { + QDBusMessage reply = qDBusPropertySet(node, msg); + send(reply); + return true; + } else if (msg.member() == QLatin1String("GetAll") && msg.signature() == QLatin1String("s")) { + QDBusMessage reply = qDBusPropertyGetAll(node, msg); + send(reply); + return true; + } + + if (!interface.isEmpty()) { + sendError(msg, QDBusError::UnknownMethod); + return true; + } + } + + return false; +} + +void QDBusConnectionPrivate::activateObject(ObjectTreeNode &node, const QDBusMessage &msg, + int pathStartPos) +{ + // This is called by QDBusConnectionPrivate::handleObjectCall to place a call to a slot + // on the object. + // + // The call is routed through the adaptor sub-objects if we have any + + // object may be null + + if (pathStartPos != msg.path().length()) { + node.flags &= ~QDBusConnection::ExportAllSignals; + node.obj = findChildObject(&node, msg.path(), pathStartPos); + if (!node.obj) { + sendError(msg, QDBusError::UnknownObject); + return; + } + } + + QDBusAdaptorConnector *connector; + if (node.flags & QDBusConnection::ExportAdaptors && + (connector = qDBusFindAdaptorConnector(node.obj))) { + int newflags = node.flags | QDBusConnection::ExportAllSlots; + + if (msg.interface().isEmpty()) { + // place the call in all interfaces + // let the first one that handles it to work + QDBusAdaptorConnector::AdaptorMap::ConstIterator it = + connector->adaptors.constBegin(); + QDBusAdaptorConnector::AdaptorMap::ConstIterator end = + connector->adaptors.constEnd(); + + for ( ; it != end; ++it) + if (activateCall(it->adaptor, newflags, msg)) + return; + } else { + // check if we have an interface matching the name that was asked: + QDBusAdaptorConnector::AdaptorMap::ConstIterator it; + it = qLowerBound(connector->adaptors.constBegin(), connector->adaptors.constEnd(), + msg.interface()); + if (it != connector->adaptors.constEnd() && msg.interface() == QLatin1String(it->interface)) { + if (!activateCall(it->adaptor, newflags, msg)) + sendError(msg, QDBusError::UnknownMethod); + return; + } + } + } + + // no adaptors matched or were exported + // try our standard filters + if (activateInternalFilters(node, msg)) + return; // internal filters have already run or an error has been sent + + // try the object itself: + if (node.flags & (QDBusConnection::ExportScriptableSlots|QDBusConnection::ExportNonScriptableSlots) || + node.flags & (QDBusConnection::ExportScriptableInvokables|QDBusConnection::ExportNonScriptableInvokables)) { + bool interfaceFound = true; + if (!msg.interface().isEmpty()) + interfaceFound = qDBusInterfaceInObject(node.obj, msg.interface()); + + if (interfaceFound) { + if (!activateCall(node.obj, node.flags, msg)) + sendError(msg, QDBusError::UnknownMethod); + return; + } + } + + // nothing matched, send an error code + if (msg.interface().isEmpty()) + sendError(msg, QDBusError::UnknownMethod); + else + sendError(msg, QDBusError::UnknownInterface); +} + +void QDBusConnectionPrivate::handleObjectCall(const QDBusMessage &msg) +{ + // if the msg is external, we were called from inside doDispatch + // that means the dispatchLock mutex is locked + // must not call out to user code in that case + // + // however, if the message is internal, handleMessage was called + // directly and no lock is in place. We can therefore call out to + // user code, if necessary + ObjectTreeNode result; + int usedLength; + QThread *objThread = 0; + QSemaphore sem; + bool semWait; + + { + QDBusReadLocker locker(HandleObjectCallAction, this); + if (!findObject(&rootNode, msg.path(), usedLength, result)) { + // qDebug("Call failed: no object found at %s", qPrintable(msg.path())); + sendError(msg, QDBusError::UnknownObject); + return; + } + + if (!result.obj) { + // no object -> no threading issues + // it's either going to be an error, or an internal filter + activateObject(result, msg, usedLength); + return; + } + + objThread = result.obj->thread(); + if (!objThread) { + send(msg.createErrorReply(QDBusError::InternalError, + QString::fromLatin1("Object '%1' (at path '%2')" + " has no thread. Cannot deliver message.") + .arg(result.obj->objectName(), msg.path()))); + return; + } + + if (!QDBusMessagePrivate::isLocal(msg)) { + // external incoming message + // post it and forget + postEventToThread(HandleObjectCallPostEventAction, result.obj, + new QDBusActivateObjectEvent(QDBusConnection(this), this, result, + usedLength, msg)); + return; + } else if (objThread != QThread::currentThread()) { + // synchronize with other thread + postEventToThread(HandleObjectCallPostEventAction, result.obj, + new QDBusActivateObjectEvent(QDBusConnection(this), this, result, + usedLength, msg, &sem)); + semWait = true; + } else { + semWait = false; + } + } // release the lock + + if (semWait) + SEM_ACQUIRE(HandleObjectCallSemaphoreAction, sem); + else + activateObject(result, msg, usedLength); +} + +QDBusActivateObjectEvent::~QDBusActivateObjectEvent() +{ + if (!handled) { + // we're being destroyed without delivering + // it means the object was deleted between posting and delivering + QDBusConnectionPrivate *that = QDBusConnectionPrivate::d(connection); + that->sendError(message, QDBusError::UnknownObject); + } + + // semaphore releasing happens in ~QMetaCallEvent +} + +void QDBusActivateObjectEvent::placeMetaCall(QObject *) +{ + QDBusConnectionPrivate *that = QDBusConnectionPrivate::d(connection); + + QDBusLockerBase::reportThreadAction(HandleObjectCallPostEventAction, + QDBusLockerBase::BeforeDeliver, that); + that->activateObject(node, message, pathStartPos); + QDBusLockerBase::reportThreadAction(HandleObjectCallPostEventAction, + QDBusLockerBase::AfterDeliver, that); + + handled = true; +} + +void QDBusConnectionPrivate::handleSignal(const QString &key, const QDBusMessage& msg) +{ + SignalHookHash::const_iterator it = signalHooks.find(key); + SignalHookHash::const_iterator end = signalHooks.constEnd(); + //qDebug("looking for: %s", path.toLocal8Bit().constData()); + //qDBusDebug() << signalHooks.keys(); + for ( ; it != end && it.key() == key; ++it) { + const SignalHook &hook = it.value(); + if (!hook.service.isEmpty()) { + const QString owner = + shouldWatchService(hook.service) ? + watchedServices.value(hook.service).owner : + hook.service; + if (owner != msg.service()) + continue; + } + if (!hook.path.isEmpty() && hook.path != msg.path()) + continue; + if (!hook.signature.isEmpty() && hook.signature != msg.signature()) + continue; + if (hook.signature.isEmpty() && !hook.signature.isNull() && !msg.signature().isEmpty()) + continue; + if (!hook.argumentMatch.isEmpty()) { + const QVariantList arguments = msg.arguments(); + if (hook.argumentMatch.size() > arguments.size()) + continue; + + bool matched = true; + for (int i = 0; i < hook.argumentMatch.size(); ++i) { + const QString ¶m = hook.argumentMatch.at(i); + if (param.isNull()) + continue; // don't try to match against this + if (param == arguments.at(i).toString()) + continue; // matched + matched = false; + break; + } + if (!matched) + continue; + } + + activateSignal(hook, msg); + } +} + +void QDBusConnectionPrivate::handleSignal(const QDBusMessage& msg) +{ + // We call handlesignal(QString, QDBusMessage) three times: + // one with member:interface + // one with member: + // one with :interface + // This allows us to match signals with wildcards on member or interface + // (but not both) + + QString key = msg.member(); + key.reserve(key.length() + 1 + msg.interface().length()); + key += QLatin1Char(':'); + key += msg.interface(); + + QDBusReadLocker locker(HandleSignalAction, this); + handleSignal(key, msg); // one try + + key.truncate(msg.member().length() + 1); // keep the ':' + handleSignal(key, msg); // second try + + key = QLatin1Char(':'); + key += msg.interface(); + handleSignal(key, msg); // third try +} + +static dbus_int32_t server_slot = -1; + +void QDBusConnectionPrivate::setServer(DBusServer *s, const QDBusErrorInternal &error) +{ + if (!s) { + handleError(error); + return; + } + + server = s; + mode = ServerMode; + + dbus_bool_t data_allocated = q_dbus_server_allocate_data_slot(&server_slot); + if (data_allocated && server_slot < 0) + return; + + dbus_bool_t watch_functions_set = q_dbus_server_set_watch_functions(server, + qDBusAddWatch, + qDBusRemoveWatch, + qDBusToggleWatch, + this, 0); + //qDebug() << "watch_functions_set" << watch_functions_set; + Q_UNUSED(watch_functions_set); + + dbus_bool_t time_functions_set = q_dbus_server_set_timeout_functions(server, + qDBusAddTimeout, + qDBusRemoveTimeout, + qDBusToggleTimeout, + this, 0); + //qDebug() << "time_functions_set" << time_functions_set; + Q_UNUSED(time_functions_set); + + q_dbus_server_set_new_connection_function(server, qDBusNewConnection, this, 0); + + dbus_bool_t data_set = q_dbus_server_set_data(server, server_slot, this, 0); + //qDebug() << "data_set" << data_set; + Q_UNUSED(data_set); +} + +void QDBusConnectionPrivate::setPeer(DBusConnection *c, const QDBusErrorInternal &error) +{ + if (!c) { + handleError(error); + return; + } + + connection = c; + mode = PeerMode; + + q_dbus_connection_set_exit_on_disconnect(connection, false); + q_dbus_connection_set_watch_functions(connection, + qDBusAddWatch, + qDBusRemoveWatch, + qDBusToggleWatch, + this, 0); + q_dbus_connection_set_timeout_functions(connection, + qDBusAddTimeout, + qDBusRemoveTimeout, + qDBusToggleTimeout, + this, 0); + q_dbus_connection_set_dispatch_status_function(connection, qDBusUpdateDispatchStatus, this, 0); + q_dbus_connection_add_filter(connection, + qDBusSignalFilter, + this, 0); + + QMetaObject::invokeMethod(this, "doDispatch", Qt::QueuedConnection); +} + +static QDBusConnection::ConnectionCapabilities connectionCapabilies(DBusConnection *connection) +{ + QDBusConnection::ConnectionCapabilities result = 0; + +#if defined(QT_LINKED_LIBDBUS) && DBUS_VERSION < 0x010400 + // no capabilities are possible +#else +# if !defined(QT_LINKED_LIBDBUS) + // run-time check if the next functions are available + int major, minor, micro; + q_dbus_get_version(&major, &minor, µ); + if (major == 1 && minor < 4) + return result; +# endif + +#ifndef DBUS_TYPE_UNIX_FD +# define DBUS_TYPE_UNIX_FD int('h') +#endif + if (q_dbus_connection_can_send_type(connection, DBUS_TYPE_UNIX_FD)) + result |= QDBusConnection::UnixFileDescriptorPassing; +#endif + + return result; +} + +void QDBusConnectionPrivate::setConnection(DBusConnection *dbc, const QDBusErrorInternal &error) +{ + if (!dbc) { + handleError(error); + return; + } + + connection = dbc; + mode = ClientMode; + + const char *service = q_dbus_bus_get_unique_name(connection); + Q_ASSERT(service); + baseService = QString::fromUtf8(service); + capabilities = connectionCapabilies(connection); + + q_dbus_connection_set_exit_on_disconnect(connection, false); + q_dbus_connection_set_watch_functions(connection, qDBusAddWatch, qDBusRemoveWatch, + qDBusToggleWatch, this, 0); + q_dbus_connection_set_timeout_functions(connection, qDBusAddTimeout, qDBusRemoveTimeout, + qDBusToggleTimeout, this, 0); + q_dbus_connection_set_dispatch_status_function(connection, qDBusUpdateDispatchStatus, this, 0); + q_dbus_connection_add_filter(connection, qDBusSignalFilter, this, 0); + + // Initialize the hooks for the NameAcquired and NameLost signals + // we don't use connectSignal here because we don't need the rules to be sent to the bus + // the bus will always send us these two signals + SignalHook hook; + hook.service = dbusServiceString(); + hook.path.clear(); // no matching + hook.obj = this; + hook.params << QMetaType::Void << QVariant::String; // both functions take a QString as parameter and return void + + hook.midx = staticMetaObject.indexOfSlot("registerServiceNoLock(QString)"); + Q_ASSERT(hook.midx != -1); + signalHooks.insert(QLatin1String("NameAcquired:" DBUS_INTERFACE_DBUS), hook); + + hook.midx = staticMetaObject.indexOfSlot("unregisterServiceNoLock(QString)"); + Q_ASSERT(hook.midx != -1); + signalHooks.insert(QLatin1String("NameLost:" DBUS_INTERFACE_DBUS), hook); + + qDBusDebug() << this << ": connected successfully"; + + // schedule a dispatch: + QMetaObject::invokeMethod(this, "doDispatch", Qt::QueuedConnection); +} + +extern "C"{ +static void qDBusResultReceived(DBusPendingCall *pending, void *user_data) +{ + QDBusPendingCallPrivate *call = reinterpret_cast<QDBusPendingCallPrivate *>(user_data); + Q_ASSERT(call->pending == pending); + Q_UNUSED(pending); + QDBusConnectionPrivate::processFinishedCall(call); +} +} + +void QDBusConnectionPrivate::waitForFinished(QDBusPendingCallPrivate *pcall) +{ + Q_ASSERT(pcall->pending); + Q_ASSERT(!pcall->autoDelete); + //Q_ASSERT(pcall->mutex.isLocked()); // there's no such function + + if (pcall->waitingForFinished) { + // another thread is already waiting + pcall->waitForFinishedCondition.wait(&pcall->mutex); + } else { + pcall->waitingForFinished = true; + pcall->mutex.unlock(); + + { + QDBusDispatchLocker locker(PendingCallBlockAction, this); + q_dbus_pending_call_block(pcall->pending); + // QDBusConnectionPrivate::processFinishedCall() is called automatically + } + pcall->mutex.lock(); + } +} + +void QDBusConnectionPrivate::processFinishedCall(QDBusPendingCallPrivate *call) +{ + QDBusConnectionPrivate *connection = const_cast<QDBusConnectionPrivate *>(call->connection); + + QMutexLocker locker(&call->mutex); + + QDBusMessage &msg = call->replyMessage; + if (call->pending) { + // decode the message + DBusMessage *reply = q_dbus_pending_call_steal_reply(call->pending); + msg = QDBusMessagePrivate::fromDBusMessage(reply, connection->capabilities); + q_dbus_message_unref(reply); + } + qDBusDebug() << connection << "got message reply (async):" << msg; + + // Check if the reply has the expected signature + call->checkReceivedSignature(); + + if (!call->receiver.isNull() && call->methodIdx != -1 && msg.type() == QDBusMessage::ReplyMessage) { + // Deliver the return values of a remote function call. + // + // There is only one connection and it is specified by idx + // The slot must have the same parameter types that the message does + // The slot may have less parameters than the message + // The slot may optionally have one final parameter that is QDBusMessage + // The slot receives read-only copies of the message (i.e., pass by value or by const-ref) + + QDBusCallDeliveryEvent *e = prepareReply(connection, call->receiver, call->methodIdx, + call->metaTypes, msg); + if (e) + connection->postEventToThread(MessageResultReceivedAction, call->receiver, e); + else + qDBusDebug() << "Deliver failed!"; + } + + if (call->pending) + q_dbus_pending_call_unref(call->pending); + call->pending = 0; + + locker.unlock(); + + // Are there any watchers? + if (call->watcherHelper) + call->watcherHelper->emitSignals(msg, call->sentMessage); + + if (msg.type() == QDBusMessage::ErrorMessage) + emit connection->callWithCallbackFailed(QDBusError(msg), call->sentMessage); + + if (call->autoDelete) { + Q_ASSERT(!call->waitingForFinished); // can't wait on a call with autoDelete! + delete call; + } +} + +int QDBusConnectionPrivate::send(const QDBusMessage& message) +{ + if (QDBusMessagePrivate::isLocal(message)) + return -1; // don't send; the reply will be retrieved by the caller + // through the d_ptr->localReply link + + QDBusError error; + DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &error); + if (!msg) { + if (message.type() == QDBusMessage::MethodCallMessage) + qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s", + qPrintable(message.service()), qPrintable(message.path()), + qPrintable(message.interface()), qPrintable(message.member()), + qPrintable(error.message())); + else if (message.type() == QDBusMessage::SignalMessage) + qWarning("QDBusConnection: error: could not send signal path \"%s\" interface \"%s\" member \"%s\": %s", + qPrintable(message.path()), qPrintable(message.interface()), + qPrintable(message.member()), + qPrintable(error.message())); + else + qWarning("QDBusConnection: error: could not send %s message to service \"%s\": %s", + message.type() == QDBusMessage::ReplyMessage ? "reply" : + message.type() == QDBusMessage::ErrorMessage ? "error" : + "invalid", qPrintable(message.service()), + qPrintable(error.message())); + lastError = error; + return 0; + } + + q_dbus_message_set_no_reply(msg, true); // the reply would not be delivered to anything + + qDBusDebug() << this << "sending message (no reply):" << message; + checkThread(); + bool isOk = q_dbus_connection_send(connection, msg, 0); + int serial = 0; + if (isOk) + serial = q_dbus_message_get_serial(msg); + + q_dbus_message_unref(msg); + return serial; +} + +QDBusMessage QDBusConnectionPrivate::sendWithReply(const QDBusMessage &message, + int sendMode, int timeout) +{ + checkThread(); + if ((sendMode == QDBus::BlockWithGui || sendMode == QDBus::Block) + && isServiceRegisteredByThread(message.service())) + // special case for synchronous local calls + return sendWithReplyLocal(message); + + if (!QCoreApplication::instance() || sendMode == QDBus::Block) { + QDBusError err; + DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &err); + if (!msg) { + qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s", + qPrintable(message.service()), qPrintable(message.path()), + qPrintable(message.interface()), qPrintable(message.member()), + qPrintable(err.message())); + lastError = err; + return QDBusMessage::createError(err); + } + + qDBusDebug() << this << "sending message (blocking):" << message; + QDBusErrorInternal error; + DBusMessage *reply = q_dbus_connection_send_with_reply_and_block(connection, msg, timeout, error); + + q_dbus_message_unref(msg); + + if (!!error) { + lastError = err = error; + return QDBusMessage::createError(err); + } + + QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(reply, capabilities); + q_dbus_message_unref(reply); + qDBusDebug() << this << "got message reply (blocking):" << amsg; + + return amsg; + } else { // use the event loop + QDBusPendingCallPrivate *pcall = sendWithReplyAsync(message, timeout); + Q_ASSERT(pcall); + + if (pcall->replyMessage.type() == QDBusMessage::InvalidMessage) { + pcall->watcherHelper = new QDBusPendingCallWatcherHelper; + QEventLoop loop; + loop.connect(pcall->watcherHelper, SIGNAL(reply(QDBusMessage)), SLOT(quit())); + loop.connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), SLOT(quit())); + + // enter the event loop and wait for a reply + loop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents); + } + + QDBusMessage reply = pcall->replyMessage; + lastError = reply; // set or clear error + + delete pcall; + return reply; + } +} + +QDBusMessage QDBusConnectionPrivate::sendWithReplyLocal(const QDBusMessage &message) +{ + qDBusDebug() << this << "sending message via local-loop:" << message; + + QDBusMessage localCallMsg = QDBusMessagePrivate::makeLocal(*this, message); + bool handled = handleMessage(localCallMsg); + + if (!handled) { + QString interface = message.interface(); + if (interface.isEmpty()) + interface = QLatin1String("<no-interface>"); + return QDBusMessage::createError(QDBusError::InternalError, + QString::fromLatin1("Internal error trying to call %1.%2 at %3 (signature '%4'") + .arg(interface, message.member(), + message.path(), message.signature())); + } + + // if the message was handled, there might be a reply + QDBusMessage localReplyMsg = QDBusMessagePrivate::makeLocalReply(*this, localCallMsg); + if (localReplyMsg.type() == QDBusMessage::InvalidMessage) { + qWarning("QDBusConnection: cannot call local method '%s' at object %s (with signature '%s') " + "on blocking mode", qPrintable(message.member()), qPrintable(message.path()), + qPrintable(message.signature())); + return QDBusMessage::createError( + QDBusError(QDBusError::InternalError, + QLatin1String("local-loop message cannot have delayed replies"))); + } + + // there is a reply + qDBusDebug() << this << "got message via local-loop:" << localReplyMsg; + return localReplyMsg; +} + +QDBusPendingCallPrivate *QDBusConnectionPrivate::sendWithReplyAsync(const QDBusMessage &message, + int timeout) +{ + if (isServiceRegisteredByThread(message.service())) { + // special case for local calls + QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate(message, this); + pcall->replyMessage = sendWithReplyLocal(message); + + return pcall; + } + + checkThread(); + QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate(message, this); + pcall->ref = 0; + + QDBusError error; + DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, capabilities, &error); + if (!msg) { + qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s", + qPrintable(message.service()), qPrintable(message.path()), + qPrintable(message.interface()), qPrintable(message.member()), + qPrintable(error.message())); + pcall->replyMessage = QDBusMessage::createError(error); + lastError = error; + return pcall; + } + + qDBusDebug() << this << "sending message (async):" << message; + DBusPendingCall *pending = 0; + + QDBusDispatchLocker locker(SendWithReplyAsyncAction, this); + if (q_dbus_connection_send_with_reply(connection, msg, &pending, timeout)) { + if (pending) { + q_dbus_message_unref(msg); + + pcall->pending = pending; + q_dbus_pending_call_set_notify(pending, qDBusResultReceived, pcall, 0); + + return pcall; + } else { + // we're probably disconnected at this point + lastError = error = QDBusError(QDBusError::Disconnected, QLatin1String("Not connected to server")); + } + } else { + lastError = error = QDBusError(QDBusError::NoMemory, QLatin1String("Out of memory")); + } + + q_dbus_message_unref(msg); + pcall->replyMessage = QDBusMessage::createError(error); + return pcall; +} + +int QDBusConnectionPrivate::sendWithReplyAsync(const QDBusMessage &message, QObject *receiver, + const char *returnMethod, const char *errorMethod, + int timeout) +{ + QDBusPendingCallPrivate *pcall = sendWithReplyAsync(message, timeout); + Q_ASSERT(pcall); + + // has it already finished with success (dispatched locally)? + if (pcall->replyMessage.type() == QDBusMessage::ReplyMessage) { + pcall->setReplyCallback(receiver, returnMethod); + processFinishedCall(pcall); + delete pcall; + return 1; + } + + // either it hasn't finished or it has finished with error + if (errorMethod) { + pcall->watcherHelper = new QDBusPendingCallWatcherHelper; + connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), receiver, errorMethod, + Qt::QueuedConnection); + pcall->watcherHelper->moveToThread(thread()); + } + + // has it already finished and is an error reply message? + if (pcall->replyMessage.type() == QDBusMessage::ErrorMessage) { + processFinishedCall(pcall); + delete pcall; + return 1; + } + + pcall->autoDelete = true; + pcall->ref.ref(); + pcall->setReplyCallback(receiver, returnMethod); + + return 1; +} + +bool QDBusConnectionPrivate::connectSignal(const QString &service, + const QString &path, const QString &interface, const QString &name, + const QStringList &argumentMatch, const QString &signature, + QObject *receiver, const char *slot) +{ + // check the slot + QDBusConnectionPrivate::SignalHook hook; + QString key; + QString name2 = name; + if (name2.isNull()) + name2.detach(); + + hook.signature = signature; + if (!prepareHook(hook, key, service, path, interface, name, argumentMatch, receiver, slot, 0, false)) + return false; // don't connect + + // avoid duplicating: + QDBusConnectionPrivate::SignalHookHash::ConstIterator it = signalHooks.find(key); + QDBusConnectionPrivate::SignalHookHash::ConstIterator end = signalHooks.constEnd(); + for ( ; it != end && it.key() == key; ++it) { + const QDBusConnectionPrivate::SignalHook &entry = it.value(); + if (entry.service == hook.service && + entry.path == hook.path && + entry.signature == hook.signature && + entry.obj == hook.obj && + entry.midx == hook.midx && + entry.argumentMatch == hook.argumentMatch) { + // no need to compare the parameters if it's the same slot + return true; // already there + } + } + + connectSignal(key, hook); + return true; +} + +void QDBusConnectionPrivate::connectSignal(const QString &key, const SignalHook &hook) +{ + signalHooks.insertMulti(key, hook); + connect(hook.obj, SIGNAL(destroyed(QObject*)), SLOT(objectDestroyed(QObject*)), + Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection)); + + MatchRefCountHash::iterator it = matchRefCounts.find(hook.matchRule); + + if (it != matchRefCounts.end()) { // Match already present + it.value() = it.value() + 1; + return; + } + + matchRefCounts.insert(hook.matchRule, 1); + + if (connection) { + if (mode != QDBusConnectionPrivate::PeerMode) { + qDBusDebug("Adding rule: %s", hook.matchRule.constData()); + q_dbus_bus_add_match(connection, hook.matchRule, NULL); + + // Successfully connected the signal + // Do we need to watch for this name? + if (shouldWatchService(hook.service)) { + WatchedServicesHash::mapped_type &data = watchedServices[hook.service]; + if (++data.refcount == 1) { + // we need to watch for this service changing + connectSignal(dbusServiceString(), QString(), dbusInterfaceString(), + QLatin1String("NameOwnerChanged"), QStringList() << hook.service, QString(), + this, SLOT(serviceOwnerChangedNoLock(QString,QString,QString))); + data.owner = getNameOwnerNoCache(hook.service); + qDBusDebug() << this << "Watching service" << hook.service << "for owner changes (current owner:" + << data.owner << ")"; + } + } + } + } +} + +bool QDBusConnectionPrivate::disconnectSignal(const QString &service, + const QString &path, const QString &interface, const QString &name, + const QStringList &argumentMatch, const QString &signature, + QObject *receiver, const char *slot) +{ + // check the slot + QDBusConnectionPrivate::SignalHook hook; + QString key; + QString name2 = name; + if (name2.isNull()) + name2.detach(); + + hook.signature = signature; + if (!prepareHook(hook, key, service, path, interface, name, argumentMatch, receiver, slot, 0, false)) + return false; // don't disconnect + + // avoid duplicating: + QDBusConnectionPrivate::SignalHookHash::Iterator it = signalHooks.find(key); + QDBusConnectionPrivate::SignalHookHash::Iterator end = signalHooks.end(); + for ( ; it != end && it.key() == key; ++it) { + const QDBusConnectionPrivate::SignalHook &entry = it.value(); + if (entry.service == hook.service && + entry.path == hook.path && + entry.signature == hook.signature && + entry.obj == hook.obj && + entry.midx == hook.midx && + entry.argumentMatch == hook.argumentMatch) { + // no need to compare the parameters if it's the same slot + disconnectSignal(it); + return true; // it was there + } + } + + // the slot was not found + return false; +} + +QDBusConnectionPrivate::SignalHookHash::Iterator +QDBusConnectionPrivate::disconnectSignal(SignalHookHash::Iterator &it) +{ + const SignalHook &hook = it.value(); + + bool erase = false; + MatchRefCountHash::iterator i = matchRefCounts.find(hook.matchRule); + if (i == matchRefCounts.end()) { + qWarning("QDBusConnectionPrivate::disconnectSignal: MatchRule not found in matchRefCounts!!"); + } else { + if (i.value() == 1) { + erase = true; + matchRefCounts.erase(i); + } + else { + i.value() = i.value() - 1; + } + } + + // we don't care about errors here + if (connection && erase) { + if (mode != QDBusConnectionPrivate::PeerMode) { + qDBusDebug("Removing rule: %s", hook.matchRule.constData()); + q_dbus_bus_remove_match(connection, hook.matchRule, NULL); + + // Successfully disconnected the signal + // Were we watching for this name? + WatchedServicesHash::Iterator sit = watchedServices.find(hook.service); + if (sit != watchedServices.end()) { + if (--sit.value().refcount == 0) { + watchedServices.erase(sit); + disconnectSignal(dbusServiceString(), QString(), dbusInterfaceString(), + QLatin1String("NameOwnerChanged"), QStringList() << hook.service, QString(), + this, SLOT(_q_serviceOwnerChanged(QString,QString,QString))); + } + } + } + + } + + return signalHooks.erase(it); +} + +void QDBusConnectionPrivate::registerObject(const ObjectTreeNode *node) +{ + connect(node->obj, SIGNAL(destroyed(QObject*)), SLOT(objectDestroyed(QObject*)), + Qt::DirectConnection); + + if (node->flags & (QDBusConnection::ExportAdaptors + | QDBusConnection::ExportScriptableSignals + | QDBusConnection::ExportNonScriptableSignals)) { + QDBusAdaptorConnector *connector = qDBusCreateAdaptorConnector(node->obj); + + if (node->flags & (QDBusConnection::ExportScriptableSignals + | QDBusConnection::ExportNonScriptableSignals)) { + connector->disconnectAllSignals(node->obj); + connector->connectAllSignals(node->obj); + } + + // disconnect and reconnect to avoid duplicates + connector->disconnect(SIGNAL(relaySignal(QObject*,const QMetaObject*,int,QVariantList)), + this, SLOT(relaySignal(QObject*,const QMetaObject*,int,QVariantList))); + connect(connector, SIGNAL(relaySignal(QObject*,const QMetaObject*,int,QVariantList)), + this, SLOT(relaySignal(QObject*,const QMetaObject*,int,QVariantList)), + Qt::DirectConnection); + } +} + +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(), QStringList(), receiver, signal, + QDBusAbstractInterface::staticMetaObject.methodCount(), true)) + return; // don't connect + + // add it to our list: + QDBusWriteLocker locker(ConnectRelayAction, this); + SignalHookHash::ConstIterator it = signalHooks.find(key); + SignalHookHash::ConstIterator end = signalHooks.constEnd(); + for ( ; it != end && it.key() == key; ++it) { + const SignalHook &entry = it.value(); + if (entry.service == hook.service && + entry.path == hook.path && + entry.signature == hook.signature && + entry.obj == hook.obj && + entry.midx == hook.midx) + return; // already there, no need to re-add + } + + connectSignal(key, hook); +} + +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(), QStringList(), receiver, signal, + QDBusAbstractInterface::staticMetaObject.methodCount(), true)) + return; // don't connect + + // remove it from our list: + QDBusWriteLocker locker(DisconnectRelayAction, this); + SignalHookHash::Iterator it = signalHooks.find(key); + SignalHookHash::Iterator end = signalHooks.end(); + for ( ; it != end && it.key() == key; ++it) { + const SignalHook &entry = it.value(); + if (entry.service == hook.service && + entry.path == hook.path && + entry.signature == hook.signature && + entry.obj == hook.obj && + entry.midx == hook.midx) { + // found it + disconnectSignal(it); + return; + } + } + + qWarning("QDBusConnectionPrivate::disconnectRelay called for a signal that was not found"); +} + +QString QDBusConnectionPrivate::getNameOwner(const QString& serviceName) +{ + if (QDBusUtil::isValidUniqueConnectionName(serviceName)) + return serviceName; + if (!connection) + return QString(); + + { + // acquire a read lock for the cache + QReadLocker locker(&lock); + WatchedServicesHash::ConstIterator it = watchedServices.constFind(serviceName); + if (it != watchedServices.constEnd()) + return it->owner; + } + + // not cached + return getNameOwnerNoCache(serviceName); +} + +QString QDBusConnectionPrivate::getNameOwnerNoCache(const QString &serviceName) +{ + QDBusMessage msg = QDBusMessage::createMethodCall(dbusServiceString(), + QLatin1String(DBUS_PATH_DBUS), dbusInterfaceString(), + QLatin1String("GetNameOwner")); + QDBusMessagePrivate::setParametersValidated(msg, true); + msg << serviceName; + QDBusMessage reply = sendWithReply(msg, QDBus::Block); + if (reply.type() == QDBusMessage::ReplyMessage) + return reply.arguments().at(0).toString(); + return QString(); +} + +QDBusMetaObject * +QDBusConnectionPrivate::findMetaObject(const QString &service, const QString &path, + const QString &interface, QDBusError &error) +{ + // service must be a unique connection name + if (!interface.isEmpty()) { + QDBusReadLocker locker(FindMetaObject1Action, this); + QDBusMetaObject *mo = cachedMetaObjects.value(interface, 0); + if (mo) + return mo; + } + + // introspect the target object + QDBusMessage msg = QDBusMessage::createMethodCall(service, path, + QLatin1String(DBUS_INTERFACE_INTROSPECTABLE), + QLatin1String("Introspect")); + QDBusMessagePrivate::setParametersValidated(msg, true); + + QDBusMessage reply = sendWithReply(msg, QDBus::Block); + + // it doesn't exist yet, we have to create it + QDBusWriteLocker locker(FindMetaObject2Action, this); + QDBusMetaObject *mo = 0; + if (!interface.isEmpty()) + mo = cachedMetaObjects.value(interface, 0); + if (mo) + // maybe it got created when we switched from read to write lock + return mo; + + QString xml; + if (reply.type() == QDBusMessage::ReplyMessage) { + if (reply.signature() == QLatin1String("s")) + // fetch the XML description + xml = reply.arguments().at(0).toString(); + } else { + error = reply; + lastError = error; + if (reply.type() != QDBusMessage::ErrorMessage || error.type() != QDBusError::UnknownMethod) + return 0; // error + } + + // release the lock and return + QDBusMetaObject *result = QDBusMetaObject::createMetaObject(interface, xml, + cachedMetaObjects, error); + lastError = error; + return result; +} + +void QDBusConnectionPrivate::registerService(const QString &serviceName) +{ + QDBusWriteLocker locker(RegisterServiceAction, this); + registerServiceNoLock(serviceName); +} + +void QDBusConnectionPrivate::registerServiceNoLock(const QString &serviceName) +{ + serviceNames.append(serviceName); +} + +void QDBusConnectionPrivate::unregisterService(const QString &serviceName) +{ + QDBusWriteLocker locker(UnregisterServiceAction, this); + unregisterServiceNoLock(serviceName); +} + +void QDBusConnectionPrivate::unregisterServiceNoLock(const QString &serviceName) +{ + serviceNames.removeAll(serviceName); +} + +bool QDBusConnectionPrivate::isServiceRegisteredByThread(const QString &serviceName) const +{ + if (!serviceName.isEmpty() && serviceName == baseService) + return true; + QStringList copy = serviceNames; + return copy.contains(serviceName); +} + +void QDBusConnectionPrivate::postEventToThread(int action, QObject *object, QEvent *ev) +{ + QDBusLockerBase::reportThreadAction(action, QDBusLockerBase::BeforePost, this); + QCoreApplication::postEvent(object, ev); + QDBusLockerBase::reportThreadAction(action, QDBusLockerBase::AfterPost, this); +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusintegrator_p.h b/src/dbus/qdbusintegrator_p.h new file mode 100644 index 0000000000..59255f9291 --- /dev/null +++ b/src/dbus/qdbusintegrator_p.h @@ -0,0 +1,162 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// 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 QDBUSINTEGRATOR_P_H +#define QDBUSINTEGRATOR_P_H + +#include "qdbus_symbols_p.h" + +#include "qcoreevent.h" +#include "qeventloop.h" +#include "qhash.h" +#include "qobject.h" +#include "private/qobject_p.h" +#include "qlist.h" +#include "qpointer.h" +#include "qsemaphore.h" + +#include "qdbusconnection.h" +#include "qdbusmessage.h" +#include "qdbusconnection_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +class QDBusConnectionPrivate; + +// Really private structs used by qdbusintegrator.cpp +// Things that aren't used by any other file + +struct QDBusSlotCache +{ + struct Data + { + int flags; + int slotIdx; + QList<int> metaTypes; + }; + typedef QMultiHash<QString, Data> Hash; + Hash hash; +}; + +class QDBusCallDeliveryEvent: public QMetaCallEvent +{ +public: + QDBusCallDeliveryEvent(const QDBusConnection &c, int id, QObject *sender, + const QDBusMessage &msg, const QList<int> &types, int f = 0) + : QMetaCallEvent(0, id, 0, sender, -1), connection(c), message(msg), metaTypes(types), flags(f) + { } + + void placeMetaCall(QObject *object) + { + QDBusConnectionPrivate::d(connection)->deliverCall(object, flags, message, metaTypes, id()); + } + +private: + QDBusConnection connection; // just for refcounting + QDBusMessage message; + QList<int> metaTypes; + int flags; +}; + +class QDBusActivateObjectEvent: public QMetaCallEvent +{ +public: + QDBusActivateObjectEvent(const QDBusConnection &c, QObject *sender, + const QDBusConnectionPrivate::ObjectTreeNode &n, + int p, const QDBusMessage &m, QSemaphore *s = 0) + : QMetaCallEvent(0, -1, 0, sender, -1, 0, 0, 0, s), connection(c), node(n), + pathStartPos(p), message(m), handled(false) + { } + ~QDBusActivateObjectEvent(); + + void placeMetaCall(QObject *); + +private: + QDBusConnection connection; // just for refcounting + QDBusConnectionPrivate::ObjectTreeNode node; + int pathStartPos; + QDBusMessage message; + bool handled; +}; + +class QDBusConnectionCallbackEvent : public QEvent +{ +public: + QDBusConnectionCallbackEvent() + : QEvent(User), subtype(Subtype(0)) + { } + + DBusWatch *watch; + union { + int timerId; + int fd; + }; + int extra; + + enum Subtype { + AddTimeout = 0, + KillTimer, + AddWatch, + //RemoveWatch, + ToggleWatch + } subtype; +}; + +QT_END_NAMESPACE + +Q_DECLARE_METATYPE(QDBusSlotCache) + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusinterface.cpp b/src/dbus/qdbusinterface.cpp new file mode 100644 index 0000000000..e748b8fa7f --- /dev/null +++ b/src/dbus/qdbusinterface.cpp @@ -0,0 +1,328 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusinterface.h" + +#include "qdbus_symbols_p.h" +#include <QtCore/qpointer.h> +#include <QtCore/qstringlist.h> + +#include "qdbusmetatype_p.h" +#include "qdbusinterface_p.h" +#include "qdbusconnection_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +static void copyArgument(void *to, int id, const QVariant &arg) +{ + if (id == arg.userType()) { + switch (id) { + case QVariant::Bool: + *reinterpret_cast<bool *>(to) = arg.toBool(); + return; + + case QMetaType::UChar: + *reinterpret_cast<uchar *>(to) = arg.value<uchar>(); + return; + + case QMetaType::Short: + *reinterpret_cast<short *>(to) = arg.value<short>(); + return; + + case QMetaType::UShort: + *reinterpret_cast<ushort *>(to) = arg.value<ushort>(); + return; + + case QVariant::Int: + *reinterpret_cast<int *>(to) = arg.toInt(); + return; + + case QVariant::UInt: + *reinterpret_cast<uint *>(to) = arg.toUInt(); + return; + + case QVariant::LongLong: + *reinterpret_cast<qlonglong *>(to) = arg.toLongLong(); + return; + + case QVariant::ULongLong: + *reinterpret_cast<qulonglong *>(to) = arg.toULongLong(); + return; + + case QVariant::Double: + *reinterpret_cast<double *>(to) = arg.toDouble(); + return; + + case QVariant::String: + *reinterpret_cast<QString *>(to) = arg.toString(); + return; + + case QVariant::ByteArray: + *reinterpret_cast<QByteArray *>(to) = arg.toByteArray(); + return; + + case QVariant::StringList: + *reinterpret_cast<QStringList *>(to) = arg.toStringList(); + return; + } + + if (id == QDBusMetaTypeId::variant) { + *reinterpret_cast<QDBusVariant *>(to) = arg.value<QDBusVariant>(); + return; + } else if (id == QDBusMetaTypeId::objectpath) { + *reinterpret_cast<QDBusObjectPath *>(to) = arg.value<QDBusObjectPath>(); + return; + } else if (id == QDBusMetaTypeId::signature) { + *reinterpret_cast<QDBusSignature *>(to) = arg.value<QDBusSignature>(); + return; + } + + // those above are the only types possible + // the demarshaller code doesn't demarshall anything else + qFatal("Found a decoded basic type in a D-Bus reply that shouldn't be there"); + } + + // if we got here, it's either an un-dermarshalled type or a mismatch + if (arg.userType() != QDBusMetaTypeId::argument) { + // it's a mismatch + //qWarning? + return; + } + + // is this type registered? + const char *userSignature = QDBusMetaType::typeToSignature(id); + if (!userSignature || !*userSignature) { + // type not registered + //qWarning? + return; + } + + // is it the same signature? + QDBusArgument dbarg = arg.value<QDBusArgument>(); + if (dbarg.currentSignature() != QLatin1String(userSignature)) { + // not the same signature, another mismatch + //qWarning? + return; + } + + // we can demarshall + QDBusMetaType::demarshall(dbarg, id, to); +} + +QDBusInterfacePrivate::QDBusInterfacePrivate(const QString &serv, const QString &p, + const QString &iface, const QDBusConnection &con) + : QDBusAbstractInterfacePrivate(serv, p, iface, con, true), metaObject(0) +{ + // QDBusAbstractInterfacePrivate's constructor checked the parameters for us + if (connection.isConnected()) { + metaObject = connectionPrivate()->findMetaObject(service, path, interface, lastError); + + if (!metaObject) { + // creation failed, somehow + // most common causes are that the service doesn't exist or doesn't support introspection + // those are not fatal errors, so we continue working + + if (!lastError.isValid()) + lastError = QDBusError(QDBusError::InternalError, QLatin1String("Unknown error")); + } + } +} + +QDBusInterfacePrivate::~QDBusInterfacePrivate() +{ + if (metaObject && !metaObject->cached) + delete metaObject; +} + + +/*! + \class QDBusInterface + \inmodule QtDBus + \since 4.2 + + \brief The QDBusInterface class is a proxy 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. + + The following code snippet demonstrates how to perform a + mathematical operation of \tt{"2 + 2"} in a remote application + called \c com.example.Calculator, accessed via the session bus. + + \snippet doc/src/snippets/code/src_qdbus_qdbusinterface.cpp 0 + + \sa {QtDBus XML compiler (qdbusxml2cpp)} +*/ + +/*! + Creates a dynamic QDBusInterface object associated with the + interface \a interface on object at path \a path on service \a + service, using the given \a connection. If \a interface is an + empty string, the object created will refer to the merging of all + interfaces found in that object. + + \a parent is passed to the base class constructor. + + If the remote service \a service is not present or if an error + occurs trying to obtain the description of the remote interface + \a interface, the object created will not be valid (see + isValid()). +*/ +QDBusInterface::QDBusInterface(const QString &service, const QString &path, const QString &interface, + const QDBusConnection &connection, QObject *parent) + : QDBusAbstractInterface(*new QDBusInterfacePrivate(service, path, interface, connection), + parent) +{ +} + +/*! + 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()->metaObject ? 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.toLatin1() == _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 || !d_func()->metaObject) + 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 || mm.methodType() == QMetaMethod::Method) { + // method call relay from Qt world to D-Bus world + // get D-Bus equivalent signature + QString methodName = QLatin1String(metaObject->dbusNameForMethod(id)); + const int *inputTypes = metaObject->inputTypesForMethod(id); + int inputTypesCount = *inputTypes; + + // we will assume that the input arguments were passed correctly + QVariantList args; + int i = 1; + for ( ; i <= inputTypesCount; ++i) + args << QVariant(inputTypes[i], argv[i]); + + // make the call + QDBusMessage reply = q->callWithArgumentList(QDBus::Block, methodName, args); + + if (reply.type() == QDBusMessage::ReplyMessage) { + // attempt to demarshall the return values + args = reply.arguments(); + QVariantList::ConstIterator it = args.constBegin(); + const int *outputTypes = metaObject->outputTypesForMethod(id); + int outputTypesCount = *outputTypes++; + + if (*mm.typeName()) { + // this method has a return type + if (argv[0] && it != args.constEnd()) + copyArgument(argv[0], *outputTypes++, *it); + + // skip this argument even if we didn't copy it + --outputTypesCount; + ++it; + } + + for (int j = 0; j < outputTypesCount && it != args.constEnd(); ++i, ++j, ++it) { + copyArgument(argv[i], outputTypes[j], *it); + } + } + + // done + lastError = reply; + return -1; + } + } + return id; +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusinterface.h b/src/dbus/qdbusinterface.h new file mode 100644 index 0000000000..a09999723b --- /dev/null +++ b/src/dbus/qdbusinterface.h @@ -0,0 +1,82 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSINTERFACE_H +#define QDBUSINTERFACE_H + +#include <QtDBus/qdbusabstractinterface.h> +#include <QtDBus/qdbusconnection.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusInterfacePrivate; +class Q_DBUS_EXPORT QDBusInterface: public QDBusAbstractInterface +{ + friend class QDBusConnection; +private: + QDBusInterface(QDBusInterfacePrivate *p); + +public: + QDBusInterface(const QString &service, const QString &path, const QString &interface = QString(), + const QDBusConnection &connection = QDBusConnection::sessionBus(), + QObject *parent = 0); + ~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) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusinterface_p.h b/src/dbus/qdbusinterface_p.h new file mode 100644 index 0000000000..cb2e9f0900 --- /dev/null +++ b/src/dbus/qdbusinterface_p.h @@ -0,0 +1,82 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// 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> + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +class QDBusInterfacePrivate: public QDBusAbstractInterfacePrivate +{ +public: + Q_DECLARE_PUBLIC(QDBusInterface) + + QDBusMetaObject *metaObject; + + QDBusInterfacePrivate(const QString &serv, const QString &p, const QString &iface, + const QDBusConnection &con); + ~QDBusInterfacePrivate(); + + int metacall(QMetaObject::Call c, int id, void **argv); +}; + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusinternalfilters.cpp b/src/dbus/qdbusinternalfilters.cpp new file mode 100644 index 0000000000..357fa2b675 --- /dev/null +++ b/src/dbus/qdbusinternalfilters.cpp @@ -0,0 +1,503 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusconnection_p.h" + +#include "qdbus_symbols_p.h" +#include <QtCore/qcoreapplication.h> +#include <QtCore/qmetaobject.h> +#include <QtCore/qstringlist.h> +#include <QtCore/qthread.h> + +#include "qdbusabstractadaptor.h" +#include "qdbusabstractadaptor_p.h" +#include "qdbusconnection.h" +#include "qdbusextratypes.h" +#include "qdbusmessage.h" +#include "qdbusmetatype.h" +#include "qdbusmetatype_p.h" +#include "qdbusmessage_p.h" +#include "qdbusutil_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +// 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" + " <method name=\"GetAll\">\n" + " <arg name=\"interface_name\" type=\"s\" direction=\"in\"/>\n" + " <arg name=\"values\" type=\"a{sv}\" direction=\"out\"/>\n" + " <annotation name=\"com.trolltech.QtDBus.QtTypeName.Out0\" value=\"QVariantMap\"/>\n" + " </method>\n" + " </interface>\n"; + +static QString generateSubObjectXml(QObject *object) +{ + QString retval; + const QObjectList &objs = object->children(); + QObjectList::ConstIterator it = objs.constBegin(); + QObjectList::ConstIterator end = objs.constEnd(); + for ( ; it != end; ++it) { + QString name = (*it)->objectName(); + if (!name.isEmpty() && QDBusUtil::isValidPartOfObjectPath(name)) + retval += QString::fromLatin1(" <node name=\"%1\"/>\n") + .arg(name); + } + return retval; +} + +// declared as extern in qdbusconnection_p.h + +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) { + Q_ASSERT_X(QThread::currentThread() == node.obj->thread(), + "QDBusConnection: internal threading error", + "function called for an object that is in another thread!!"); + + if (node.flags & (QDBusConnection::ExportScriptableContents + | QDBusConnection::ExportNonScriptableContents)) { + // create XML for the object itself + 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(QString::fromLatin1(it->interface), + it->adaptor->metaObject(), + &QDBusAbstractAdaptor::staticMetaObject, + QDBusConnection::ExportScriptableContents + | QDBusConnection::ExportNonScriptableContents); + + QDBusAbstractAdaptorPrivate::saveIntrospectionXml(it->adaptor, ifaceXml); + } + + xml_data += ifaceXml; + } + } + + xml_data += QLatin1String( propertiesInterfaceXml ); + } + + xml_data += QLatin1String( introspectableInterfaceXml ); + + if (node.flags & QDBusConnection::ExportChildObjects) { + xml_data += generateSubObjectXml(node.obj); + } else { + // generate from the object tree + QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it = + node.children.constBegin(); + QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator end = + node.children.constEnd(); + for ( ; it != end; ++it) + if (it->obj || !it->children.isEmpty()) + xml_data += QString::fromLatin1(" <node name=\"%1\"/>\n") + .arg(it->name); + } + + xml_data += QLatin1String("</node>\n"); + return xml_data; +} + +// implement the D-Bus interface org.freedesktop.DBus.Properties + +static inline QDBusMessage interfaceNotFoundError(const QDBusMessage &msg, const QString &interface_name) +{ + return msg.createErrorReply(QDBusError::UnknownInterface, + QString::fromLatin1("Interface %1 was not found in object %2") + .arg(interface_name) + .arg(msg.path())); +} + +static inline QDBusMessage +propertyNotFoundError(const QDBusMessage &msg, const QString &interface_name, const QByteArray &property_name) +{ + return msg.createErrorReply(QDBusError::InvalidArgs, + QString::fromLatin1("Property %1%2%3 was not found in object %4") + .arg(interface_name, + QString::fromLatin1(interface_name.isEmpty() ? "" : "."), + QString::fromLatin1(property_name), + msg.path())); +} + +QDBusMessage qDBusPropertyGet(const QDBusConnectionPrivate::ObjectTreeNode &node, + const QDBusMessage &msg) +{ + Q_ASSERT(msg.arguments().count() == 2); + Q_ASSERT_X(!node.obj || QThread::currentThread() == node.obj->thread(), + "QDBusConnection: internal threading error", + "function called for an object that is in another thread!!"); + + QString interface_name = msg.arguments().at(0).toString(); + QByteArray property_name = msg.arguments().at(1).toString().toUtf8(); + + QDBusAdaptorConnector *connector; + QVariant value; + bool interfaceFound = false; + if (node.flags & QDBusConnection::ExportAdaptors && + (connector = qDBusFindAdaptorConnector(node.obj))) { + + // find the class that implements interface_name or try until we've found the property + // in case of an empty interface + if (interface_name.isEmpty()) { + for (QDBusAdaptorConnector::AdaptorMap::ConstIterator it = connector->adaptors.constBegin(), + end = connector->adaptors.constEnd(); it != end; ++it) { + const QMetaObject *mo = it->adaptor->metaObject(); + int pidx = mo->indexOfProperty(property_name); + if (pidx != -1) { + value = mo->property(pidx).read(it->adaptor); + break; + } + } + } else { + QDBusAdaptorConnector::AdaptorMap::ConstIterator it; + it = qLowerBound(connector->adaptors.constBegin(), connector->adaptors.constEnd(), + interface_name); + if (it != connector->adaptors.constEnd() && interface_name == QLatin1String(it->interface)) { + interfaceFound = true; + value = it->adaptor->property(property_name); + } + } + } + + if (!interfaceFound && !value.isValid() + && node.flags & (QDBusConnection::ExportAllProperties | + QDBusConnection::ExportNonScriptableProperties)) { + // try the object itself + if (!interface_name.isEmpty()) + interfaceFound = qDBusInterfaceInObject(node.obj, interface_name); + + if (interfaceFound) { + int pidx = node.obj->metaObject()->indexOfProperty(property_name); + if (pidx != -1) { + QMetaProperty mp = node.obj->metaObject()->property(pidx); + if ((mp.isScriptable() && (node.flags & QDBusConnection::ExportScriptableProperties)) || + (!mp.isScriptable() && (node.flags & QDBusConnection::ExportNonScriptableProperties))) + value = mp.read(node.obj); + } + } + } + + if (!value.isValid()) { + // the property was not found + if (!interfaceFound) + return interfaceNotFoundError(msg, interface_name); + return propertyNotFoundError(msg, interface_name, property_name); + } + + return msg.createReply(QVariant::fromValue(QDBusVariant(value))); +} + +enum PropertyWriteResult { + PropertyWriteSuccess = 0, + PropertyNotFound, + PropertyTypeMismatch, + PropertyWriteFailed +}; + +static QDBusMessage propertyWriteReply(const QDBusMessage &msg, const QString &interface_name, + const QByteArray &property_name, int status) +{ + switch (status) { + case PropertyNotFound: + return propertyNotFoundError(msg, interface_name, property_name); + case PropertyTypeMismatch: + return msg.createErrorReply(QDBusError::InvalidArgs, + QString::fromLatin1("Invalid arguments for writing to property %1%2%3") + .arg(interface_name, + QString::fromLatin1(interface_name.isEmpty() ? "" : "."), + QString::fromLatin1(property_name))); + case PropertyWriteFailed: + return msg.createErrorReply(QDBusError::InternalError, + QString::fromLatin1("Internal error")); + + case PropertyWriteSuccess: + return msg.createReply(); + } + Q_ASSERT_X(false, "", "Should not be reached"); + return QDBusMessage(); +} + +static int writeProperty(QObject *obj, const QByteArray &property_name, QVariant value, + int propFlags = QDBusConnection::ExportAllProperties) +{ + const QMetaObject *mo = obj->metaObject(); + int pidx = mo->indexOfProperty(property_name); + if (pidx == -1) { + // this object has no property by that name + return PropertyNotFound; + } + + QMetaProperty mp = mo->property(pidx); + + // check if this property is exported + bool isScriptable = mp.isScriptable(); + if (!(propFlags & QDBusConnection::ExportScriptableProperties) && isScriptable) + return PropertyNotFound; + if (!(propFlags & QDBusConnection::ExportNonScriptableProperties) && !isScriptable) + return PropertyNotFound; + + // we found our property + // do we have the right type? + int id = mp.type(); + if (id == QVariant::UserType) { + // dynamic type + id = qDBusNameToTypeId(mp.typeName()); + if (id == -1) { + // type not registered? + qWarning("QDBusConnection: Unable to handle unregistered datatype '%s' for property '%s::%s'", + mp.typeName(), mo->className(), property_name.constData()); + return PropertyWriteFailed; + } + } + + if (id != 0xff && value.userType() == QDBusMetaTypeId::argument) { + // we have to demarshall before writing + void *null = 0; + QVariant other(id, null); + if (!QDBusMetaType::demarshall(qvariant_cast<QDBusArgument>(value), id, other.data())) { + qWarning("QDBusConnection: type `%s' (%d) is not registered with QtDBus. " + "Use qDBusRegisterMetaType to register it", + mp.typeName(), id); + return PropertyWriteFailed; + } + + value = other; + } + + // the property type here should match + return mp.write(obj, value) ? PropertyWriteSuccess : PropertyWriteFailed; +} + +QDBusMessage qDBusPropertySet(const QDBusConnectionPrivate::ObjectTreeNode &node, + const QDBusMessage &msg) +{ + Q_ASSERT(msg.arguments().count() == 3); + Q_ASSERT_X(!node.obj || QThread::currentThread() == node.obj->thread(), + "QDBusConnection: internal threading error", + "function called for an object that is in another thread!!"); + + QString interface_name = msg.arguments().at(0).toString(); + QByteArray property_name = msg.arguments().at(1).toString().toUtf8(); + QVariant value = qvariant_cast<QDBusVariant>(msg.arguments().at(2)).variant(); + + QDBusAdaptorConnector *connector; + if (node.flags & QDBusConnection::ExportAdaptors && + (connector = qDBusFindAdaptorConnector(node.obj))) { + + // find the class that implements interface_name or try until we've found the property + // in case of an empty interface + if (interface_name.isEmpty()) { + for (QDBusAdaptorConnector::AdaptorMap::ConstIterator it = connector->adaptors.constBegin(), + end = connector->adaptors.constEnd(); it != end; ++it) { + int status = writeProperty(it->adaptor, property_name, value); + if (status == PropertyNotFound) + continue; + return propertyWriteReply(msg, interface_name, property_name, status); + } + } else { + QDBusAdaptorConnector::AdaptorMap::ConstIterator it; + it = qLowerBound(connector->adaptors.constBegin(), connector->adaptors.constEnd(), + interface_name); + if (it != connector->adaptors.end() && interface_name == QLatin1String(it->interface)) { + return propertyWriteReply(msg, interface_name, property_name, + writeProperty(it->adaptor, property_name, value)); + } + } + } + + if (node.flags & (QDBusConnection::ExportScriptableProperties | + QDBusConnection::ExportNonScriptableProperties)) { + // try the object itself + bool interfaceFound = true; + if (!interface_name.isEmpty()) + interfaceFound = qDBusInterfaceInObject(node.obj, interface_name); + + if (interfaceFound) { + return propertyWriteReply(msg, interface_name, property_name, + writeProperty(node.obj, property_name, value, node.flags)); + } + } + + // the property was not found + if (!interface_name.isEmpty()) + return interfaceNotFoundError(msg, interface_name); + return propertyWriteReply(msg, interface_name, property_name, PropertyNotFound); +} + +// unite two QVariantMaps, but don't generate duplicate keys +static QVariantMap &operator+=(QVariantMap &lhs, const QVariantMap &rhs) +{ + QVariantMap::ConstIterator it = rhs.constBegin(), + end = rhs.constEnd(); + for ( ; it != end; ++it) + lhs.insert(it.key(), it.value()); + return lhs; +} + +static QVariantMap readAllProperties(QObject *object, int flags) +{ + QVariantMap result; + const QMetaObject *mo = object->metaObject(); + + // QObject has properties, so don't start from 0 + for (int i = QObject::staticMetaObject.propertyCount(); i < mo->propertyCount(); ++i) { + QMetaProperty mp = mo->property(i); + + // is it readable? + if (!mp.isReadable()) + continue; + + // is it a registered property? + int typeId = qDBusNameToTypeId(mp.typeName()); + if (!typeId) + continue; + const char *signature = QDBusMetaType::typeToSignature(typeId); + if (!signature) + continue; + + // is this property visible from the outside? + if ((mp.isScriptable() && flags & QDBusConnection::ExportScriptableProperties) || + (!mp.isScriptable() && flags & QDBusConnection::ExportNonScriptableProperties)) { + // yes, it's visible + QVariant value = mp.read(object); + if (value.isValid()) + result.insert(QString::fromLatin1(mp.name()), value); + } + } + + return result; +} + +QDBusMessage qDBusPropertyGetAll(const QDBusConnectionPrivate::ObjectTreeNode &node, + const QDBusMessage &msg) +{ + Q_ASSERT(msg.arguments().count() == 1); + Q_ASSERT_X(!node.obj || QThread::currentThread() == node.obj->thread(), + "QDBusConnection: internal threading error", + "function called for an object that is in another thread!!"); + + QString interface_name = msg.arguments().at(0).toString(); + + bool interfaceFound = false; + QVariantMap result; + + QDBusAdaptorConnector *connector; + if (node.flags & QDBusConnection::ExportAdaptors && + (connector = qDBusFindAdaptorConnector(node.obj))) { + + if (interface_name.isEmpty()) { + // iterate over all interfaces + for (QDBusAdaptorConnector::AdaptorMap::ConstIterator it = connector->adaptors.constBegin(), + end = connector->adaptors.constEnd(); it != end; ++it) { + result += readAllProperties(it->adaptor, QDBusConnection::ExportAllProperties); + } + } else { + // 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.constEnd() && interface_name == QLatin1String(it->interface)) { + interfaceFound = true; + result = readAllProperties(it->adaptor, QDBusConnection::ExportAllProperties); + } + } + } + + if (node.flags & QDBusConnection::ExportAllProperties && + (!interfaceFound || interface_name.isEmpty())) { + // try the object itself + result += readAllProperties(node.obj, node.flags); + interfaceFound = true; + } + + if (!interfaceFound && !interface_name.isEmpty()) { + // the interface was not found + return interfaceNotFoundError(msg, interface_name); + } + + return msg.createReply(QVariant::fromValue(result)); +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusintrospection.cpp b/src/dbus/qdbusintrospection.cpp new file mode 100644 index 0000000000..a93d4bc089 --- /dev/null +++ b/src/dbus/qdbusintrospection.cpp @@ -0,0 +1,429 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusintrospection_p.h" +#include "qdbusxmlparser_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +/*! + \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). +*/ + +/*! + \variable QDBusIntrospection::Argument::type + The argument type. +*/ + +/*! + \variable 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. +*/ + +/*! + \variable QDBusIntrospection::Method::name + The method's name. +*/ + +/*! + \variable QDBusIntrospection::Method::inputArgs + A list of the method's input arguments. +*/ + +/*! + \variable QDBusIntrospection::Method::outputArgs + A list of the method's output arguments (i.e., return values). +*/ + +/*! + \variable 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. +*/ + +/*! + \variable QDBusIntrospection::Signal::name + The signal's name. +*/ + +/*! + \variable QDBusIntrospection::Signal::outputArgs + A list of the signal's arguments. +*/ + +/*! + \variable 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. +*/ + +/*! + \variable QDBusIntrospection::Property::name + The property's name. +*/ + +/*! + \variable QDBusIntrospection::Property::type + The property's type. +*/ + +/*! + \enum QDBusIntrospection::Property::Access + The possible access rights for a property: + \value Read + \value Write + \value ReadWrite +*/ + +/*! + \variable QDBusIntrospection::Property::access + The property's access rights. +*/ + +/*! + \variable 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. +*/ + +/*! + \variable QDBusIntrospection::Interface::name + The interface's name. +*/ + +/*! + \variable 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. +*/ + +/*! + \variable 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. +*/ + +/*! + \variable 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). +*/ + +/*! + \variable 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. +*/ + +/*! + \variable 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. +*/ + +/*! + \variable QDBusIntrospection::Object::service + The object's service name. + + \sa parseObject(), parseObjectTree() +*/ + +/*! + \variable QDBusIntrospection::Object::path + The object's path on the service. This is an absolute path. + + \sa parseObject(), parseObjectTree() +*/ + +/*! + \variable 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. +*/ + +/*! + \variable QDBusIntrospection::Object::interfaces + The list of interface names in this object. +*/ + +/*! + \variable 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. +*/ + +/*! + \variable QDBusIntrospection::ObjectTree::interfaceData + A map of interfaces and their names. +*/ + +/*! + \variable 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; +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusintrospection_p.h b/src/dbus/qdbusintrospection_p.h new file mode 100644 index 0000000000..caf3bece5e --- /dev/null +++ b/src/dbus/qdbusintrospection_p.h @@ -0,0 +1,180 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSINTROSPECTION_H +#define QDBUSINTROSPECTION_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of the QLibrary class. This header file may change from +// version to version without notice, or even be removed. +// +// We mean it. +// + +#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> + +QT_BEGIN_NAMESPACE + +class Q_DBUS_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(); +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/dbus/qdbusmacros.h b/src/dbus/qdbusmacros.h new file mode 100644 index 0000000000..09fa2a4e6d --- /dev/null +++ b/src/dbus/qdbusmacros.h @@ -0,0 +1,70 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSMACROS_H +#define QDBUSMACROS_H + +#include <QtCore/qglobal.h> +#include <QtCore/qmetatype.h> +#include <QtCore/qvariant.h> + +#ifndef Q_MOC_RUN +# define Q_NOREPLY +#endif + +#ifdef Q_CC_MSVC +#include <QtCore/qlist.h> +#include <QtCore/qset.h> +#include <QtCore/qhash.h> +#include <QtCore/qvector.h> +#endif + +// prevent syncqt complaints +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER +QT_BEGIN_NAMESPACE +QT_MODULE(DBus) +QT_END_NAMESPACE +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusmarshaller.cpp b/src/dbus/qdbusmarshaller.cpp new file mode 100644 index 0000000000..6dec359713 --- /dev/null +++ b/src/dbus/qdbusmarshaller.cpp @@ -0,0 +1,573 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusargument_p.h" +#include "qdbusconnection.h" +#include "qdbusmetatype_p.h" +#include "qdbusutil_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +static void qIterAppend(DBusMessageIter *it, QByteArray *ba, int type, const void *arg) +{ + if (ba) + *ba += char(type); + else + q_dbus_message_iter_append_basic(it, type, arg); +} + +QDBusMarshaller::~QDBusMarshaller() +{ + close(); +} + +inline QString QDBusMarshaller::currentSignature() +{ + if (message) + return QString::fromUtf8(q_dbus_message_get_signature(message)); + return QString(); +} + +inline void QDBusMarshaller::append(uchar arg) +{ + qIterAppend(&iterator, ba, DBUS_TYPE_BYTE, &arg); +} + +inline void QDBusMarshaller::append(bool arg) +{ + dbus_bool_t cast = arg; + qIterAppend(&iterator, ba, DBUS_TYPE_BOOLEAN, &cast); +} + +inline void QDBusMarshaller::append(short arg) +{ + qIterAppend(&iterator, ba, DBUS_TYPE_INT16, &arg); +} + +inline void QDBusMarshaller::append(ushort arg) +{ + qIterAppend(&iterator, ba, DBUS_TYPE_UINT16, &arg); +} + +inline void QDBusMarshaller::append(int arg) +{ + qIterAppend(&iterator, ba, DBUS_TYPE_INT32, &arg); +} + +inline void QDBusMarshaller::append(uint arg) +{ + qIterAppend(&iterator, ba, DBUS_TYPE_UINT32, &arg); +} + +inline void QDBusMarshaller::append(qlonglong arg) +{ + qIterAppend(&iterator, ba, DBUS_TYPE_INT64, &arg); +} + +inline void QDBusMarshaller::append(qulonglong arg) +{ + qIterAppend(&iterator, ba, DBUS_TYPE_UINT64, &arg); +} + +inline void QDBusMarshaller::append(double arg) +{ + qIterAppend(&iterator, ba, DBUS_TYPE_DOUBLE, &arg); +} + +void QDBusMarshaller::append(const QString &arg) +{ + QByteArray data = arg.toUtf8(); + const char *cdata = data.constData(); + qIterAppend(&iterator, ba, DBUS_TYPE_STRING, &cdata); +} + +inline void QDBusMarshaller::append(const QDBusObjectPath &arg) +{ + QByteArray data = arg.path().toUtf8(); + if (!ba && data.isEmpty()) + error(QLatin1String("Invalid object path passed in arguments")); + const char *cdata = data.constData(); + qIterAppend(&iterator, ba, DBUS_TYPE_OBJECT_PATH, &cdata); +} + +inline void QDBusMarshaller::append(const QDBusSignature &arg) +{ + QByteArray data = arg.signature().toUtf8(); + if (!ba && data.isEmpty()) + error(QLatin1String("Invalid signature passed in arguments")); + const char *cdata = data.constData(); + qIterAppend(&iterator, ba, DBUS_TYPE_SIGNATURE, &cdata); +} + +inline void QDBusMarshaller::append(const QDBusUnixFileDescriptor &arg) +{ + int fd = arg.fileDescriptor(); + if (!ba && fd == -1) { + error(QLatin1String("Invalid file descriptor passed in arguments")); + } else { + qIterAppend(&iterator, ba, DBUS_TYPE_UNIX_FD, &fd); + } +} + +inline void QDBusMarshaller::append(const QByteArray &arg) +{ + if (ba) { + *ba += DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING; + return; + } + + const char* cdata = arg.constData(); + DBusMessageIter subiterator; + q_dbus_message_iter_open_container(&iterator, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, + &subiterator); + q_dbus_message_iter_append_fixed_array(&subiterator, DBUS_TYPE_BYTE, &cdata, arg.length()); + q_dbus_message_iter_close_container(&iterator, &subiterator); +} + +inline bool QDBusMarshaller::append(const QDBusVariant &arg) +{ + if (ba) { + *ba += DBUS_TYPE_VARIANT_AS_STRING; + return true; + } + + const QVariant &value = arg.variant(); + QVariant::Type id = QVariant::Type(value.userType()); + if (id == QVariant::Invalid) { + qWarning("QDBusMarshaller: cannot add a null QDBusVariant"); + error(QLatin1String("Variant containing QVariant::Invalid passed in arguments")); + return false; + } + + QByteArray tmpSignature; + const char *signature = 0; + if (int(id) == QDBusMetaTypeId::argument) { + // take the signature from the QDBusArgument object we're marshalling + tmpSignature = + qvariant_cast<QDBusArgument>(value).currentSignature().toLatin1(); + signature = tmpSignature.constData(); + } else { + // take the signatuer from the metatype we're marshalling + signature = QDBusMetaType::typeToSignature(id); + } + if (!signature) { + qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. " + "Use qDBusRegisterMetaType to register it", + QVariant::typeToName( id ), id); + error(QString::fromLatin1("Unregistered type %1 passed in arguments") + .arg(QLatin1String(QVariant::typeToName(id)))); + return false; + } + + QDBusMarshaller sub(capabilities); + open(sub, DBUS_TYPE_VARIANT, signature); + bool isOk = sub.appendVariantInternal(value); + // don't call sub.close(): it auto-closes + + return isOk; +} + +inline void QDBusMarshaller::append(const QStringList &arg) +{ + if (ba) { + *ba += DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING; + return; + } + + QDBusMarshaller sub(capabilities); + open(sub, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING); + QStringList::ConstIterator it = arg.constBegin(); + QStringList::ConstIterator end = arg.constEnd(); + for ( ; it != end; ++it) + sub.append(*it); + // don't call sub.close(): it auto-closes +} + +inline QDBusMarshaller *QDBusMarshaller::beginStructure() +{ + return beginCommon(DBUS_TYPE_STRUCT, 0); +} + +inline QDBusMarshaller *QDBusMarshaller::beginArray(int id) +{ + const char *signature = QDBusMetaType::typeToSignature( QVariant::Type(id) ); + if (!signature) { + qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. " + "Use qDBusRegisterMetaType to register it", + QVariant::typeToName( QVariant::Type(id) ), id); + error(QString::fromLatin1("Unregistered type %1 passed in arguments") + .arg(QLatin1String(QVariant::typeToName(QVariant::Type(id))))); + return this; + } + + return beginCommon(DBUS_TYPE_ARRAY, signature); +} + +inline QDBusMarshaller *QDBusMarshaller::beginMap(int kid, int vid) +{ + const char *ksignature = QDBusMetaType::typeToSignature( QVariant::Type(kid) ); + if (!ksignature) { + qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. " + "Use qDBusRegisterMetaType to register it", + QVariant::typeToName( QVariant::Type(kid) ), kid); + error(QString::fromLatin1("Unregistered type %1 passed in arguments") + .arg(QLatin1String(QVariant::typeToName(QVariant::Type(kid))))); + return this; + } + if (ksignature[1] != 0 || !QDBusUtil::isValidBasicType(*ksignature)) { + qWarning("QDBusMarshaller: type '%s' (%d) cannot be used as the key type in a D-BUS map.", + QVariant::typeToName( QVariant::Type(kid) ), kid); + error(QString::fromLatin1("Type %1 passed in arguments cannot be used as a key in a map") + .arg(QLatin1String(QVariant::typeToName(QVariant::Type(kid))))); + return this; + } + + const char *vsignature = QDBusMetaType::typeToSignature( QVariant::Type(vid) ); + if (!vsignature) { + const char *typeName = QVariant::typeToName(QVariant::Type(vid)); + qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. " + "Use qDBusRegisterMetaType to register it", + typeName, vid); + error(QString::fromLatin1("Unregistered type %1 passed in arguments") + .arg(QLatin1String(typeName))); + return this; + } + + QByteArray signature; + signature = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING; + signature += ksignature; + signature += vsignature; + signature += DBUS_DICT_ENTRY_END_CHAR_AS_STRING; + return beginCommon(DBUS_TYPE_ARRAY, signature); +} + +inline QDBusMarshaller *QDBusMarshaller::beginMapEntry() +{ + return beginCommon(DBUS_TYPE_DICT_ENTRY, 0); +} + +void QDBusMarshaller::open(QDBusMarshaller &sub, int code, const char *signature) +{ + sub.parent = this; + sub.ba = ba; + sub.ok = true; + sub.capabilities = capabilities; + + if (ba) + switch (code) { + case DBUS_TYPE_ARRAY: + *ba += char(code); + *ba += signature; + // fall through + + case DBUS_TYPE_DICT_ENTRY: + sub.closeCode = 0; + break; + + case DBUS_TYPE_STRUCT: + *ba += DBUS_STRUCT_BEGIN_CHAR; + sub.closeCode = DBUS_STRUCT_END_CHAR; + break; + } + else + q_dbus_message_iter_open_container(&iterator, code, signature, &sub.iterator); +} + +QDBusMarshaller *QDBusMarshaller::beginCommon(int code, const char *signature) +{ + QDBusMarshaller *d = new QDBusMarshaller(capabilities); + open(*d, code, signature); + return d; +} + +inline QDBusMarshaller *QDBusMarshaller::endStructure() +{ return endCommon(); } + +inline QDBusMarshaller *QDBusMarshaller::endArray() +{ return endCommon(); } + +inline QDBusMarshaller *QDBusMarshaller::endMap() +{ return endCommon(); } + +inline QDBusMarshaller *QDBusMarshaller::endMapEntry() +{ return endCommon(); } + +QDBusMarshaller *QDBusMarshaller::endCommon() +{ + QDBusMarshaller *retval = parent; + delete this; + return retval; +} + +void QDBusMarshaller::close() +{ + if (ba) { + if (closeCode) + *ba += closeCode; + } else if (parent) { + q_dbus_message_iter_close_container(&parent->iterator, &iterator); + } +} + +void QDBusMarshaller::error(const QString &msg) +{ + ok = false; + if (parent) + parent->error(msg); + else + errorString = msg; +} + +bool QDBusMarshaller::appendVariantInternal(const QVariant &arg) +{ + int id = arg.userType(); + if (id == QVariant::Invalid) { + qWarning("QDBusMarshaller: cannot add an invalid QVariant"); + error(QLatin1String("Variant containing QVariant::Invalid passed in arguments")); + return false; + } + + // intercept QDBusArgument parameters here + if (id == QDBusMetaTypeId::argument) { + QDBusArgument dbusargument = qvariant_cast<QDBusArgument>(arg); + QDBusArgumentPrivate *d = QDBusArgumentPrivate::d(dbusargument); + if (!d->message) + return false; // can't append this one... + + QDBusDemarshaller demarshaller(capabilities); + demarshaller.message = q_dbus_message_ref(d->message); + + if (d->direction == Demarshalling) { + // it's demarshalling; just copy + demarshaller.iterator = static_cast<QDBusDemarshaller *>(d)->iterator; + } else { + // it's marshalling; start over + if (!q_dbus_message_iter_init(demarshaller.message, &demarshaller.iterator)) + return false; // error! + } + + return appendCrossMarshalling(&demarshaller); + } + + const char *signature = QDBusMetaType::typeToSignature( QVariant::Type(id) ); + if (!signature) { + qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. " + "Use qDBusRegisterMetaType to register it", + QVariant::typeToName( QVariant::Type(id) ), id); + error(QString::fromLatin1("Unregistered type %1 passed in arguments") + .arg(QLatin1String(QVariant::typeToName(QVariant::Type(id))))); + return false; + } + + switch (*signature) { +#ifdef __OPTIMIZE__ + case DBUS_TYPE_BYTE: + case DBUS_TYPE_INT16: + case DBUS_TYPE_UINT16: + case DBUS_TYPE_INT32: + case DBUS_TYPE_UINT32: + case DBUS_TYPE_INT64: + case DBUS_TYPE_UINT64: + case DBUS_TYPE_DOUBLE: + qIterAppend(&iterator, ba, *signature, arg.constData()); + return true; + case DBUS_TYPE_BOOLEAN: + append( arg.toBool() ); + return true; +#else + case DBUS_TYPE_BYTE: + append( qvariant_cast<uchar>(arg) ); + return true; + case DBUS_TYPE_BOOLEAN: + append( arg.toBool() ); + return true; + case DBUS_TYPE_INT16: + append( qvariant_cast<short>(arg) ); + return true; + case DBUS_TYPE_UINT16: + append( qvariant_cast<ushort>(arg) ); + return true; + case DBUS_TYPE_INT32: + append( static_cast<dbus_int32_t>(arg.toInt()) ); + return true; + case DBUS_TYPE_UINT32: + append( static_cast<dbus_uint32_t>(arg.toUInt()) ); + return true; + case DBUS_TYPE_INT64: + append( arg.toLongLong() ); + return true; + case DBUS_TYPE_UINT64: + append( arg.toULongLong() ); + return true; + case DBUS_TYPE_DOUBLE: + append( arg.toDouble() ); + return true; +#endif + + case DBUS_TYPE_STRING: + append( arg.toString() ); + return true; + case DBUS_TYPE_OBJECT_PATH: + append( qvariant_cast<QDBusObjectPath>(arg) ); + return true; + case DBUS_TYPE_SIGNATURE: + append( qvariant_cast<QDBusSignature>(arg) ); + return true; + + // compound types: + case DBUS_TYPE_VARIANT: + // nested QVariant + return append( qvariant_cast<QDBusVariant>(arg) ); + + case DBUS_TYPE_ARRAY: + // could be many things + // find out what kind of array it is + switch (arg.type()) { + case QVariant::StringList: + append( arg.toStringList() ); + return true; + + case QVariant::ByteArray: + append( arg.toByteArray() ); + return true; + + default: + ; // fall through + } + // fall through + + case DBUS_TYPE_STRUCT: + case DBUS_STRUCT_BEGIN_CHAR: + return appendRegisteredType( arg ); + + case DBUS_TYPE_DICT_ENTRY: + case DBUS_DICT_ENTRY_BEGIN_CHAR: + qFatal("QDBusMarshaller::appendVariantInternal got a DICT_ENTRY!"); + return false; + + case DBUS_TYPE_UNIX_FD: + if (capabilities & QDBusConnection::UnixFileDescriptorPassing || ba) { + append(qvariant_cast<QDBusUnixFileDescriptor>(arg)); + return true; + } + // fall through + + default: + qWarning("QDBusMarshaller::appendVariantInternal: Found unknown D-BUS type '%s'", + signature); + return false; + } + + return true; +} + +bool QDBusMarshaller::appendRegisteredType(const QVariant &arg) +{ + ref.ref(); // reference up + QDBusArgument self(QDBusArgumentPrivate::create(this)); + return QDBusMetaType::marshall(self, arg.userType(), arg.constData()); +} + +bool QDBusMarshaller::appendCrossMarshalling(QDBusDemarshaller *demarshaller) +{ + int code = q_dbus_message_iter_get_arg_type(&demarshaller->iterator); + if (QDBusUtil::isValidBasicType(code)) { + // easy: just append + // do exactly like the D-BUS docs suggest + // (see apidocs for q_dbus_message_iter_get_basic) + + qlonglong value; + q_dbus_message_iter_get_basic(&demarshaller->iterator, &value); + q_dbus_message_iter_next(&demarshaller->iterator); + q_dbus_message_iter_append_basic(&iterator, code, &value); + return true; + } + + if (code == DBUS_TYPE_ARRAY) { + int element = q_dbus_message_iter_get_element_type(&demarshaller->iterator); + if (QDBusUtil::isValidFixedType(element) && element != DBUS_TYPE_UNIX_FD) { + // another optimization: fixed size arrays + // code is exactly like QDBusDemarshaller::toByteArray + DBusMessageIter sub; + q_dbus_message_iter_recurse(&demarshaller->iterator, &sub); + q_dbus_message_iter_next(&demarshaller->iterator); + int len; + void* data; + q_dbus_message_iter_get_fixed_array(&sub,&data,&len); + + char signature[2] = { char(element), 0 }; + q_dbus_message_iter_open_container(&iterator, DBUS_TYPE_ARRAY, signature, &sub); + q_dbus_message_iter_append_fixed_array(&sub, element, &data, len); + q_dbus_message_iter_close_container(&iterator, &sub); + + return true; + } + } + + // We have to recurse + QDBusDemarshaller *drecursed = demarshaller->beginCommon(); + + QDBusMarshaller mrecursed(capabilities); // create on the stack makes it autoclose + QByteArray subSignature; + const char *sig = 0; + if (code == DBUS_TYPE_VARIANT || code == DBUS_TYPE_ARRAY) { + subSignature = drecursed->currentSignature().toLatin1(); + if (!subSignature.isEmpty()) + sig = subSignature.constData(); + } + open(mrecursed, code, sig); + + while (!drecursed->atEnd()) { + if (!mrecursed.appendCrossMarshalling(drecursed)) { + delete drecursed; + return false; + } + } + + delete drecursed; + return true; +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusmessage.cpp b/src/dbus/qdbusmessage.cpp new file mode 100644 index 0000000000..bd77c77921 --- /dev/null +++ b/src/dbus/qdbusmessage.cpp @@ -0,0 +1,805 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusmessage.h" + +#include <qdebug.h> +#include <qstringlist.h> + +#include "qdbus_symbols_p.h" + +#include "qdbusargument_p.h" +#include "qdbuserror.h" +#include "qdbusmessage_p.h" +#include "qdbusmetatype.h" +#include "qdbusconnection_p.h" +#include "qdbusutil_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +static inline const char *data(const QByteArray &arr) +{ + return arr.isEmpty() ? 0 : arr.constData(); +} + +QDBusMessagePrivate::QDBusMessagePrivate() + : msg(0), reply(0), type(DBUS_MESSAGE_TYPE_INVALID), + timeout(-1), localReply(0), ref(1), delayedReply(false), localMessage(false), + parametersValidated(false), autoStartService(true) +{ +} + +QDBusMessagePrivate::~QDBusMessagePrivate() +{ + if (msg) + q_dbus_message_unref(msg); + if (reply) + q_dbus_message_unref(reply); + delete localReply; +} + +/*! + \since 4.3 + Returns the human-readable message associated with the error that was received. +*/ +QString QDBusMessage::errorMessage() const +{ + if (d_ptr->type == ErrorMessage) { + if (!d_ptr->message.isEmpty()) + return d_ptr->message; + if (!d_ptr->arguments.isEmpty()) + return d_ptr->arguments.at(0).toString(); + } + return QString(); +} + +/*! + \internal + Constructs a DBusMessage object from \a message. The returned value must be de-referenced + with q_dbus_message_unref. The \a capabilities flags indicates which capabilities to use. + + The \a error object is set to indicate the error if anything went wrong with the + marshalling. Usually, this error message will be placed in the reply, as if the call failed. + The \a error pointer must not be null. +*/ +DBusMessage *QDBusMessagePrivate::toDBusMessage(const QDBusMessage &message, QDBusConnection::ConnectionCapabilities capabilities, + QDBusError *error) +{ + if (!qdbus_loadLibDBus()) { + *error = QDBusError(QDBusError::Failed, QLatin1String("Could not open lidbus-1 library")); + return 0; + } + + DBusMessage *msg = 0; + const QDBusMessagePrivate *d_ptr = message.d_ptr; + + switch (d_ptr->type) { + case DBUS_MESSAGE_TYPE_INVALID: + //qDebug() << "QDBusMessagePrivate::toDBusMessage" << "message is invalid"; + break; + case DBUS_MESSAGE_TYPE_METHOD_CALL: + // only service and interface can be empty -> path and name must not be empty + if (!d_ptr->parametersValidated) { + if (!QDBusUtil::checkBusName(d_ptr->service, QDBusUtil::EmptyAllowed, error)) + return 0; + if (!QDBusUtil::checkObjectPath(d_ptr->path, QDBusUtil::EmptyNotAllowed, error)) + return 0; + if (!QDBusUtil::checkInterfaceName(d_ptr->interface, QDBusUtil::EmptyAllowed, error)) + return 0; + if (!QDBusUtil::checkMemberName(d_ptr->name, QDBusUtil::EmptyNotAllowed, error, "method")) + return 0; + } + + msg = q_dbus_message_new_method_call(data(d_ptr->service.toUtf8()), d_ptr->path.toUtf8(), + data(d_ptr->interface.toUtf8()), d_ptr->name.toUtf8()); + q_dbus_message_set_auto_start( msg, d_ptr->autoStartService ); + break; + case DBUS_MESSAGE_TYPE_METHOD_RETURN: + msg = q_dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); + if (!d_ptr->localMessage) { + q_dbus_message_set_destination(msg, q_dbus_message_get_sender(d_ptr->reply)); + q_dbus_message_set_reply_serial(msg, q_dbus_message_get_serial(d_ptr->reply)); + } + break; + case DBUS_MESSAGE_TYPE_ERROR: + // error name can't be empty + if (!d_ptr->parametersValidated + && !QDBusUtil::checkErrorName(d_ptr->name, QDBusUtil::EmptyNotAllowed, error)) + return 0; + + msg = q_dbus_message_new(DBUS_MESSAGE_TYPE_ERROR); + q_dbus_message_set_error_name(msg, d_ptr->name.toUtf8()); + if (!d_ptr->localMessage) { + q_dbus_message_set_destination(msg, q_dbus_message_get_sender(d_ptr->reply)); + q_dbus_message_set_reply_serial(msg, q_dbus_message_get_serial(d_ptr->reply)); + } + break; + case DBUS_MESSAGE_TYPE_SIGNAL: + // nothing can be empty here + if (!d_ptr->parametersValidated) { + if (!QDBusUtil::checkObjectPath(d_ptr->path, QDBusUtil::EmptyNotAllowed, error)) + return 0; + if (!QDBusUtil::checkInterfaceName(d_ptr->interface, QDBusUtil::EmptyAllowed, error)) + return 0; + if (!QDBusUtil::checkMemberName(d_ptr->name, QDBusUtil::EmptyNotAllowed, error, "method")) + return 0; + } + + msg = q_dbus_message_new_signal(d_ptr->path.toUtf8(), d_ptr->interface.toUtf8(), + d_ptr->name.toUtf8()); + break; + default: + Q_ASSERT(false); + break; + } + + // if we got here, the parameters validated + // and since the message parameters cannot be changed once the message is created + // we can record this fact + d_ptr->parametersValidated = true; + + QDBusMarshaller marshaller(capabilities); + QVariantList::ConstIterator it = d_ptr->arguments.constBegin(); + QVariantList::ConstIterator cend = d_ptr->arguments.constEnd(); + q_dbus_message_iter_init_append(msg, &marshaller.iterator); + if (!d_ptr->message.isEmpty()) + // prepend the error message + marshaller.append(d_ptr->message); + for ( ; it != cend; ++it) + marshaller.appendVariantInternal(*it); + + // check if everything is ok + if (marshaller.ok) + return msg; + + // not ok; + q_dbus_message_unref(msg); + *error = QDBusError(QDBusError::Failed, QLatin1String("Marshalling failed: ") + marshaller.errorString); + return 0; +} + +/* +struct DBusMessage +{ + DBusAtomic refcount; + DBusHeader header; + DBusString body; + char byte_order; + unsigned int locked : 1; +DBUS_DISABLE_CHECKS + unsigned int in_cache : 1; +#endif + DBusList *size_counters; + long size_counter_delta; + dbus_uint32_t changed_stamp : CHANGED_STAMP_BITS; + DBusDataSlotList slot_list; +#ifndef DBUS_DISABLE_CHECKS + int generation; +#endif +}; +*/ + +/*! + \internal + Constructs a QDBusMessage by parsing the given DBusMessage object. +*/ +QDBusMessage QDBusMessagePrivate::fromDBusMessage(DBusMessage *dmsg, QDBusConnection::ConnectionCapabilities capabilities) +{ + QDBusMessage message; + if (!dmsg) + return message; + + message.d_ptr->type = q_dbus_message_get_type(dmsg); + message.d_ptr->path = QString::fromUtf8(q_dbus_message_get_path(dmsg)); + message.d_ptr->interface = QString::fromUtf8(q_dbus_message_get_interface(dmsg)); + message.d_ptr->name = message.d_ptr->type == DBUS_MESSAGE_TYPE_ERROR ? + QString::fromUtf8(q_dbus_message_get_error_name(dmsg)) : + QString::fromUtf8(q_dbus_message_get_member(dmsg)); + message.d_ptr->service = QString::fromUtf8(q_dbus_message_get_sender(dmsg)); + message.d_ptr->signature = QString::fromUtf8(q_dbus_message_get_signature(dmsg)); + message.d_ptr->msg = q_dbus_message_ref(dmsg); + + QDBusDemarshaller demarshaller(capabilities); + demarshaller.message = q_dbus_message_ref(dmsg); + if (q_dbus_message_iter_init(demarshaller.message, &demarshaller.iterator)) + while (!demarshaller.atEnd()) + message << demarshaller.toVariantInternal(); + return message; +} + +bool QDBusMessagePrivate::isLocal(const QDBusMessage &message) +{ + return message.d_ptr->localMessage; +} + +QDBusMessage QDBusMessagePrivate::makeLocal(const QDBusConnectionPrivate &conn, + const QDBusMessage &asSent) +{ + // simulate the message being sent to the bus and then received back + // the only field that the bus sets when delivering the message + // (as opposed to the message as we send it), is the sender + // so we simply set the sender to our unique name + + // determine if we are carrying any complex types + QString computedSignature; + QVariantList::ConstIterator it = asSent.d_ptr->arguments.constBegin(); + QVariantList::ConstIterator end = asSent.d_ptr->arguments.constEnd(); + for ( ; it != end; ++it) { + int id = it->userType(); + const char *signature = QDBusMetaType::typeToSignature(id); + if ((id != QVariant::StringList && id != QVariant::ByteArray && + qstrlen(signature) != 1) || id == qMetaTypeId<QDBusVariant>()) { + // yes, we are + // we must marshall and demarshall again so as to create QDBusArgument + // entries for the complex types + QDBusError error; + DBusMessage *message = toDBusMessage(asSent, conn.capabilities, &error); + if (!message) { + // failed to marshall, so it's a call error + return QDBusMessage::createError(error); + } + + q_dbus_message_set_sender(message, conn.baseService.toUtf8()); + + QDBusMessage retval = fromDBusMessage(message, conn.capabilities); + retval.d_ptr->localMessage = true; + q_dbus_message_unref(message); + if (retval.d_ptr->service.isEmpty()) + retval.d_ptr->service = conn.baseService; + return retval; + } else { + computedSignature += QLatin1String(signature); + } + } + + // no complex types seen + // optimize by using the variant list itself + QDBusMessage retval; + QDBusMessagePrivate *d = retval.d_ptr; + d->arguments = asSent.d_ptr->arguments; + d->path = asSent.d_ptr->path; + d->interface = asSent.d_ptr->interface; + d->name = asSent.d_ptr->name; + d->message = asSent.d_ptr->message; + d->type = asSent.d_ptr->type; + + d->service = conn.baseService; + d->signature = computedSignature; + d->localMessage = true; + return retval; +} + +QDBusMessage QDBusMessagePrivate::makeLocalReply(const QDBusConnectionPrivate &conn, + const QDBusMessage &callMsg) +{ + // simulate the reply (return or error) message being sent to the bus and + // then received back. + if (callMsg.d_ptr->localReply) + return makeLocal(conn, *callMsg.d_ptr->localReply); + return QDBusMessage(); // failed +} + +/*! + \class QDBusMessage + \inmodule QtDBus + \since 4.2 + + \brief The QDBusMessage class represents one message sent or + received over the D-Bus bus. + + This object can represent any of the four different types of + messages (MessageType) that can occur on the bus: + + \list + \o Method calls + \o Method return values + \o Signal emissions + \o Error codes + \endlist + + Objects of this type are created with the static createError(), + createMethodCall() and createSignal() functions. Use the + QDBusConnection::send() function to send the messages. +*/ + +/*! + \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 with the given \a path, \a interface + and \a name, 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 QDBusMessage object that is returned can be sent using the + QDBusConnection::send() function. +*/ +QDBusMessage QDBusMessage::createSignal(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::call(). +*/ +QDBusMessage QDBusMessage::createMethodCall(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 an error, + with the given \a name and \a msg. +*/ +QDBusMessage QDBusMessage::createError(const QString &name, const QString &msg) +{ + QDBusMessage error; + error.d_ptr->type = DBUS_MESSAGE_TYPE_ERROR; + error.d_ptr->name = name; + error.d_ptr->message = msg; + + return error; +} + +/*! + \fn QDBusMessage QDBusMessage::createError(const QDBusError &error) + + Constructs a new DBus message representing the given \a error. +*/ + +/*! + \fn QDBusMessage QDBusMessage::createError(QDBusError::ErrorType type, const QString &msg) + + Constructs a new DBus message for the error type \a type using + the message \a msg. Returns the DBus message. +*/ + +/*! + \fn QDBusMessage QDBusMessage::createReply(const QList<QVariant> &arguments) const + + Constructs a new DBus message representing a reply, with the given + \a arguments. +*/ +QDBusMessage QDBusMessage::createReply(const QVariantList &arguments) const +{ + QDBusMessage reply; + reply.setArguments(arguments); + reply.d_ptr->type = DBUS_MESSAGE_TYPE_METHOD_RETURN; + if (d_ptr->msg) + reply.d_ptr->reply = q_dbus_message_ref(d_ptr->msg); + if (d_ptr->localMessage) { + reply.d_ptr->localMessage = true; + d_ptr->localReply = new QDBusMessage(reply); // keep an internal copy + } + + // the reply must have a msg or be a local-loop optimization + Q_ASSERT(reply.d_ptr->reply || reply.d_ptr->localMessage); + return reply; +} + +/*! + Constructs a new DBus message representing an error reply message, + with the given \a name and \a msg. +*/ +QDBusMessage QDBusMessage::createErrorReply(const QString name, const QString &msg) const +{ + QDBusMessage reply = QDBusMessage::createError(name, msg); + if (d_ptr->msg) + reply.d_ptr->reply = q_dbus_message_ref(d_ptr->msg); + if (d_ptr->localMessage) { + reply.d_ptr->localMessage = true; + d_ptr->localReply = new QDBusMessage(reply); // keep an internal copy + } + + // the reply must have a msg or be a local-loop optimization + Q_ASSERT(reply.d_ptr->reply || reply.d_ptr->localMessage); + return reply; +} + +/*! + \fn QDBusMessage QDBusMessage::createReply(const QVariant &argument) const + + Constructs a new DBus message representing a reply, with the + given \a argument. +*/ + +/*! + \fn QDBusMessage QDBusMessage::createErrorReply(const QDBusError &error) const + + Constructs a new DBus message representing an error reply message, + from the given \a error object. +*/ + +/*! + \fn QDBusMessage QDBusMessage::createErrorReply(QDBusError::ErrorType type, const QString &msg) const + + Constructs a new DBus reply message for the error type \a type using + the message \a msg. Returns the DBus message. +*/ +QDBusMessage QDBusMessage::createErrorReply(QDBusError::ErrorType atype, const QString &amsg) const +{ + QDBusMessage msg = createErrorReply(QDBusError::errorString(atype), amsg); + msg.d_ptr->parametersValidated = true; + return msg; +} + + +/*! + Constructs an empty, invalid QDBusMessage object. + + \sa createError(), createMethodCall(), createSignal() +*/ +QDBusMessage::QDBusMessage() +{ + d_ptr = new QDBusMessagePrivate; +} + +/*! + Constructs a copy of the object given by \a other. + + Note: QDBusMessage objects are shared. Modifications made to the + copy will affect the original one as well. See setDelayedReply() + for more information. +*/ +QDBusMessage::QDBusMessage(const QDBusMessage &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. + + Note: QDBusMessage objects are shared. Modifications made to the + copy will affect the original one as well. See setDelayedReply() + for more information. +*/ +QDBusMessage &QDBusMessage::operator=(const QDBusMessage &other) +{ + qAtomicAssign(d_ptr, other.d_ptr); + return *this; +} + +/*! + Returns the name of the service or the bus address of the remote method call. +*/ +QString QDBusMessage::service() const +{ + return d_ptr->service; +} + +/*! + 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 method that was called. +*/ +QString QDBusMessage::member() const +{ + if (d_ptr->type != ErrorMessage) + return d_ptr->name; + return QString(); +} + +/*! + Returns the name of the error that was received. +*/ +QString QDBusMessage::errorName() const +{ + if (d_ptr->type == ErrorMessage) + return d_ptr->name; + return QString(); +} + +/*! + 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; +} + +/*! + Returns the flag that indicates if this message should see a reply + or not. This is only meaningful for \l {MethodCallMessage}{method + call messages}: any other kind of message cannot have replies and + this function will always return false for them. +*/ +bool QDBusMessage::isReplyRequired() const +{ + if (!d_ptr->msg) + return d_ptr->localMessage; // if it's a local message, reply is required + return !q_dbus_message_get_no_reply(d_ptr->msg); +} + +/*! + Sets whether the message will be replied later (if \a enable is + true) or if an automatic reply should be generated by QtDBus + (if \a enable is false). + + In D-Bus, all method calls must generate a reply to the caller, unless the + caller explicitly indicates otherwise (see isReplyRequired()). QtDBus + automatically generates such replies for any slots being called, but it + also allows slots to indicate whether they will take responsibility + of sending the reply at a later time, after the function has finished + processing. + + \sa {Delayed Replies} +*/ +void QDBusMessage::setDelayedReply(bool enable) const +{ + d_ptr->delayedReply = enable; +} + +/*! + Returns the delayed reply flag, as set by setDelayedReply(). By default, this + flag is false, which means QtDBus will generate automatic replies + when necessary. +*/ +bool QDBusMessage::isDelayedReply() const +{ + return d_ptr->delayedReply; +} + +/*! + Sets the auto start flag to \a enable. This flag only makes sense + for method call messages, where it tells the D-Bus server to + either auto start the service responsible for the service name, or + not to auto start it. + + By default this flag is true, i.e. a service is autostarted. + This means: + + When the service that this method call is sent to is already + running, the method call is sent to it. If the service is not + running yet, the D-Bus daemon is requested to autostart the + service that is assigned to this service name. This is + handled by .service files that are placed in a directory known + to the D-Bus server. These files then each contain a service + name and the path to a program that should be executed when + this service name is requested. + + \since 4.7 +*/ +void QDBusMessage::setAutoStartService(bool enable) +{ + d_ptr->autoStartService = enable; +} + +/*! + Returns the auto start flag, as set by setAutoStartService(). By default, this + flag is true, which means QtDBus will auto start a service, if it is + not running already. + + \sa setAutoStartService() + + \since 4.7 +*/ +bool QDBusMessage::autoStartService() const +{ + return d_ptr->autoStartService; +} + +/*! + Sets the arguments that are going to be sent over D-Bus to \a arguments. Those + will be the arguments to a method call or the parameters in the signal. + + \sa arguments() +*/ +void QDBusMessage::setArguments(const QList<QVariant> &arguments) +{ + // FIXME: should we detach? + d_ptr->arguments = arguments; +} + +/*! + Returns the list of arguments that are going to be sent or were received from + D-Bus. +*/ +QList<QVariant> QDBusMessage::arguments() const +{ + return d_ptr->arguments; +} + +/*! + Appends the argument \a arg to the list of arguments to be sent over D-Bus in + a method call or signal emission. +*/ + +QDBusMessage &QDBusMessage::operator<<(const QVariant &arg) +{ + // FIXME: should we detach? + d_ptr->arguments.append(arg); + return *this; +} + +/*! + 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: + break; + } + return InvalidMessage; +} + +/*! + Sends the message 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; + otherwise returns false. + + \sa QDBusConnection::send() +*/ +#ifndef QT_NO_DEBUG_STREAM +static 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) +{ + bool first = true; + QVariantList::ConstIterator it = list.constBegin(); + QVariantList::ConstIterator end = list.constEnd(); + for ( ; it != end; ++it) { + if (!first) + dbg.nospace() << ", "; + dbg.nospace() << qPrintable(QDBusUtil::argumentToString(*it)); + first = false; + } +} + +QDebug operator<<(QDebug dbg, const QDBusMessage &msg) +{ + dbg.nospace() << "QDBusMessage(type=" << msg.type() + << ", service=" << msg.service(); + if (msg.type() == QDBusMessage::MethodCallMessage || + msg.type() == QDBusMessage::SignalMessage) + dbg.nospace() << ", path=" << msg.path() + << ", interface=" << msg.interface() + << ", member=" << msg.member(); + if (msg.type() == QDBusMessage::ErrorMessage) + dbg.nospace() << ", error name=" << msg.errorName() + << ", error message=" << msg.errorMessage(); + dbg.nospace() << ", signature=" << msg.signature() + << ", contents=("; + debugVariantList(dbg, msg.arguments()); + dbg.nospace() << ") )"; + return dbg.space(); +} +#endif + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusmessage.h b/src/dbus/qdbusmessage.h new file mode 100644 index 0000000000..d88cb4738d --- /dev/null +++ b/src/dbus/qdbusmessage.h @@ -0,0 +1,132 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSMESSAGE_H +#define QDBUSMESSAGE_H + +#include <QtDBus/qdbusmacros.h> +#include <QtDBus/qdbuserror.h> +#include <QtCore/qlist.h> +#include <QtCore/qvariant.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusMessagePrivate; +class Q_DBUS_EXPORT QDBusMessage +{ +public: + enum MessageType { + InvalidMessage, + MethodCallMessage, + ReplyMessage, + ErrorMessage, + SignalMessage + }; + + QDBusMessage(); + QDBusMessage(const QDBusMessage &other); + QDBusMessage &operator=(const QDBusMessage &other); + ~QDBusMessage(); + + static QDBusMessage createSignal(const QString &path, const QString &interface, + const QString &name); + static QDBusMessage createMethodCall(const QString &destination, const QString &path, + const QString &interface, const QString &method); + static QDBusMessage createError(const QString &name, const QString &msg); + static inline QDBusMessage createError(const QDBusError &err) + { return createError(err.name(), err.message()); } + static inline QDBusMessage createError(QDBusError::ErrorType type, const QString &msg) + { return createError(QDBusError::errorString(type), msg); } + + QDBusMessage createReply(const QList<QVariant> &arguments = QList<QVariant>()) const; + inline QDBusMessage createReply(const QVariant &argument) const + { return createReply(QList<QVariant>() << argument); } + + QDBusMessage createErrorReply(const QString name, const QString &msg) const; + inline QDBusMessage createErrorReply(const QDBusError &err) const + { return createErrorReply(err.name(), err.message()); } + QDBusMessage createErrorReply(QDBusError::ErrorType type, const QString &msg) const; + + // there are no setters; if this changes, see qdbusmessage_p.h + QString service() const; + QString path() const; + QString interface() const; + QString member() const; + QString errorName() const; + QString errorMessage() const; + MessageType type() const; + QString signature() const; + + bool isReplyRequired() const; + + void setDelayedReply(bool enable) const; + bool isDelayedReply() const; + + void setAutoStartService(bool enable); + bool autoStartService() const; + + void setArguments(const QList<QVariant> &arguments); + QList<QVariant> arguments() const; + + QDBusMessage &operator<<(const QVariant &arg); + +private: + friend class QDBusMessagePrivate; + QDBusMessagePrivate *d_ptr; +}; + +#ifndef QT_NO_DEBUG_STREAM +Q_DBUS_EXPORT QDebug operator<<(QDebug, const QDBusMessage &); +#endif + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif + diff --git a/src/dbus/qdbusmessage_p.h b/src/dbus/qdbusmessage_p.h new file mode 100644 index 0000000000..52d4d25cdc --- /dev/null +++ b/src/dbus/qdbusmessage_p.h @@ -0,0 +1,110 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSMESSAGE_P_H +#define QDBUSMESSAGE_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of the QLibrary class. This header file may change from +// version to version without notice, or even be removed. +// +// We mean it. +// + +#include <qatomic.h> +#include <qstring.h> +#include <qdbusmessage.h> +#include <qdbusconnection.h> + +struct DBusMessage; + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +class QDBusConnectionPrivate; + +class QDBusMessagePrivate +{ +public: + QDBusMessagePrivate(); + ~QDBusMessagePrivate(); + + QList<QVariant> arguments; + + // the following parameters are "const": they are not changed after the constructors + // the parametersValidated member below controls whether they've been validated already + QString service, path, interface, name, message, signature; + + DBusMessage *msg; + DBusMessage *reply; + int type; + int timeout; + mutable QDBusMessage *localReply; + QAtomicInt ref; + + mutable uint delayedReply : 1; + uint localMessage : 1; + mutable uint parametersValidated : 1; + uint autoStartService : 1; + + static void setParametersValidated(QDBusMessage &msg, bool enable) + { msg.d_ptr->parametersValidated = enable; } + + static DBusMessage *toDBusMessage(const QDBusMessage &message, QDBusConnection::ConnectionCapabilities capabilities, + QDBusError *error); + static QDBusMessage fromDBusMessage(DBusMessage *dmsg, QDBusConnection::ConnectionCapabilities capabilities); + + static bool isLocal(const QDBusMessage &msg); + static QDBusMessage makeLocal(const QDBusConnectionPrivate &conn, + const QDBusMessage &asSent); + static QDBusMessage makeLocalReply(const QDBusConnectionPrivate &conn, + const QDBusMessage &asSent); +}; + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusmetaobject.cpp b/src/dbus/qdbusmetaobject.cpp new file mode 100644 index 0000000000..df8bc1d288 --- /dev/null +++ b/src/dbus/qdbusmetaobject.cpp @@ -0,0 +1,703 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusmetaobject_p.h" + +#include <QtCore/qbytearray.h> +#include <QtCore/qhash.h> +#include <QtCore/qstring.h> +#include <QtCore/qvarlengtharray.h> + +#include "qdbusutil_p.h" +#include "qdbuserror.h" +#include "qdbusmetatype.h" +#include "qdbusargument.h" +#include "qdbusintrospection_p.h" +#include "qdbusabstractinterface_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +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 name; + QByteArray inputSignature; + QByteArray outputSignature; + QVarLengthArray<int, 4> inputTypes; + QVarLengthArray<int, 4> outputTypes; + int flags; + }; + + struct Property { + QByteArray typeName; + QByteArray signature; + int type; + int flags; + }; + struct Type { + int id; + QByteArray name; + }; + + 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; + + Type findType(const QByteArray &signature, + const QDBusIntrospection::Annotations &annotations, + const char *direction = "Out", int id = -1); + + void parseMethods(); + void parseSignals(); + void parseProperties(); +}; + +static const int intsPerProperty = 2; +static const int intsPerMethod = 5; + +// ### 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(); + } +} + +Q_DBUS_EXPORT bool qt_dbus_metaobject_skip_annotations = false; + +QDBusMetaObjectGenerator::Type +QDBusMetaObjectGenerator::findType(const QByteArray &signature, + const QDBusIntrospection::Annotations &annotations, + const char *direction, int id) +{ + Type result; + result.id = QVariant::Invalid; + + int type = QDBusMetaType::signatureToType(signature); + if (type == QVariant::Invalid && !qt_dbus_metaobject_skip_annotations) { + // it's not a type normally handled by our meta type system + // it must contain an annotation + QString annotationName = QString::fromLatin1("com.trolltech.QtDBus.QtTypeName"); + if (id >= 0) + annotationName += QString::fromLatin1(".%1%2") + .arg(QLatin1String(direction)) + .arg(id); + + // extract from annotations: + QByteArray typeName = annotations.value(annotationName).toLatin1(); + + // verify that it's a valid one + if (!typeName.isEmpty()) { + // type name found + type = QVariant::nameToType(typeName); + if (type == QVariant::UserType) + type = QMetaType::type(typeName); + } + + if (type == QVariant::Invalid || signature != QDBusMetaType::typeToSignature(type)) { + // type is still unknown or doesn't match back to the signature that it + // was expected to, so synthesize a fake type + type = QMetaType::VoidStar; + typeName = "QDBusRawType<0x" + signature.toHex() + ">*"; + } + + result.name = typeName; + } else if (type == QVariant::Invalid) { + // this case is used only by the qdbus command-line tool + // invalid, let's create an impossible type that contains the signature + + if (signature == "av") { + result.name = "QVariantList"; + type = QVariant::List; + } else if (signature == "a{sv}") { + result.name = "QVariantMap"; + type = QVariant::Map; + } else { + result.name = "QDBusRawType::" + signature; + type = -1; + } + } else { + result.name = QVariant::typeToName( QVariant::Type(type) ); + } + + result.id = type; + return result; // success +} + +void QDBusMetaObjectGenerator::parseMethods() +{ + // + // TODO: + // Add cloned methods when the remote object has return types + // + + QDBusIntrospection::Methods::ConstIterator method_it = data->methods.constBegin(); + QDBusIntrospection::Methods::ConstIterator method_end = data->methods.constEnd(); + for ( ; method_it != method_end; ++method_it) { + const QDBusIntrospection::Method &m = *method_it; + Method mm; + + mm.name = m.name.toLatin1(); + QByteArray prototype = mm.name; + prototype += '('; + + bool ok = true; + + // build the input argument list + for (int i = 0; i < m.inputArgs.count(); ++i) { + const QDBusIntrospection::Argument &arg = m.inputArgs.at(i); + + Type type = findType(arg.type.toLatin1(), m.annotations, "In", i); + if (type.id == QVariant::Invalid) { + ok = false; + break; + } + + mm.inputSignature += arg.type.toLatin1(); + mm.inputTypes.append(type.id); + + mm.parameters.append(arg.name.toLatin1()); + mm.parameters.append(','); + + prototype.append(type.name); + 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); + + Type type = findType(arg.type.toLatin1(), m.annotations, "Out", i); + if (type.id == QVariant::Invalid) { + ok = false; + break; + } + + mm.outputSignature += arg.type.toLatin1(); + mm.outputTypes.append(type.id); + + if (i == 0) { + // return value + mm.typeName = type.name; + } else { + // non-const ref parameter + mm.parameters.append(arg.name.toLatin1()); + mm.parameters.append(','); + + prototype.append(type.name); + 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_NOREPLY"; + + // meta method flags + mm.flags = AccessPublic | MethodSlot | MethodScriptable; + + // add + methods.insert(QMetaObject::normalizedSignature(prototype), mm); + } +} + +void QDBusMetaObjectGenerator::parseSignals() +{ + QDBusIntrospection::Signals::ConstIterator signal_it = data->signals_.constBegin(); + QDBusIntrospection::Signals::ConstIterator signal_end = data->signals_.constEnd(); + for ( ; signal_it != signal_end; ++signal_it) { + const QDBusIntrospection::Signal &s = *signal_it; + Method mm; + + mm.name = s.name.toLatin1(); + QByteArray prototype = mm.name; + prototype += '('; + + bool ok = true; + + // build the output argument list + for (int i = 0; i < s.outputArgs.count(); ++i) { + const QDBusIntrospection::Argument &arg = s.outputArgs.at(i); + + Type type = findType(arg.type.toLatin1(), s.annotations, "Out", i); + if (type.id == QVariant::Invalid) { + ok = false; + break; + } + + mm.inputSignature += arg.type.toLatin1(); + mm.inputTypes.append(type.id); + + mm.parameters.append(arg.name.toLatin1()); + mm.parameters.append(','); + + prototype.append(type.name); + 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() +{ + QDBusIntrospection::Properties::ConstIterator prop_it = data->properties.constBegin(); + QDBusIntrospection::Properties::ConstIterator prop_end = data->properties.constEnd(); + for ( ; prop_it != prop_end; ++prop_it) { + const QDBusIntrospection::Property &p = *prop_it; + Property mp; + Type type = findType(p.type.toLatin1(), p.annotations); + if (type.id == QVariant::Invalid) + continue; + + QByteArray name = p.name.toLatin1(); + mp.signature = p.type.toLatin1(); + mp.type = type.id; + mp.typeName = type.name; + + // build the flags: + mp.flags = StdCppSet | Scriptable | Stored | Designable; + if (p.access != QDBusIntrospection::Property::Write) + mp.flags |= Readable; + if (p.access != QDBusIntrospection::Property::Read) + mp.flags |= Writable; + + if (mp.typeName == "QDBusVariant") + 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> idata; + idata.resize(sizeof(QDBusMetaObjectPrivate) / sizeof(int)); + + QDBusMetaObjectPrivate *header = reinterpret_cast<QDBusMetaObjectPrivate *>(idata.data()); + header->revision = 1; + header->className = 0; + header->classInfoCount = 0; + header->classInfoData = 0; + header->methodCount = methods.count(); + header->methodData = idata.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 = idata.size() + + (header->methodCount * (5+intsPerMethod)) + + (header->propertyCount * (3+intsPerProperty)); + foreach (const Method &mm, methods) + data_size += 2 + mm.inputTypes.count() + mm.outputTypes.count(); + idata.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; + idata[typeidOffset++] = 0; // eod + + // add each method: + for (QMap<QByteArray, Method>::ConstIterator it = methods.constBegin(); + it != methods.constEnd(); ++it) { + // form "prototype\0parameters\0typeName\0tag\0methodname\0inputSignature\0outputSignature" + const Method &mm = it.value(); + + idata[offset++] = stringdata.length(); + stringdata += it.key(); // prototype + stringdata += null; + idata[offset++] = stringdata.length(); + stringdata += mm.parameters; + stringdata += null; + idata[offset++] = stringdata.length(); + stringdata += mm.typeName; + stringdata += null; + idata[offset++] = stringdata.length(); + stringdata += mm.tag; + stringdata += null; + idata[offset++] = mm.flags; + + idata[signatureOffset++] = stringdata.length(); + stringdata += mm.name; + stringdata += null; + idata[signatureOffset++] = stringdata.length(); + stringdata += mm.inputSignature; + stringdata += null; + idata[signatureOffset++] = stringdata.length(); + stringdata += mm.outputSignature; + stringdata += null; + + idata[signatureOffset++] = typeidOffset; + idata[typeidOffset++] = mm.inputTypes.count(); + memcpy(idata.data() + typeidOffset, mm.inputTypes.data(), mm.inputTypes.count() * sizeof(int)); + typeidOffset += mm.inputTypes.count(); + + idata[signatureOffset++] = typeidOffset; + idata[typeidOffset++] = mm.outputTypes.count(); + memcpy(idata.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 == idata.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" + idata[offset++] = stringdata.length(); + stringdata += it.key(); // name + stringdata += null; + idata[offset++] = stringdata.length(); + stringdata += mp.typeName; + stringdata += null; + idata[offset++] = mp.flags; + + idata[signatureOffset++] = stringdata.length(); + stringdata += mp.signature; + stringdata += null; + idata[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[idata.size()]; + memcpy(uint_data, idata.data(), idata.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 + bool us = it.key() == interface; + + QDBusMetaObject *obj = cache.value(it.key(), 0); + if ( !obj && ( us || !interface.startsWith( QLatin1String("local.") ) ) ) { + // 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); + else if (!us) + delete obj; + + } + + if (us) + // 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::fromLatin1("Interface '%1' was not found") + .arg(interface)); + return 0; +} + +QDBusMetaObject::QDBusMetaObject() +{ +} + +static 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; +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusmetaobject_p.h b/src/dbus/qdbusmetaobject_p.h new file mode 100644 index 0000000000..d71659b484 --- /dev/null +++ b/src/dbus/qdbusmetaobject_p.h @@ -0,0 +1,94 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// 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> + +QT_BEGIN_NAMESPACE + +class QDBusError; + +struct QDBusMetaObjectPrivate; +struct Q_DBUS_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; + +private: + QDBusMetaObject(); +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/dbus/qdbusmetatype.cpp b/src/dbus/qdbusmetatype.cpp new file mode 100644 index 0000000000..9d9112cde5 --- /dev/null +++ b/src/dbus/qdbusmetatype.cpp @@ -0,0 +1,483 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusmetatype.h" + +#include <string.h> +#include "qdbus_symbols_p.h" + +#include <qbytearray.h> +#include <qglobal.h> +#include <qreadwritelock.h> +#include <qvector.h> + +#include "qdbusmessage.h" +#include "qdbusunixfiledescriptor.h" +#include "qdbusutil_p.h" +#include "qdbusmetatype_p.h" +#include "qdbusargument_p.h" + +#ifndef QT_NO_DBUS + +#ifndef DBUS_TYPE_UNIX_FD +# define DBUS_TYPE_UNIX_FD int('h') +# define DBUS_TYPE_UNIX_FD_AS_STRING "h" +#endif + +Q_DECLARE_METATYPE(QList<bool>) +Q_DECLARE_METATYPE(QList<short>) +Q_DECLARE_METATYPE(QList<ushort>) +Q_DECLARE_METATYPE(QList<int>) +Q_DECLARE_METATYPE(QList<uint>) +Q_DECLARE_METATYPE(QList<qlonglong>) +Q_DECLARE_METATYPE(QList<qulonglong>) +Q_DECLARE_METATYPE(QList<double>) + +QT_BEGIN_NAMESPACE + +class QDBusCustomTypeInfo +{ +public: + QDBusCustomTypeInfo() : signature(0, '\0'), marshall(0), demarshall(0) + { } + + // Suggestion: + // change 'signature' to char* and make QDBusCustomTypeInfo a Movable type + QByteArray signature; + QDBusMetaType::MarshallFunction marshall; + QDBusMetaType::DemarshallFunction demarshall; +}; + +template<typename T> +inline static void registerHelper(T * = 0) +{ + void (*mf)(QDBusArgument &, const T *) = qDBusMarshallHelper<T>; + void (*df)(const QDBusArgument &, T *) = qDBusDemarshallHelper<T>; + QDBusMetaType::registerMarshallOperators(qMetaTypeId<T>(), + reinterpret_cast<QDBusMetaType::MarshallFunction>(mf), + reinterpret_cast<QDBusMetaType::DemarshallFunction>(df)); +} + +int QDBusMetaTypeId::message; +int QDBusMetaTypeId::argument; +int QDBusMetaTypeId::variant; +int QDBusMetaTypeId::objectpath; +int QDBusMetaTypeId::signature; +int QDBusMetaTypeId::error; +int QDBusMetaTypeId::unixfd; + +void QDBusMetaTypeId::init() +{ + static volatile bool initialized = false; + + // reentrancy is not a problem since everything else is locked on their own + // set the guard variable at the end + if (!initialized) { + // register our types with QtCore + message = qRegisterMetaType<QDBusMessage>("QDBusMessage"); + argument = qRegisterMetaType<QDBusArgument>("QDBusArgument"); + variant = qRegisterMetaType<QDBusVariant>("QDBusVariant"); + objectpath = qRegisterMetaType<QDBusObjectPath>("QDBusObjectPath"); + signature = qRegisterMetaType<QDBusSignature>("QDBusSignature"); + error = qRegisterMetaType<QDBusError>("QDBusError"); + unixfd = qRegisterMetaType<QDBusUnixFileDescriptor>("QDBusUnixFileDescriptor"); + +#ifndef QDBUS_NO_SPECIALTYPES + // and register QtCore's with us + registerHelper<QDate>(); + registerHelper<QTime>(); + registerHelper<QDateTime>(); + registerHelper<QRect>(); + registerHelper<QRectF>(); + registerHelper<QSize>(); + registerHelper<QSizeF>(); + registerHelper<QPoint>(); + registerHelper<QPointF>(); + registerHelper<QLine>(); + registerHelper<QLineF>(); + registerHelper<QVariantList>(); + registerHelper<QVariantMap>(); + registerHelper<QVariantHash>(); + + qDBusRegisterMetaType<QList<bool> >(); + qDBusRegisterMetaType<QList<short> >(); + qDBusRegisterMetaType<QList<ushort> >(); + qDBusRegisterMetaType<QList<int> >(); + qDBusRegisterMetaType<QList<uint> >(); + qDBusRegisterMetaType<QList<qlonglong> >(); + qDBusRegisterMetaType<QList<qulonglong> >(); + qDBusRegisterMetaType<QList<double> >(); + qDBusRegisterMetaType<QList<QDBusObjectPath> >(); + qDBusRegisterMetaType<QList<QDBusSignature> >(); + qDBusRegisterMetaType<QList<QDBusUnixFileDescriptor> >(); +#endif + + initialized = true; + } +} + +Q_GLOBAL_STATIC(QVector<QDBusCustomTypeInfo>, customTypes) +Q_GLOBAL_STATIC(QReadWriteLock, customTypesLock) + +/*! + \class QDBusMetaType + \brief Meta-type registration system for the QtDBus module. + \internal + + The QDBusMetaType class allows you to register class types for + marshalling and demarshalling over D-Bus. D-Bus supports a very + limited set of primitive types, but allows one to extend the type + system by creating compound types, such as arrays (lists) and + structs. In order to use them with QtDBus, those types must be + registered. + + See \l {qdbustypesystem.html}{QtDBus type system} for more + information on the type system and how to register additional + types. + + \sa {qdbustypesystem.html}{QtDBus type system}, + qDBusRegisterMetaType(), QMetaType, QVariant, QDBusArgument +*/ + +/*! + \fn int qDBusRegisterMetaType() + \relates QDBusArgument + \threadsafe + \since 4.2 + + Registers \c{T} with the + \l {qdbustypesystem.html}{QtDBus type system} and the Qt \l + {QMetaType}{meta-type system}, if it's not already registered. + + To register a type, it must be declared as a meta-type with the + Q_DECLARE_METATYPE() macro, and then registered as in the + following example: + + \snippet doc/src/snippets/code/src_qdbus_qdbusmetatype.cpp 0 + + If \c{T} isn't a type derived from one of + Qt's \l{container classes}, the \c{operator<<} and + \c{operator>>} streaming operators between \c{T} and QDBusArgument + must be already declared. See the \l {qdbustypesystem.html}{QtDBus + type system} page for more information on how to declare such + types. + + This function returns the Qt meta type id for the type (the same + value that is returned from qRegisterMetaType()). + + \sa {qdbustypesystem.html}{QtDBus type system}, qRegisterMetaType(), QMetaType +*/ + +/*! + \typedef QDBusMetaType::MarshallFunction + \internal +*/ + +/*! + \typedef QDBusMetaType::DemarshallFunction + \internal +*/ + +/*! + \internal + Registers the marshalling and demarshalling functions for meta + type \a id. +*/ +void QDBusMetaType::registerMarshallOperators(int id, MarshallFunction mf, + DemarshallFunction df) +{ + QByteArray var; + QVector<QDBusCustomTypeInfo> *ct = customTypes(); + if (id < 0 || !mf || !df || !ct) + return; // error! + + QWriteLocker locker(customTypesLock()); + if (id >= ct->size()) + ct->resize(id + 1); + QDBusCustomTypeInfo &info = (*ct)[id]; + info.marshall = mf; + info.demarshall = df; +} + +/*! + \internal + Executes the marshalling of type \a id (whose data is contained in + \a data) to the D-Bus marshalling argument \a arg. Returns true if + the marshalling succeeded, or false if an error occurred. +*/ +bool QDBusMetaType::marshall(QDBusArgument &arg, int id, const void *data) +{ + QDBusMetaTypeId::init(); + + MarshallFunction mf; + { + QReadLocker locker(customTypesLock()); + QVector<QDBusCustomTypeInfo> *ct = customTypes(); + if (id >= ct->size()) + return false; // non-existent + + const QDBusCustomTypeInfo &info = (*ct).at(id); + if (!info.marshall) { + mf = 0; // make gcc happy + return false; + } else + mf = info.marshall; + } + + mf(arg, data); + return true; +} + +/*! + \internal + Executes the demarshalling of type \a id (whose data will be placed in + \a data) from the D-Bus marshalling argument \a arg. Returns true if + the demarshalling succeeded, or false if an error occurred. +*/ +bool QDBusMetaType::demarshall(const QDBusArgument &arg, int id, void *data) +{ + QDBusMetaTypeId::init(); + + DemarshallFunction df; + { + QReadLocker locker(customTypesLock()); + QVector<QDBusCustomTypeInfo> *ct = customTypes(); + if (id >= ct->size()) + return false; // non-existent + + const QDBusCustomTypeInfo &info = (*ct).at(id); + if (!info.demarshall) { + df = 0; // make gcc happy + return false; + } else + df = info.demarshall; + } + + QDBusArgument copy = arg; + df(copy, data); + return true; +} + +/*! + \fn QDBusMetaType::signatureToType(const char *signature) + \internal + + Returns the Qt meta type id for the given D-Bus signature for exactly one full type, given + by \a signature. + + Note: this function only handles the basic D-Bus types. + + \sa QDBusUtil::isValidSingleSignature(), typeToSignature(), + QVariant::type(), QVariant::userType() +*/ +int QDBusMetaType::signatureToType(const char *signature) +{ + if (!signature) + return QVariant::Invalid; + + QDBusMetaTypeId::init(); + 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: + return QVariant::String; + + case DBUS_TYPE_OBJECT_PATH: + return QDBusMetaTypeId::objectpath; + + case DBUS_TYPE_SIGNATURE: + return QDBusMetaTypeId::signature; + + case DBUS_TYPE_UNIX_FD: + return QDBusMetaTypeId::unixfd; + + case DBUS_TYPE_VARIANT: + return QDBusMetaTypeId::variant; + + case DBUS_TYPE_ARRAY: // special case + switch (signature[1]) { + case DBUS_TYPE_BYTE: + return QVariant::ByteArray; + + case DBUS_TYPE_STRING: + return QVariant::StringList; + + case DBUS_TYPE_VARIANT: + return QVariant::List; + + case DBUS_TYPE_OBJECT_PATH: + return qMetaTypeId<QList<QDBusObjectPath> >(); + + case DBUS_TYPE_SIGNATURE: + return qMetaTypeId<QList<QDBusSignature> >(); + + } + // fall through + default: + return QVariant::Invalid; + } +} + +/*! + \fn QDBusMetaType::typeToSignature(int type) + \internal + + Returns the D-Bus signature equivalent to the supplied meta type id \a type. + + More types can be registered with the qDBusRegisterMetaType() function. + + \sa QDBusUtil::isValidSingleSignature(), signatureToType(), + QVariant::type(), QVariant::userType() +*/ +const char *QDBusMetaType::typeToSignature(int type) +{ + // check if it's a static type + switch (type) + { + case QMetaType::UChar: + return DBUS_TYPE_BYTE_AS_STRING; + + case QVariant::Bool: + return DBUS_TYPE_BOOLEAN_AS_STRING; + + case QMetaType::Short: + return DBUS_TYPE_INT16_AS_STRING; + + case QMetaType::UShort: + return DBUS_TYPE_UINT16_AS_STRING; + + case QVariant::Int: + return DBUS_TYPE_INT32_AS_STRING; + + case QVariant::UInt: + return DBUS_TYPE_UINT32_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::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 + } + + QDBusMetaTypeId::init(); + if (type == QDBusMetaTypeId::variant) + return DBUS_TYPE_VARIANT_AS_STRING; + else if (type == QDBusMetaTypeId::objectpath) + return DBUS_TYPE_OBJECT_PATH_AS_STRING; + else if (type == QDBusMetaTypeId::signature) + return DBUS_TYPE_SIGNATURE_AS_STRING; + else if (type == QDBusMetaTypeId::unixfd) + return DBUS_TYPE_UNIX_FD_AS_STRING; + + // try the database + QVector<QDBusCustomTypeInfo> *ct = customTypes(); + { + QReadLocker locker(customTypesLock()); + if (type >= ct->size()) + return 0; // type not registered with us + + const QDBusCustomTypeInfo &info = (*ct).at(type); + + if (!info.signature.isNull()) + return info.signature; + + if (!info.marshall) + return 0; // type not registered with us + } + + // call to user code to construct the signature type + QDBusCustomTypeInfo *info; + { + // createSignature will never return a null QByteArray + // if there was an error, it'll return "" + QByteArray signature = QDBusArgumentPrivate::createSignature(type); + + // re-acquire lock + QWriteLocker locker(customTypesLock()); + info = &(*ct)[type]; + info->signature = signature; + } + return info->signature; +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusmetatype.h b/src/dbus/qdbusmetatype.h new file mode 100644 index 0000000000..b0cba9bbaa --- /dev/null +++ b/src/dbus/qdbusmetatype.h @@ -0,0 +1,100 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSMETATYPE_H +#define QDBUSMETATYPE_H + +#include "QtCore/qmetatype.h" +#include <QtDBus/qdbusargument.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class Q_DBUS_EXPORT QDBusMetaType +{ +public: + typedef void (*MarshallFunction)(QDBusArgument &, const void *); + typedef void (*DemarshallFunction)(const QDBusArgument &, void *); + + static void registerMarshallOperators(int typeId, MarshallFunction, DemarshallFunction); + static bool marshall(QDBusArgument &, int id, const void *data); + static bool demarshall(const QDBusArgument &, int id, void *data); + + static int signatureToType(const char *signature); + static const char *typeToSignature(int type); +}; + +template<typename T> +void qDBusMarshallHelper(QDBusArgument &arg, const T *t) +{ arg << *t; } + +template<typename T> +void qDBusDemarshallHelper(const QDBusArgument &arg, T *t) +{ arg >> *t; } + +template<typename T> +int qDBusRegisterMetaType( +#ifndef qdoc + T * /* dummy */ = 0 +#endif +) +{ + void (*mf)(QDBusArgument &, const T *) = qDBusMarshallHelper<T>; + void (*df)(const QDBusArgument &, T *) = qDBusDemarshallHelper<T>; + + int id = qRegisterMetaType<T>(); // make sure it's registered + QDBusMetaType::registerMarshallOperators(id, + reinterpret_cast<QDBusMetaType::MarshallFunction>(mf), + reinterpret_cast<QDBusMetaType::DemarshallFunction>(df)); + return id; +} + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusmetatype_p.h b/src/dbus/qdbusmetatype_p.h new file mode 100644 index 0000000000..b931c75ab1 --- /dev/null +++ b/src/dbus/qdbusmetatype_p.h @@ -0,0 +1,75 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSMETATYPE_P_H +#define QDBUSMETATYPE_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of the QLibrary class. This header file may change from +// version to version without notice, or even be removed. +// +// We mean it. +// + +#include <qdbusmetatype.h> + +QT_BEGIN_NAMESPACE + +struct QDBusMetaTypeId +{ + static int message; // QDBusMessage + static int argument; // QDBusArgument + static int variant; // QDBusVariant + static int objectpath; // QDBusObjectPath + static int signature; // QDBusSignature + static int error; // QDBusError + static int unixfd; // QDBusUnixFileDescriptor + + static void init(); +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/dbus/qdbusmisc.cpp b/src/dbus/qdbusmisc.cpp new file mode 100644 index 0000000000..58c28cf287 --- /dev/null +++ b/src/dbus/qdbusmisc.cpp @@ -0,0 +1,201 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <string.h> + +#include <QtCore/qcoreapplication.h> +#include <QtCore/qvariant.h> +#include <QtCore/qmetaobject.h> + +#include "qdbusutil_p.h" +#include "qdbusconnection_p.h" +#include "qdbusmetatype_p.h" +#include "qdbusabstractadaptor_p.h" // for QCLASSINFO_DBUS_* + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +bool qDBusCheckAsyncTag(const char *tag) +{ + static const char noReplyTag[] = "Q_NOREPLY"; + if (!tag || !*tag) + return false; + + const char *p = strstr(tag, noReplyTag); + if (p != NULL && + (p == tag || *(p-1) == ' ') && + (p[sizeof noReplyTag - 1] == '\0' || p[sizeof noReplyTag - 1] == ' ')) + 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); + return id; +} + +QString qDBusInterfaceFromMetaObject(const QMetaObject *mo) +{ + QString interface; + + 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')) && + interface.length() >= 2 && interface.at(1).isUpper()) { + // 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('.'), + QString::SkipEmptyParts); + if (domainName.isEmpty()) + interface.prepend(QLatin1String("local.")); + else + for (int i = 0; i < domainName.count(); ++i) + interface.prepend(QLatin1Char('.')).prepend(domainName.at(i)); + } + } + + return interface; +} + +bool qDBusInterfaceInObject(QObject *obj, const QString &interface_name) +{ + const QMetaObject *mo = obj->metaObject(); + for ( ; mo != &QObject::staticMetaObject; mo = mo->superClass()) + if (interface_name == qDBusInterfaceFromMetaObject(mo)) + return true; + return false; +} + +// 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) +{ + QDBusMetaTypeId::init(); + + QList<QByteArray> parameterTypes = mm.parameterTypes(); + metaTypes.clear(); + + metaTypes.append(0); // return type + int inputCount = 0; + bool seenMessage = false; + QList<QByteArray>::ConstIterator it = parameterTypes.constBegin(); + QList<QByteArray>::ConstIterator end = parameterTypes.constEnd(); + for ( ; it != end; ++it) { + const QByteArray &type = *it; + if (type.endsWith('*')) { + //qWarning("Could not parse the method '%s'", mm.signature()); + // pointer? + return -1; + } + + if (type.endsWith('&')) { + QByteArray basictype = type; + basictype.truncate(type.length() - 1); + + int id = qDBusNameToTypeId(basictype); + if (id == 0) { + //qWarning("Could not parse the method '%s'", mm.signature()); + // invalid type in method parameter list + return -1; + } else if (QDBusMetaType::typeToSignature(id) == 0) + 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; + } + + if (id == QDBusMetaTypeId::message) + seenMessage = true; + else if (QDBusMetaType::typeToSignature(id) == 0) + return -1; + + metaTypes.append(id); + ++inputCount; + } + + return inputCount; +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbuspendingcall.cpp b/src/dbus/qdbuspendingcall.cpp new file mode 100644 index 0000000000..3ebd149ed3 --- /dev/null +++ b/src/dbus/qdbuspendingcall.cpp @@ -0,0 +1,539 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbuspendingcall.h" +#include "qdbuspendingcall_p.h" + +#include "qdbusconnection_p.h" +#include "qdbusmetatype_p.h" +#include "qcoreapplication.h" +#include "qcoreevent.h" +#include <private/qobject_p.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +/*! + \class QDBusPendingCall + \inmodule QtDBus + \since 4.5 + + \brief The QDBusPendingCall class refers to one pending asynchronous call + + A QDBusPendingCall object is a reference to a method call that was + sent over D-Bus without waiting for a reply. QDBusPendingCall is an + opaque type, meant to be used as a handle for a pending reply. + + In most programs, the QDBusPendingCall class will not be used + directly. It can be safely replaced with the template-based + QDBusPendingReply, in order to access the contents of the reply or + wait for it to be complete. + + The QDBusPendingCallWatcher class allows one to connect to a signal + that will indicate when the reply has arrived or if the call has + timed out. It also provides the + QDBusPendingCallWatcher::waitForFinished() method which will suspend + the execution of the program until the reply has arrived. + + \note If you create a copy of a QDBusPendingCall object, all + information will be shared among the many copies. Therefore, + QDBusPendingCall is an explicitly-shared object and does not + provide a method of detaching the copies (since they refer + to the same pending call) + + \sa QDBusPendingReply, QDBusPendingCallWatcher, + QDBusAbstractInterface::asyncCall() +*/ + +/*! + \class QDBusPendingCallWatcher + \inmodule QtDBus + \since 4.5 + + \brief The QDBusPendingCallWatcher class provides a convenient way for + waiting for asynchronous replies + + The QDBusPendingCallWatcher provides the finished() signal that will be + emitted when a reply arrives. + + It is usually used like the following example: + + \snippet doc/src/snippets/code/src.qdbus.qdbuspendingcall.cpp 0 + + Note that it is not necessary to keep the original QDBusPendingCall + object around since QDBusPendingCallWatcher inherits from that class + too. + + The slot connected to by the above code could be something similar + to the following: + + \snippet doc/src/snippets/code/src.qdbus.qdbuspendingcall.cpp 1 + + Note the use of QDBusPendingReply to validate the argument types in + the reply. If the reply did not contain exactly two arguments + (one string and one QByteArray), QDBusPendingReply::isError() will + return true. + + \sa QDBusPendingReply, QDBusAbstractInterface::asyncCall() +*/ + +/*! + \fn void QDBusPendingCallWatcher::finished(QDBusPendingCallWatcher *self) + + This signal is emitted when the pending call has finished and its + reply is available. The \a self parameter is a pointer to the + object itself, passed for convenience so that the slot can access + the properties and determine the contents of the reply. +*/ + +void QDBusPendingCallWatcherHelper::add(QDBusPendingCallWatcher *watcher) +{ + connect(this, SIGNAL(finished()), watcher, SLOT(_q_finished()), Qt::QueuedConnection); +} + +QDBusPendingCallPrivate::~QDBusPendingCallPrivate() +{ + if (pending) { + q_dbus_pending_call_cancel(pending); + q_dbus_pending_call_unref(pending); + } + delete watcherHelper; +} + +bool QDBusPendingCallPrivate::setReplyCallback(QObject *target, const char *member) +{ + receiver = target; + metaTypes.clear(); + methodIdx = -1; + if (!target) + return true;; // unsetting + + if (!member || !*member) { + // would not be able to deliver a reply + qWarning("QDBusPendingCall::setReplyCallback: error: cannot deliver a reply to %s::%s (%s)", + target ? target->metaObject()->className() : "(null)", + member ? member + 1 : "(null)", + target ? qPrintable(target->objectName()) : "no name"); + return false; + } + + methodIdx = QDBusConnectionPrivate::findSlot(target, member + 1, metaTypes); + if (methodIdx == -1) { + QByteArray normalizedName = QMetaObject::normalizedSignature(member + 1); + methodIdx = QDBusConnectionPrivate::findSlot(target, normalizedName, metaTypes); + } + if (methodIdx == -1) { + // would not be able to deliver a reply + qWarning("QDBusPendingCall::setReplyCallback: error: cannot deliver a reply to %s::%s (%s)", + target->metaObject()->className(), + member + 1, qPrintable(target->objectName())); + return false; + } + + // success + // construct the expected signature + int count = metaTypes.count() - 1; + if (count == 1 && metaTypes.at(1) == QDBusMetaTypeId::message) { + // wildcard slot, can receive anything, so don't set the signature + return true; + } + + if (metaTypes.at(count) == QDBusMetaTypeId::message) + --count; + + // QList<int> is actually a vector + // kids, don't try this at home + setMetaTypes(count, count ? &metaTypes.at(1) : 0); + return true; +} + +void QDBusPendingCallPrivate::setMetaTypes(int count, const int *types) +{ + expectedReplyCount = count; + if (count == 0) { + expectedReplySignature = QLatin1String(""); // not null + return; + } + + QByteArray sig; + sig.reserve(count + count / 2); + for (int i = 0; i < count; ++i) { + const char *typeSig = QDBusMetaType::typeToSignature(types[i]); + if (!typeSig) { + qFatal("QDBusPendingReply: type %s is not registered with QtDBus", + QMetaType::typeName(types[i])); + } + sig += typeSig; + } + + expectedReplySignature = QString::fromLatin1(sig); +} + +void QDBusPendingCallPrivate::checkReceivedSignature() +{ + // MUST BE CALLED WITH A LOCKED MUTEX! + + if (replyMessage.type() == QDBusMessage::InvalidMessage) + return; // not yet finished - no message to + // validate against + if (replyMessage.type() == QDBusMessage::ErrorMessage) + return; // we don't have to check the signature of an error reply + + if (expectedReplySignature.isNull()) + return; // no signature to validate against + + // can't use startsWith here because a null string doesn't start or end with an empty string + if (!replyMessage.signature().indexOf(expectedReplySignature) == 0) { + QString errorMsg = QLatin1String("Unexpected reply signature: got \"%1\", " + "expected \"%2\""); + replyMessage = QDBusMessage::createError( + QDBusError::InvalidSignature, + errorMsg.arg(replyMessage.signature(), expectedReplySignature)); + + } +} + +void QDBusPendingCallPrivate::waitForFinished() +{ + QMutexLocker locker(&mutex); + + if (replyMessage.type() != QDBusMessage::InvalidMessage) + return; // already finished + + connection->waitForFinished(this); +} + +/*! + Creates a copy of the \a other pending asynchronous call. Note + that both objects will refer to the same pending call. +*/ +QDBusPendingCall::QDBusPendingCall(const QDBusPendingCall &other) + : d(other.d) +{ +} + +/*! + \internal +*/ +QDBusPendingCall::QDBusPendingCall(QDBusPendingCallPrivate *dd) + : d(dd) +{ +} + +/*! + Destroys this copy of the QDBusPendingCall object. If this copy is + also the last copy of a pending asynchronous call, the call will + be canceled and no further notifications will be received. There + will be no way of accessing the reply's contents when it arrives. +*/ +QDBusPendingCall::~QDBusPendingCall() +{ + // d deleted by QExplicitlySharedDataPointer +} + + +/*! + Creates a copy of the \a other pending asynchronous call and drops + the reference to the previously-referenced call. Note that both + objects will refer to the same pending call after this function. + + If this object contained the last reference of a pending + asynchronous call, the call will be canceled and no further + notifications will be received. There will be no way of accessing + the reply's contents when it arrives. +*/ +QDBusPendingCall &QDBusPendingCall::operator=(const QDBusPendingCall &other) +{ + d = other.d; + return *this; +} + +/*! + \fn bool QDBusPendingCallWatcher::isFinished() const + + Returns true if the pending call has finished processing and the + reply has been received. + + Note that this function only changes state if you call + waitForFinished() or if an external D-Bus event happens, which in + general only happens if you return to the event loop execution. + + \sa QDBusPendingReply::isFinished() +*/ +/*! + \fn bool QDBusPendingReply::isFinished() const + + Returns true if the pending call has finished processing and the + reply has been received. If this function returns true, the + isError(), error() and reply() methods should return valid + information. + + Note that this function only changes state if you call + waitForFinished() or if an external D-Bus event happens, which in + general only happens if you return to the event loop execution. + + \sa QDBusPendingCallWatcher::isFinished() +*/ + +bool QDBusPendingCall::isFinished() const +{ + if (!d) + return true; // considered finished + + QMutexLocker locker(&d->mutex); + return d->replyMessage.type() != QDBusMessage::InvalidMessage; +} + +void QDBusPendingCall::waitForFinished() +{ + if (d) d->waitForFinished(); +} + +/*! + \fn bool QDBusPendingReply::isValid() const + + Returns true if the reply contains a normal reply message, false + if it contains anything else. + + If the pending call has not finished processing, this function + return false. +*/ +bool QDBusPendingCall::isValid() const +{ + if (!d) + return false; + QMutexLocker locker(&d->mutex); + return d->replyMessage.type() == QDBusMessage::ReplyMessage; +} + +/*! + \fn bool QDBusPendingReply::isError() const + + Returns true if the reply contains an error message, false if it + contains a normal method reply. + + If the pending call has not finished processing, this function + also returns true. +*/ +bool QDBusPendingCall::isError() const +{ + if (!d) + return true; // considered finished and an error + QMutexLocker locker(&d->mutex); + return d->replyMessage.type() == QDBusMessage::ErrorMessage; +} + +/*! + \fn QDBusError QDBusPendingReply::error() const + + Retrieves the error content of the reply message, if it has + finished processing. If the reply message has not finished + processing or if it contains a normal reply message (non-error), + this function returns an invalid QDBusError. +*/ +QDBusError QDBusPendingCall::error() const +{ + if (d) { + QMutexLocker locker(&d->mutex); + return d->replyMessage; + } + + // not connected, return an error + QDBusError err = QDBusError(QDBusError::Disconnected, + QLatin1String("Not connected to D-Bus server")); + return err; +} + +/*! + \fn QDBusMessage QDBusPendingReply::reply() const + + Retrieves the reply message received for the asynchronous call + that was sent, if it has finished processing. If the pending call + is not finished, this function returns a QDBusMessage of type + QDBusMessage::InvalidMessage. + + After it has finished processing, the message type will either be + an error message or a normal method reply message. +*/ +QDBusMessage QDBusPendingCall::reply() const +{ + if (!d) + return QDBusMessage::createError(error()); + QMutexLocker locker(&d->mutex); + return d->replyMessage; +} + +#if 0 +/*! + Sets the slot \a member in object \a target to be called when the + reply arrives. The slot's parameter list must match the reply + message's arguments for it to be called. + + It may, optionally, contain a QDBusMessage final parameter. If it + is present, the parameter will contain the reply message object. + + The callback will not be called if the reply is an error message. + + This function returns true if it could set the callback, false + otherwise. It is not a guarantee that the callback will be + called. + + \warning QDBusPendingCall only supports one callback per pending + asynchronous call, even if multiple QDBusPendingCall + objects are referencing the same pending call. +*/ +bool QDBusPendingCall::setReplyCallback(QObject *target, const char *member) +{ + if (!d) + return false; + + return d->setReplyCallback(target, member); +} +#endif + +/*! + \since 4.6 + Creates a QDBusPendingCall object based on the error condition + \a error. The resulting pending call object will be in the + "finished" state and QDBusPendingReply::isError() will return true. + + \sa fromCompletedCall() +*/ +QDBusPendingCall QDBusPendingCall::fromError(const QDBusError &error) +{ + return fromCompletedCall(QDBusMessage::createError(error)); +} + +/*! + \since 4.6 + Creates a QDBusPendingCall object based on the message \a msg. + The message must be of type QDBusMessage::ErrorMessage or + QDBusMessage::ReplyMessage (that is, a message that is typical + of a completed call). + + This function is useful for code that requires simulating a pending + call, but that has already finished. + + \sa fromError() +*/ +QDBusPendingCall QDBusPendingCall::fromCompletedCall(const QDBusMessage &msg) +{ + QDBusPendingCallPrivate *d = 0; + if (msg.type() == QDBusMessage::ErrorMessage || + msg.type() == QDBusMessage::ReplyMessage) { + d = new QDBusPendingCallPrivate(QDBusMessage(), 0); + d->replyMessage = msg; + } + + return QDBusPendingCall(d); +} + + +class QDBusPendingCallWatcherPrivate: public QObjectPrivate +{ +public: + void _q_finished(); + + Q_DECLARE_PUBLIC(QDBusPendingCallWatcher) +}; + +inline void QDBusPendingCallWatcherPrivate::_q_finished() +{ + Q_Q(QDBusPendingCallWatcher); + emit q->finished(q); +} + +/*! + Creates a QDBusPendingCallWatcher object to watch for replies on the + asynchronous pending call \a call and sets this object's parent + to \a parent. +*/ +QDBusPendingCallWatcher::QDBusPendingCallWatcher(const QDBusPendingCall &call, QObject *parent) + : QObject(*new QDBusPendingCallWatcherPrivate, parent), QDBusPendingCall(call) +{ + if (d) { // QDBusPendingCall::d + QMutexLocker locker(&d->mutex); + if (!d->watcherHelper) { + d->watcherHelper = new QDBusPendingCallWatcherHelper; + if (d->replyMessage.type() != QDBusMessage::InvalidMessage) { + // cause a signal emission anyways + QMetaObject::invokeMethod(d->watcherHelper, "finished", Qt::QueuedConnection); + } + } + d->watcherHelper->add(this); + } +} + +/*! + Destroys this object. If this QDBusPendingCallWatcher object was the + last reference to the unfinished pending call, the call will be + canceled. +*/ +QDBusPendingCallWatcher::~QDBusPendingCallWatcher() +{ +} + +/*! + \fn void QDBusPendingCallWatcher::waitForFinished() + + Suspends the execution of the calling thread until the reply is + received and processed. After this function returns, isFinished() + should return true, indicating the reply's contents are ready to + be processed. + + \sa QDBusPendingReply::waitForFinished() +*/ +void QDBusPendingCallWatcher::waitForFinished() +{ + if (d) { + d->waitForFinished(); + + // our signals were queued, so deliver them + QCoreApplication::sendPostedEvents(d->watcherHelper, QEvent::MetaCall); + QCoreApplication::sendPostedEvents(this, QEvent::MetaCall); + } +} +QT_END_NAMESPACE + +#endif // QT_NO_DBUS + +#include "moc_qdbuspendingcall.cpp" diff --git a/src/dbus/qdbuspendingcall.h b/src/dbus/qdbuspendingcall.h new file mode 100644 index 0000000000..d1e783f459 --- /dev/null +++ b/src/dbus/qdbuspendingcall.h @@ -0,0 +1,125 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSPENDINGCALL_H +#define QDBUSPENDINGCALL_H + +#include <QtCore/qglobal.h> +#include <QtCore/qobject.h> +#include <QtCore/qshareddata.h> + +#include <QtDBus/qdbusmacros.h> +#include <QtDBus/qdbusmessage.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusConnection; +class QDBusError; +class QDBusPendingCallWatcher; + +class QDBusPendingCallPrivate; +class Q_DBUS_EXPORT QDBusPendingCall +{ +public: + QDBusPendingCall(const QDBusPendingCall &other); + ~QDBusPendingCall(); + QDBusPendingCall &operator=(const QDBusPendingCall &other); + +#ifndef Q_QDOC + // pretend that they aren't here + bool isFinished() const; + void waitForFinished(); + + bool isError() const; + bool isValid() const; + QDBusError error() const; + QDBusMessage reply() const; +#endif + + static QDBusPendingCall fromError(const QDBusError &error); + static QDBusPendingCall fromCompletedCall(const QDBusMessage &message); + +protected: + QExplicitlySharedDataPointer<QDBusPendingCallPrivate> d; + friend class QDBusPendingCallPrivate; + friend class QDBusPendingCallWatcher; + friend class QDBusConnection; + + QDBusPendingCall(QDBusPendingCallPrivate *dd); + +private: + QDBusPendingCall(); // not defined +}; + +class QDBusPendingCallWatcherPrivate; +class Q_DBUS_EXPORT QDBusPendingCallWatcher: public QObject, public QDBusPendingCall +{ + Q_OBJECT +public: + QDBusPendingCallWatcher(const QDBusPendingCall &call, QObject *parent = 0); + ~QDBusPendingCallWatcher(); + +#ifdef Q_QDOC + // trick qdoc into thinking this method is here + bool isFinished() const; +#endif + void waitForFinished(); // non-virtual override + +Q_SIGNALS: + void finished(QDBusPendingCallWatcher *self); + +private: + Q_DECLARE_PRIVATE(QDBusPendingCallWatcher) + Q_PRIVATE_SLOT(d_func(), void _q_finished()) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbuspendingcall_p.h b/src/dbus/qdbuspendingcall_p.h new file mode 100644 index 0000000000..b61f2578ba --- /dev/null +++ b/src/dbus/qdbuspendingcall_p.h @@ -0,0 +1,141 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// 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 QDBUSPENDINGCALL_P_H +#define QDBUSPENDINGCALL_P_H + +#include <qshareddata.h> +#include <qpointer.h> +#include <qlist.h> +#include <qmutex.h> +#include <qwaitcondition.h> + +#include "qdbusmessage.h" +#include "qdbus_symbols_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +class QDBusPendingCall; +class QDBusPendingCallWatcher; +class QDBusPendingCallWatcherHelper; +class QDBusConnectionPrivate; + +class QDBusPendingCallPrivate: public QSharedData +{ +public: + // { + // set only during construction: + const QDBusMessage sentMessage; + QDBusConnectionPrivate * const connection; + + // for the callback mechanism (see setReplyCallback and QDBusConnectionPrivate::sendWithReplyAsync) + QPointer<QObject> receiver; + QList<int> metaTypes; + int methodIdx; + + bool autoDelete; + // } + + mutable QMutex mutex; + QWaitCondition waitForFinishedCondition; + + // { + // protected by the mutex above: + QDBusPendingCallWatcherHelper *watcherHelper; + QDBusMessage replyMessage; + DBusPendingCall *pending; + volatile bool waitingForFinished; + + QString expectedReplySignature; + int expectedReplyCount; + // } + + QDBusPendingCallPrivate(const QDBusMessage &sent, QDBusConnectionPrivate *connection) + : sentMessage(sent), connection(connection), autoDelete(false), watcherHelper(0), pending(0), waitingForFinished(false) + { } + ~QDBusPendingCallPrivate(); + bool setReplyCallback(QObject *target, const char *member); + void waitForFinished(); + void setMetaTypes(int count, const int *types); + void checkReceivedSignature(); + + static QDBusPendingCall fromMessage(const QDBusMessage &msg); +}; + +class QDBusPendingCallWatcherHelper: public QObject +{ + Q_OBJECT +public: + void add(QDBusPendingCallWatcher *watcher); + + void emitSignals(const QDBusMessage &replyMessage, const QDBusMessage &sentMessage) + { + if (replyMessage.type() == QDBusMessage::ReplyMessage) + emit reply(replyMessage); + else + emit error(replyMessage, sentMessage); + emit finished(); + } + +Q_SIGNALS: + void finished(); + void reply(const QDBusMessage &msg); + void error(const QDBusError &error, const QDBusMessage &msg); +}; + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbuspendingreply.cpp b/src/dbus/qdbuspendingreply.cpp new file mode 100644 index 0000000000..4dc1c77b8e --- /dev/null +++ b/src/dbus/qdbuspendingreply.cpp @@ -0,0 +1,281 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbuspendingreply.h" +#include "qdbuspendingcall_p.h" +#include "qdbusmetatype.h" + +#ifndef QT_NO_DBUS + +/*! + \class QDBusPendingReply + \inmodule QtDBus + \since 4.5 + + \brief The QDBusPendingReply class contains the reply to an asynchronous method call + + The QDBusPendingReply is a template class with up to 8 template + parameters. Those parameters are the types that will be used to + extract the contents of the reply's data. + + This class is similar in functionality to QDBusReply, but with two + important differences: + + \list + \o QDBusReply accepts exactly one return type, whereas + QDBusPendingReply can have from 1 to 8 types + \o QDBusReply only works on already completed replies, whereas + QDBusPendingReply allows one to wait for replies from pending + calls + \endlist + + Where with QDBusReply you would write: + + \snippet doc/src/snippets/code/src_qdbus_qdbusreply.cpp 0 + + with QDBusPendingReply, the equivalent code (including the blocking + wait for the reply) would be: + + \snippet doc/src/snippets/code/src.qdbus.qdbuspendingreply.cpp 0 + + For method calls that have more than one output argument, with + QDBusReply, you would write: + + \snippet doc/src/snippets/code/src_qdbus_qdbusreply.cpp 1 + + whereas with QDBusPendingReply, all of the output arguments should + be template parameters: + + \snippet doc/src/snippets/code/src.qdbus.qdbuspendingreply.cpp 2 + + QDBusPendingReply objects can be associated with + QDBusPendingCallWatcher objects, which emit signals when the reply + arrives. + + \sa QDBusPendingCallWatcher, QDBusReply, + QDBusAbstractInterface::asyncCall() +*/ + +/*! + \fn QDBusPendingReply::QDBusPendingReply() + + Creates an empty QDBusPendingReply object. Without assigning a + QDBusPendingCall object to this reply, QDBusPendingReply cannot do + anything. All functions return their failure values. +*/ + +/*! + \fn QDBusPendingReply::QDBusPendingReply(const QDBusPendingReply &other) + + Creates a copy of the \a other QDBusPendingReply object. Just like + QDBusPendingCall and QDBusPendingCallWatcher, this QDBusPendingReply + object will share the same pending call reference. All copies + share the same return values. +*/ + +/*! + \fn QDBusPendingReply::QDBusPendingReply(const QDBusPendingCall &call) + + Creates a QDBusPendingReply object that will take its contents from + the \a call pending asynchronous call. This QDBusPendingReply object + will share the same pending call reference as \a call. +*/ + +/*! + \fn QDBusPendingReply::QDBusPendingReply(const QDBusMessage &message) + + Creates a QDBusPendingReply object that will take its contents from + the message \a message. In this case, this object will be already + in its finished state and the reply's contents will be accessible. + + \sa isFinished() +*/ + +/*! + \fn QDBusPendingReply &QDBusPendingReply::operator=(const QDBusPendingReply &other) + + Makes a copy of \a other and drops the reference to the current + pending call. If the current reference is to an unfinished pending + call and this is the last reference, the pending call will be + canceled and there will be no way of retrieving the reply's + contents, when they arrive. +*/ + +/*! + \fn QDBusPendingReply &QDBusPendingReply::operator=(const QDBusPendingCall &call) + + Makes this object take its contents from the \a call pending call + and drops the reference to the current pending call. If the + current reference is to an unfinished pending call and this is the + last reference, the pending call will be canceled and there will + be no way of retrieving the reply's contents, when they arrive. +*/ + +/*! + \fn QDBusPendingReply &QDBusPendingReply::operator=(const QDBusMessage &message) + + Makes this object take its contents from the \a message message + and drops the reference to the current pending call. If the + current reference is to an unfinished pending call and this is the + last reference, the pending call will be canceled and there will + be no way of retrieving the reply's contents, when they arrive. + + After this function is finished, the QDBusPendingReply object will + be in its "finished" state and the \a message contents will be + accessible. + + \sa isFinished() +*/ + +/*! + \fn int QDBusPendingReply::count() const + + Return the number of arguments the reply is supposed to have. This + number matches the number of non-void template parameters in this + class. + + If the reply arrives with a different number of arguments (or with + different types), it will be transformed into an error reply + indicating a bad signature. +*/ + +/*! + \fn QVariant QDBusPendingReply::argumentAt(int index) const + + Returns the argument at position \a index in the reply's + contents. If the reply doesn't have that many elements, this + function's return value is undefined (will probably cause an + assertion failure), so it is important to verify that the + processing is finished and the reply is valid. +*/ + +/*! + \fn Type QDBusPendingReply::argumentAt() const + + Returns the argument at position \c Index (which is a template + parameter) cast to type \c Type. This function uses template code + to determine the proper \c Type type, according to the type list + used in the construction of this object. + + Note that, if the reply hasn't arrived, this function causes the + calling thread to block until the reply is processed. +*/ + +/*! + \fn T1 QDBusPendingReply::value() const + + Returns the first argument in this reply, cast to type \c T1 (the + first template parameter of this class). This is equivalent to + calling argumentAt<0>(). + + This function is provided as a convenience, matching the + QDBusReply::value() function. + + Note that, if the reply hasn't arrived, this function causes the + calling thread to block until the reply is processed. +*/ + +/*! + \fn QDBusPendingReply::operator T1() const + + Returns the first argument in this reply, cast to type \c T1 (the + first template parameter of this class). This is equivalent to + calling argumentAt<0>(). + + This function is provided as a convenience, matching the + QDBusReply::value() function. + + Note that, if the reply hasn't arrived, this function causes the + calling thread to block until the reply is processed. +*/ + +/*! + \fn void QDBusPendingReply::waitForFinished() + + Suspends the execution of the calling thread until the reply is + received and processed. After this function returns, isFinished() + should return true, indicating the reply's contents are ready to + be processed. + + \sa QDBusPendingCallWatcher::waitForFinished() +*/ + +QDBusPendingReplyData::QDBusPendingReplyData() + : QDBusPendingCall(0) // initialize base class empty +{ +} + +QDBusPendingReplyData::~QDBusPendingReplyData() +{ +} + +void QDBusPendingReplyData::assign(const QDBusPendingCall &other) +{ + QDBusPendingCall::operator=(other); +} + +void QDBusPendingReplyData::assign(const QDBusMessage &message) +{ + d = new QDBusPendingCallPrivate(QDBusMessage(), 0); // drops the reference to the old one + d->replyMessage = message; +} + +QVariant QDBusPendingReplyData::argumentAt(int index) const +{ + if (d) + d->waitForFinished(); // bypasses "const" + + Q_ASSERT_X(d && index >= 0 && index < d->replyMessage.arguments().count(), + "QDBusPendingReply::argumentAt", + "Index out of bounds"); + + return d->replyMessage.arguments().at(index); +} + +void QDBusPendingReplyData::setMetaTypes(int count, const int *types) +{ + Q_ASSERT(d); + QMutexLocker locker(&d->mutex); + d->setMetaTypes(count, types); + d->checkReceivedSignature(); +} + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbuspendingreply.h b/src/dbus/qdbuspendingreply.h new file mode 100644 index 0000000000..cb230ca8da --- /dev/null +++ b/src/dbus/qdbuspendingreply.h @@ -0,0 +1,217 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSPENDINGREPLY_H +#define QDBUSPENDINGREPLY_H + +#include <QtCore/qglobal.h> +#include <QtDBus/qdbusmacros.h> +#include <QtDBus/qdbusargument.h> +#include <QtDBus/qdbuspendingcall.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class Q_DBUS_EXPORT QDBusPendingReplyData: public QDBusPendingCall +{ +protected: + QDBusPendingReplyData(); + ~QDBusPendingReplyData(); + void assign(const QDBusPendingCall &call); + void assign(const QDBusMessage &message); + + QVariant argumentAt(int index) const; + void setMetaTypes(int count, const int *metaTypes); +}; + +namespace QDBusPendingReplyTypes { + template<int Index, + typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6, typename T7, typename T8> + struct Select + { + typedef Select<Index - 1, T2, T3, T4, T5, T6, T7, T8, void> Next; + typedef typename Next::Type Type; + }; + template<typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6, typename T7, typename T8> + struct Select<0, T1, T2, T3, T4, T5, T6, T7, T8> + { + typedef T1 Type; + }; + + template<typename T1> inline int metaTypeFor(T1 * = 0) + { return qMetaTypeId<T1>(); } + // specialize for QVariant, allowing it to be used in place of QDBusVariant + template<> inline int metaTypeFor<QVariant>(QVariant *) + { return qMetaTypeId<QDBusVariant>(); } + + template<typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6, typename T7, typename T8> + struct ForEach + { + typedef ForEach<T2, T3, T4, T5, T6, T7, T8, void> Next; + enum { Total = Next::Total + 1 }; + static inline void fillMetaTypes(int *p) + { + *p = metaTypeFor<T1>(0); + Next::fillMetaTypes(++p); + } + }; + template<> + struct ForEach<void, void, void, void, void, void, void, void> + { + enum { Total = 0 }; + static inline void fillMetaTypes(int *) + { } + }; +} // namespace QDBusPendingReplyTypes + +template<typename T1 = void, typename T2 = void, typename T3 = void, typename T4 = void, + typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void> +class QDBusPendingReply: +#ifdef Q_QDOC + public QDBusPendingCall +#else + public QDBusPendingReplyData +#endif +{ + typedef QDBusPendingReplyTypes::ForEach<T1, T2, T3, T4, T5, T6, T7, T8> ForEach; + template<int Index> struct Select : + QDBusPendingReplyTypes::Select<Index, T1, T2, T3, T4, T5, T6, T7, T8> + { + }; + +public: + enum { Count = ForEach::Total }; + + inline QDBusPendingReply() + { } + inline QDBusPendingReply(const QDBusPendingReply &other) + : QDBusPendingReplyData(other) + { } + inline QDBusPendingReply(const QDBusPendingCall &call) + { *this = call; } + inline QDBusPendingReply(const QDBusMessage &message) + { *this = message; } + inline QDBusPendingReply &operator=(const QDBusPendingReply &other) + { assign(other); return *this; } + inline QDBusPendingReply &operator=(const QDBusPendingCall &call) + { assign(call); return *this; } + inline QDBusPendingReply &operator=(const QDBusMessage &message) + { assign(message); return *this; } + + inline int count() const { return Count; } + +#if defined(Q_QDOC) || defined(Q_NO_USING_KEYWORD) + inline QVariant argumentAt(int index) const + { return QDBusPendingReplyData::argumentAt(index); } +#else + using QDBusPendingReplyData::argumentAt; +#endif + +#if defined(Q_QDOC) + bool isFinished() const; + void waitForFinished(); + + bool isValid() const; + bool isError() const; + QDBusError error() const; + QDBusMessage reply() const; + + template<int Index> inline Type argumentAt() const; + inline T1 value() const; + inline operator T1() const; +#else + template<int Index> inline + const typename Select<Index>::Type argumentAt() const + { + // static assert? + Q_ASSERT_X(Index < count() && Index >= 0, "QDBusPendingReply::argumentAt", + "Index out of bounds"); + typedef typename Select<Index>::Type ResultType; + return qdbus_cast<ResultType>(argumentAt(Index), 0); + } + + inline typename Select<0>::Type value() const + { + return argumentAt<0>(); + } + + inline operator typename Select<0>::Type() const + { + return argumentAt<0>(); + } +#endif + +private: + inline void calculateMetaTypes() + { + if (!d) return; + int typeIds[Count > 0 ? Count : 1]; // use at least one since zero-sized arrays aren't valid + ForEach::fillMetaTypes(typeIds); + setMetaTypes(Count, typeIds); + } + + inline void assign(const QDBusPendingCall &call) + { + QDBusPendingReplyData::assign(call); + calculateMetaTypes(); + } + + inline void assign(const QDBusMessage &message) + { + QDBusPendingReplyData::assign(message); + calculateMetaTypes(); + } +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusreply.cpp b/src/dbus/qdbusreply.cpp new file mode 100644 index 0000000000..d360f27290 --- /dev/null +++ b/src/dbus/qdbusreply.cpp @@ -0,0 +1,248 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusreply.h" +#include "qdbusmetatype.h" +#include "qdbusmetatype_p.h" +#include <QDebug> + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +/*! + \class QDBusReply + \inmodule QtDBus + \since 4.2 + + \brief The QDBusReply class stores 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: + \snippet doc/src/snippets/code/src_qdbus_qdbusreply.cpp 0 + + If the remote method call cannot fail, you can skip the error checking: + \snippet doc/src/snippets/code/src_qdbus_qdbusreply.cpp 1 + + However, if it does fail under those conditions, the value returned by QDBusReply::value() is + a default-constructed value. It may be indistinguishable 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). Use the isValid() function to test if the reply succeeded. + + \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 QDBusPendingReply<T> &reply) + Constructs a QDBusReply object from the pending reply message, \a reply. +*/ + +/*! + \fn QDBusReply::QDBusReply(const QDBusPendingCall &pcall) + Automatically construct a QDBusReply object from the asynchronous + pending call \a pcall. If the call isn't finished yet, QDBusReply + will call QDBusPendingCall::waitForFinished(), which is a blocking + operation. + + If the return types patch, QDBusReply will extract the first + return argument from the reply. +*/ + +/*! + \fn QDBusReply::QDBusReply(const QDBusError &error) + Constructs an error reply from the D-Bus error code given by \a error. +*/ + +/*! + \fn QDBusReply::operator=(const QDBusReply &other) + Makes this object be a copy of the object \a other. +*/ + +/*! + \fn QDBusReply::operator=(const QDBusError &error) + Sets this object to contain the error code given by \a error. You + can later access it with error(). +*/ + +/*! + \fn QDBusReply::operator=(const QDBusMessage &message) + + Makes this object contain the reply specified by message \a + message. If \a message is an error message, this function will + copy the error code and message into this object + + If \a message is a standard reply message and contains at least + one parameter, it will be copied into this object, as long as it + is of the correct type. If it's not of the same type as this + QDBusError object, this function will instead set an error code + indicating a type mismatch. +*/ + +/*! + \fn QDBusReply::operator=(const QDBusPendingCall &pcall) + + Makes this object contain the reply specified by the pending + asynchronous call \a pcall. If the call is not finished yet, this + function will call QDBusPendingCall::waitForFinished() to block + until the reply arrives. + + If \a pcall finishes with an error message, this function will + copy the error code and message into this object + + If \a pcall finished with a standard reply message and contains at + least one parameter, it will be copied into this object, as long + as it is of the correct type. If it's not of the same type as this + QDBusError object, this function will instead set an error code + indicating a type mismatch. +*/ + +/*! + \fn bool QDBusReply::isValid() const + + Returns true if no error occurred; otherwise, returns false. + + \sa error() +*/ + +/*! + \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). + + \sa isValid() +*/ + +/*! + \fn QDBusReply::value() const + 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() const + Returns the same as value(). + + This function is not available if the remote call returns \c void. +*/ + +/*! + \internal + Fills in the QDBusReply data \a error and \a data from the reply message \a reply. +*/ +void qDBusReplyFill(const QDBusMessage &reply, QDBusError &error, QVariant &data) +{ + error = reply; + + if (error.isValid()) { + data = QVariant(); // clear it + return; + } + + if (reply.arguments().count() >= 1 && reply.arguments().at(0).userType() == data.userType()) { + data = reply.arguments().at(0); + return; + } + + const char *expectedSignature = QDBusMetaType::typeToSignature(data.userType()); + const char *receivedType = 0; + QByteArray receivedSignature; + + if (reply.arguments().count() >= 1) { + if (reply.arguments().at(0).userType() == QDBusMetaTypeId::argument) { + // compare signatures instead + QDBusArgument arg = qvariant_cast<QDBusArgument>(reply.arguments().at(0)); + receivedSignature = arg.currentSignature().toLatin1(); + if (receivedSignature == expectedSignature) { + // matched. Demarshall it + QDBusMetaType::demarshall(arg, data.userType(), data.data()); + return; + } + } else { + // not an argument and doesn't match? + int type = reply.arguments().at(0).userType(); + receivedType = QVariant::typeToName(QVariant::Type(type)); + receivedSignature = QDBusMetaType::typeToSignature(type); + } + } + + // error + if (receivedSignature.isEmpty()) + receivedSignature = "no signature"; + QString errorMsg; + if (receivedType) { + errorMsg = QString::fromLatin1("Unexpected reply signature: got \"%1\" (%4), " + "expected \"%2\" (%3)") + .arg(QLatin1String(receivedSignature), + QLatin1String(expectedSignature), + QLatin1String(data.typeName()), + QLatin1String(receivedType)); + } else { + errorMsg = QString::fromLatin1("Unexpected reply signature: got \"%1\", " + "expected \"%2\" (%3)") + .arg(QLatin1String(receivedSignature), + QLatin1String(expectedSignature), + QLatin1String(data.typeName())); + } + + error = QDBusError(QDBusError::InvalidSignature, errorMsg); + data = QVariant(); // clear it +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusreply.h b/src/dbus/qdbusreply.h new file mode 100644 index 0000000000..1f535e3356 --- /dev/null +++ b/src/dbus/qdbusreply.h @@ -0,0 +1,199 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSREPLY_H +#define QDBUSREPLY_H + +#include <QtCore/qglobal.h> +#include <QtCore/qvariant.h> + +#include <QtDBus/qdbusmacros.h> +#include <QtDBus/qdbusmessage.h> +#include <QtDBus/qdbuserror.h> +#include <QtDBus/qdbusextratypes.h> +#include <QtDBus/qdbuspendingreply.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +Q_DBUS_EXPORT void qDBusReplyFill(const QDBusMessage &reply, QDBusError &error, QVariant &data); + +template<typename T> +class QDBusReply +{ + typedef T Type; +public: + inline QDBusReply(const QDBusMessage &reply) + { + *this = reply; + } + inline QDBusReply& operator=(const QDBusMessage &reply) + { + QVariant data(qMetaTypeId(&m_data), reinterpret_cast<void*>(0)); + qDBusReplyFill(reply, m_error, data); + m_data = qvariant_cast<Type>(data); + return *this; + } + + inline QDBusReply(const QDBusPendingCall &pcall) + { + *this = pcall; + } + inline QDBusReply &operator=(const QDBusPendingCall &pcall) + { + QDBusPendingCall other(pcall); + other.waitForFinished(); + return *this = other.reply(); + } + inline QDBusReply(const QDBusPendingReply<T> &reply) + { + *this = static_cast<QDBusPendingCall>(reply); + } + + inline QDBusReply(const QDBusError &dbusError = QDBusError()) + : m_error(dbusError), m_data(Type()) + { + } + inline QDBusReply& operator=(const QDBusError& dbusError) + { + m_error = dbusError; + 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 isValid() const { return !m_error.isValid(); } + + inline const QDBusError& error() { return m_error; } + + inline Type value() const + { + return m_data; + } + + inline operator Type () const + { + return m_data; + } + +private: + QDBusError m_error; + Type m_data; +}; + +# ifndef Q_QDOC +// specialize for QVariant: +template<> inline QDBusReply<QVariant>& +QDBusReply<QVariant>::operator=(const QDBusMessage &reply) +{ + void *null = 0; + QVariant data(qMetaTypeId<QDBusVariant>(), null); + qDBusReplyFill(reply, m_error, data); + m_data = qvariant_cast<QDBusVariant>(data).variant(); + return *this; +} + +// specialize for void: +template<> +class QDBusReply<void> +{ +public: + inline QDBusReply(const QDBusMessage &reply) + : m_error(reply) + { + } + inline QDBusReply& operator=(const QDBusMessage &reply) + { + m_error = reply; + return *this; + } + inline QDBusReply(const QDBusError &dbusError = QDBusError()) + : m_error(dbusError) + { + } + inline QDBusReply(const QDBusPendingCall &pcall) + { + *this = pcall; + } + inline QDBusReply &operator=(const QDBusPendingCall &pcall) + { + QDBusPendingCall other(pcall); + other.waitForFinished(); + return *this = other.reply(); + } + inline QDBusReply& operator=(const QDBusError& dbusError) + { + m_error = dbusError; + return *this; + } + + inline QDBusReply& operator=(const QDBusReply& other) + { + m_error = other.m_error; + return *this; + } + + inline bool isValid() const { return !m_error.isValid(); } + + inline const QDBusError& error() { return m_error; } + +private: + QDBusError m_error; +}; +# endif + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusserver.cpp b/src/dbus/qdbusserver.cpp new file mode 100644 index 0000000000..abc5cb3cbe --- /dev/null +++ b/src/dbus/qdbusserver.cpp @@ -0,0 +1,140 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusserver.h" +#include "qdbusconnection_p.h" +#include "qdbusconnectionmanager_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +/*! + \class QDBusServer + \inmodule QtDBus + \internal + + \brief The QDBusServer class provides peer-to-peer communication + between processes on the same computer. +*/ + +/*! + Constructs a QDBusServer with the given \a address, and the given + \a parent. +*/ +QDBusServer::QDBusServer(const QString &address, QObject *parent) + : QObject(parent) +{ + if (address.isEmpty()) + return; + + if (!qdbus_loadLibDBus()) { + d = 0; + return; + } + d = new QDBusConnectionPrivate(this); + + QMutexLocker locker(&QDBusConnectionManager::instance()->mutex); + QDBusConnectionManager::instance()->setConnection(QLatin1String("QDBusServer-") + QString::number(reinterpret_cast<qulonglong>(d)), d); + + QObject::connect(d, SIGNAL(newServerConnection(QDBusConnection)), + this, SIGNAL(newConnection(QDBusConnection))); + + QDBusErrorInternal error; + d->setServer(q_dbus_server_listen(address.toUtf8().constData(), error), error); +} + +/*! + Destructs a QDBusServer +*/ +QDBusServer::~QDBusServer() +{ + if (QDBusConnectionManager::instance()) { + QMutexLocker locker(&QDBusConnectionManager::instance()->mutex); + QDBusConnectionManager::instance()->removeConnection(d->name); + } +} + +/*! + Returns true if this QDBusServer object is connected. + + If it isn't connected, you need to call the constructor again. +*/ +bool QDBusServer::isConnected() const +{ + return d && d->server && q_dbus_server_get_is_connected(d->server); +} + +/*! + Returns the last error that happened in this server. + + This function is provided for low-level code. +*/ +QDBusError QDBusServer::lastError() const +{ + return d->lastError; +} + +/*! + Returns the address this server is associated with. +*/ +QString QDBusServer::address() const +{ + QString addr; + if (d && d->server) { + char *c = q_dbus_server_get_address(d->server); + addr = QString::fromUtf8(c); + q_dbus_free(c); + } + + return addr; +} + +/*! + \fn void QDBusServer::newConnection(const QDBusConnection &connection) + + This signal is emitted when a new client connection \a connection is + established to the server. + */ + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusserver.h b/src/dbus/qdbusserver.h new file mode 100644 index 0000000000..fcb78bdb1e --- /dev/null +++ b/src/dbus/qdbusserver.h @@ -0,0 +1,84 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#ifndef QDBUSSERVER_H +#define QDBUSSERVER_H + +#include <QtCore/qobject.h> +#include <QtCore/qstring.h> +#include <QtDBus/qdbusmacros.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusConnectionPrivate; +class QDBusError; +class QDBusConnection; + +class Q_DBUS_EXPORT QDBusServer: public QObject +{ + Q_OBJECT +public: + QDBusServer(const QString &address = "unix:tmpdir=/tmp", QObject *parent = 0); + virtual ~QDBusServer(); + + bool isConnected() const; + QDBusError lastError() const; + QString address() const; + +Q_SIGNALS: + void newConnection(const QDBusConnection &connection); + +private: + Q_DISABLE_COPY(QDBusServer) + QDBusConnectionPrivate *d; +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusservicewatcher.cpp b/src/dbus/qdbusservicewatcher.cpp new file mode 100644 index 0000000000..615d7d38e0 --- /dev/null +++ b/src/dbus/qdbusservicewatcher.cpp @@ -0,0 +1,381 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusservicewatcher.h" +#include "qdbusconnection.h" +#include "qdbus_symbols_p.h" + +#include <QStringList> + +#include <private/qobject_p.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +Q_GLOBAL_STATIC_WITH_ARGS(QString, busService, (QLatin1String(DBUS_SERVICE_DBUS))) +Q_GLOBAL_STATIC_WITH_ARGS(QString, busInterface, (QLatin1String(DBUS_INTERFACE_DBUS))) +Q_GLOBAL_STATIC_WITH_ARGS(QString, signalName, (QLatin1String("NameOwnerChanged"))) + +class QDBusServiceWatcherPrivate: public QObjectPrivate +{ + Q_DECLARE_PUBLIC(QDBusServiceWatcher) +public: + QDBusServiceWatcherPrivate(const QDBusConnection &c, QDBusServiceWatcher::WatchMode wm) + : connection(c), watchMode(wm) + { + } + + QStringList servicesWatched; + QDBusConnection connection; + QDBusServiceWatcher::WatchMode watchMode; + + void _q_serviceOwnerChanged(const QString &, const QString &, const QString &); + void setConnection(const QStringList &services, const QDBusConnection &c, QDBusServiceWatcher::WatchMode watchMode); + + QStringList matchArgsForService(const QString &service); + void addService(const QString &service); + void removeService(const QString &service); +}; + +void QDBusServiceWatcherPrivate::_q_serviceOwnerChanged(const QString &service, const QString &oldOwner, const QString &newOwner) +{ + Q_Q(QDBusServiceWatcher); + emit q->serviceOwnerChanged(service, oldOwner, newOwner); + if (oldOwner.isEmpty()) + emit q->serviceRegistered(service); + else if (newOwner.isEmpty()) + emit q->serviceUnregistered(service); +} + +void QDBusServiceWatcherPrivate::setConnection(const QStringList &s, const QDBusConnection &c, QDBusServiceWatcher::WatchMode wm) +{ + if (connection.isConnected()) { + // remove older rules + foreach (const QString &s, servicesWatched) + removeService(s); + } + + connection = c; + watchMode = wm; + servicesWatched = s; + + if (connection.isConnected()) { + // add new rules + foreach (const QString &s, servicesWatched) + addService(s); + } +} + +QStringList QDBusServiceWatcherPrivate::matchArgsForService(const QString &service) +{ + QStringList matchArgs; + matchArgs << service; + + switch (watchMode) { + case QDBusServiceWatcher::WatchForOwnerChange: + break; + + case QDBusServiceWatcher::WatchForRegistration: + matchArgs << QString::fromLatin1("", 0); + break; + + case QDBusServiceWatcher::WatchForUnregistration: + matchArgs << QString() << QString::fromLatin1("", 0); + break; + } + return matchArgs; +} + +void QDBusServiceWatcherPrivate::addService(const QString &service) +{ + QStringList matchArgs = matchArgsForService(service); + connection.connect(*busService(), QString(), *busInterface(), *signalName(), + matchArgs, QString(), q_func(), + SLOT(_q_serviceOwnerChanged(QString,QString,QString))); +} + +void QDBusServiceWatcherPrivate::removeService(const QString &service) +{ + QStringList matchArgs = matchArgsForService(service); + connection.disconnect(*busService(), QString(), *busInterface(), *signalName(), + matchArgs, QString(), q_func(), + SLOT(_q_serviceOwnerChanged(QString,QString,QString))); +} + +/*! + \class QDBusServiceWatcher + \since 4.6 + \inmodule QtDBus + + \brief The QDBusServiceWatcher class allows the user to watch for a bus service change. + + A QDBusServiceWatcher object can be used to notify the application about + an ownership change of a service name on the bus. It has three watch + modes: + + \list + \o Watching for service registration only. + \o Watching for service unregistration only. + \o Watching for any kind of service ownership change (the default mode). + \endlist + + Besides being created or deleted, services may change owners without a + unregister/register operation happening. So the serviceRegistered() + and serviceUnregistered() signals may not be emitted if that + happens. + + This class is more efficient than using the + QDBusConnectionInterface::serviceOwnerChanged() signal because it allows + one to receive only the signals for which the class is interested in. + + \sa QDBusConnection +*/ + +/*! + \enum QDBusServiceWatcher::WatchModeFlag + + QDBusServiceWatcher supports three different watch modes, which are configured by this flag: + + \value WatchForRegistration watch for service registration only, ignoring + any signals related to other service ownership change. + + \value WatchForUnregistration watch for service unregistration only, + ignoring any signals related to other service ownership change. + + \value WatchForOwnerChange watch for any kind of service ownership + change. +*/ + +/*! + \property QDBusServiceWatcher::watchMode + + The \c watchMode property holds the current watch mode for this + QDBusServiceWatcher object. The default value for this property is + QDBusServiceWatcher::WatchForOwnershipChange. +*/ + +/*! + \property QDBusServiceWatcher::watchedServices + + The \c servicesWatched property holds the list of services watched. + + Note that modifying this list with setServicesWatched() is an expensive + operation. If you can, prefer to change it by way of addWatchedService() + and removeWatchedService(). +*/ + +/*! + \fn void QDBusServiceWatcher::serviceRegistered(const QString &serviceName) + + This signal is emitted whenever this object detects that the service \a + serviceName became available on the bus. + + \sa serviceUnregistered(), serviceOwnerChanged() +*/ + +/*! + \fn void QDBusServiceWatcher::serviceUnregistered(const QString &serviceName) + + This signal is emitted whenever this object detects that the service \a + serviceName was unregistered from the bus and is no longer available. + + \sa serviceRegistered(), serviceOwnerChanged() +*/ + +/*! + \fn void QDBusServiceWatcher::serviceOwnerChanged(const QString &serviceName, const QString &oldOwner, const QString &newOwner) + + This signal is emitted whenever this object detects that there was a + service ownership change relating to the \a serviceName service. The \a + oldOwner parameter contains the old owner name and \a newOwner is the new + owner. Both \a oldOwner and \a newOwner are unique connection names. + + Note that this signal is also emitted whenever the \a serviceName service + was registered or unregistered. If it was registered, \a oldOwner will + contain an empty string, whereas if it was unregistered, \a newOwner will + contain an empty string. + + If you need only to find out if the service is registered or unregistered + only, without being notified that the ownership changed, consider using + the specific modes for those operations. This class is more efficient if + you use the more specific modes. + + \sa serviceRegistered(), serviceUnregistered() +*/ + +/*! + Creates a QDBusServiceWatcher object. Note that until you set a + connection with setConnection(), this object will not emit any signals. + + The \a parent parameter is passed to QObject to set the parent of this + object. +*/ +QDBusServiceWatcher::QDBusServiceWatcher(QObject *parent) + : QObject(*new QDBusServiceWatcherPrivate(QDBusConnection(QString()), WatchForOwnerChange), parent) +{ +} + +/*! + Creates a QDBusServiceWatcher object and attaches it to the \a connection + connection. Also, this function immediately starts watching for \a + watchMode changes to service \a service. + + The \a parent parameter is passed to QObject to set the parent of this + object. +*/ +QDBusServiceWatcher::QDBusServiceWatcher(const QString &service, const QDBusConnection &connection, WatchMode watchMode, QObject *parent) + : QObject(*new QDBusServiceWatcherPrivate(connection, watchMode), parent) +{ + d_func()->setConnection(QStringList() << service, connection, watchMode); +} + +/*! + Destroys the QDBusServiceWatcher object and releases any resources + associated with it. +*/ +QDBusServiceWatcher::~QDBusServiceWatcher() +{ +} + +/*! + Returns the list of D-Bus services that are being watched. + + \sa setWatchedServices() +*/ +QStringList QDBusServiceWatcher::watchedServices() const +{ + return d_func()->servicesWatched; +} + +/*! + Sets the list of D-Bus services being watched to be \a services. + + Note that setting the entire list means removing all previous rules for + watching services and adding new ones. This is an expensive operation and + should be avoided, if possible. Instead, use addWatchedService() and + removeWatchedService() if you can to manipulate entries in the list. +*/ +void QDBusServiceWatcher::setWatchedServices(const QStringList &services) +{ + Q_D(QDBusServiceWatcher); + if (services == d->servicesWatched) + return; + d->setConnection(services, d->connection, d->watchMode); +} + +/*! + Adds \a newService to the list of services to be watched by this object. + This function is more efficient than setWatchedServices() and should be + used whenever possible to add services. +*/ +void QDBusServiceWatcher::addWatchedService(const QString &newService) +{ + Q_D(QDBusServiceWatcher); + if (d->servicesWatched.contains(newService)) + return; + d->addService(newService); + d->servicesWatched << newService; +} + +/*! + Removes the \a service from the list of services being watched by this + object. Note that D-Bus notifications are asynchronous, so there may + still be signals pending delivery about \a service. Those signals will + still be emitted whenever the D-Bus messages are processed. + + This function returns true if any services were removed. +*/ +bool QDBusServiceWatcher::removeWatchedService(const QString &service) +{ + Q_D(QDBusServiceWatcher); + d->removeService(service); + return d->servicesWatched.removeOne(service); +} + +QDBusServiceWatcher::WatchMode QDBusServiceWatcher::watchMode() const +{ + return d_func()->watchMode; +} + +void QDBusServiceWatcher::setWatchMode(WatchMode mode) +{ + Q_D(QDBusServiceWatcher); + if (mode == d->watchMode) + return; + d->setConnection(d->servicesWatched, d->connection, mode); +} + +/*! + Returns the QDBusConnection that this object is attached to. + + \sa setConnection() +*/ +QDBusConnection QDBusServiceWatcher::connection() const +{ + return d_func()->connection; +} + +/*! + Sets the D-Bus connection that this object is attached to be \a + connection. All services watched will be transferred to this connection. + + Note that QDBusConnection objects are reference counted: + QDBusServiceWatcher will keep a reference for this connection while it + exists. The connection is not closed until the reference count drops to + zero, so this will ensure that any notifications are received while this + QDBusServiceWatcher object exists. + + \sa connection() +*/ +void QDBusServiceWatcher::setConnection(const QDBusConnection &connection) +{ + Q_D(QDBusServiceWatcher); + if (connection.name() == d->connection.name()) + return; + d->setConnection(d->servicesWatched, connection, d->watchMode); +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS + +#include "moc_qdbusservicewatcher.cpp" diff --git a/src/dbus/qdbusservicewatcher.h b/src/dbus/qdbusservicewatcher.h new file mode 100644 index 0000000000..0e0b52efac --- /dev/null +++ b/src/dbus/qdbusservicewatcher.h @@ -0,0 +1,106 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSSERVICEWATCHER_H +#define QDBUSSERVICEWATCHER_H + +#include <QtCore/qobject.h> +#include <QtDBus/qdbusmacros.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusConnection; + +class QDBusServiceWatcherPrivate; +class Q_DBUS_EXPORT QDBusServiceWatcher: public QObject +{ + Q_OBJECT + Q_PROPERTY(QStringList watchedServices READ watchedServices WRITE setWatchedServices) + Q_PROPERTY(WatchMode watchMode READ watchMode WRITE setWatchMode) +public: + enum WatchModeFlag { + WatchForRegistration = 0x01, + WatchForUnregistration = 0x02, + WatchForOwnerChange = 0x03 + }; + Q_DECLARE_FLAGS(WatchMode, WatchModeFlag) + + explicit QDBusServiceWatcher(QObject *parent = 0); + QDBusServiceWatcher(const QString &service, const QDBusConnection &connection, + WatchMode watchMode = WatchForOwnerChange, QObject *parent = 0); + ~QDBusServiceWatcher(); + + QStringList watchedServices() const; + void setWatchedServices(const QStringList &services); + void addWatchedService(const QString &newService); + bool removeWatchedService(const QString &service); + + WatchMode watchMode() const; + void setWatchMode(WatchMode mode); + + QDBusConnection connection() const; + void setConnection(const QDBusConnection &connection); + +Q_SIGNALS: + void serviceRegistered(const QString &service); + void serviceUnregistered(const QString &service); + void serviceOwnerChanged(const QString &service, const QString &oldOwner, const QString &newOwner); + +private: + Q_PRIVATE_SLOT(d_func(), void _q_serviceOwnerChanged(QString,QString,QString)) + Q_DISABLE_COPY(QDBusServiceWatcher) + Q_DECLARE_PRIVATE(QDBusServiceWatcher) +}; + +Q_DECLARE_OPERATORS_FOR_FLAGS(QDBusServiceWatcher::WatchMode) + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif // QDBUSSERVICEWATCHER_H diff --git a/src/dbus/qdbusthreaddebug_p.h b/src/dbus/qdbusthreaddebug_p.h new file mode 100644 index 0000000000..d595a41cb7 --- /dev/null +++ b/src/dbus/qdbusthreaddebug_p.h @@ -0,0 +1,235 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#ifndef QDBUSTHREADDEBUG_P_H +#define QDBUSTHREADDEBUG_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtCore/qglobal.h> + +#ifndef QT_NO_DBUS + +#if !defined(QDBUS_THREAD_DEBUG) && defined(QT_BUILD_INTERNAL) +# define QDBUS_THREAD_DEBUG 1 +#endif + +#if QDBUS_THREAD_DEBUG +QT_BEGIN_NAMESPACE +typedef void (*qdbusThreadDebugFunc)(int, int, QDBusConnectionPrivate *); +Q_DBUS_EXPORT void qdbusDefaultThreadDebug(int, int, QDBusConnectionPrivate *); +extern Q_DBUS_EXPORT qdbusThreadDebugFunc qdbusThreadDebug; +QT_END_NAMESPACE +#endif + +enum ThreadAction { + ConnectAction = 0, + DisconnectAction = 1, + RegisterObjectAction = 2, + UnregisterObjectAction = 3, + ObjectRegisteredAtAction = 4, + + CloseConnectionAction = 10, + ObjectDestroyedAction = 11, + RelaySignalAction = 12, + HandleObjectCallAction = 13, + HandleSignalAction = 14, + ConnectRelayAction = 15, + DisconnectRelayAction = 16, + FindMetaObject1Action = 17, + FindMetaObject2Action = 18, + RegisterServiceAction = 19, + UnregisterServiceAction = 20, + UpdateSignalHookOwnerAction = 21, + HandleObjectCallPostEventAction = 22, + HandleObjectCallSemaphoreAction = 23, + DoDispatchAction = 24, + SendWithReplyAsyncAction = 25, + MessageResultReceivedAction = 26, + ActivateSignalAction = 27, + PendingCallBlockAction = 28, + + AddTimeoutAction = 50, + RealAddTimeoutAction = 51, + RemoveTimeoutAction = 52, + KillTimerAction = 58, + TimerEventAction = 59, + AddWatchAction = 60, + RemoveWatchAction = 61, + ToggleWatchAction = 62, + SocketReadAction = 63, + SocketWriteAction = 64 +}; + +struct QDBusLockerBase +{ + enum Condition + { + BeforeLock, + AfterLock, + BeforeUnlock, + AfterUnlock, + + BeforePost, + AfterPost, + BeforeDeliver, + AfterDeliver, + + BeforeAcquire, + AfterAcquire, + BeforeRelease, + AfterRelease + }; + +#if QDBUS_THREAD_DEBUG + static inline void reportThreadAction(int action, int condition, QDBusConnectionPrivate *ptr) + { if (qdbusThreadDebug) qdbusThreadDebug(action, condition, ptr); } +#else + static inline void reportThreadAction(int, int, QDBusConnectionPrivate *) { } +#endif +}; + +struct QDBusReadLocker: QDBusLockerBase +{ + QDBusConnectionPrivate *self; + ThreadAction action; + inline QDBusReadLocker(ThreadAction a, QDBusConnectionPrivate *s) + : self(s), action(a) + { + reportThreadAction(action, BeforeLock, self); + self->lock.lockForRead(); + reportThreadAction(action, AfterLock, self); + } + + inline ~QDBusReadLocker() + { + reportThreadAction(action, BeforeUnlock, self); + self->lock.unlock(); + reportThreadAction(action, AfterUnlock, self); + } +}; + +struct QDBusWriteLocker: QDBusLockerBase +{ + QDBusConnectionPrivate *self; + ThreadAction action; + inline QDBusWriteLocker(ThreadAction a, QDBusConnectionPrivate *s) + : self(s), action(a) + { + reportThreadAction(action, BeforeLock, self); + self->lock.lockForWrite(); + reportThreadAction(action, AfterLock, self); + } + + inline ~QDBusWriteLocker() + { + reportThreadAction(action, BeforeUnlock, self); + self->lock.unlock(); + reportThreadAction(action, AfterUnlock, self); + } +}; + +struct QDBusMutexLocker: QDBusLockerBase +{ + QDBusConnectionPrivate *self; + QMutex *mutex; + ThreadAction action; + inline QDBusMutexLocker(ThreadAction a, QDBusConnectionPrivate *s, + QMutex *m) + : self(s), mutex(m), action(a) + { + reportThreadAction(action, BeforeLock, self); + mutex->lock(); + reportThreadAction(action, AfterLock, self); + } + + inline ~QDBusMutexLocker() + { + reportThreadAction(action, BeforeUnlock, self); + mutex->unlock(); + reportThreadAction(action, AfterUnlock, self); + } +}; + +struct QDBusDispatchLocker: QDBusMutexLocker +{ + inline QDBusDispatchLocker(ThreadAction a, QDBusConnectionPrivate *s) + : QDBusMutexLocker(a, s, &s->dispatchLock) + { } +}; + +struct QDBusWatchAndTimeoutLocker: QDBusMutexLocker +{ + inline QDBusWatchAndTimeoutLocker(ThreadAction a, QDBusConnectionPrivate *s) + : QDBusMutexLocker(a, s, &s->watchAndTimeoutLock) + { } +}; + +#if QDBUS_THREAD_DEBUG +# define SEM_ACQUIRE(action, sem) \ + do { \ + QDBusLockerBase::reportThreadAction(action, QDBusLockerBase::BeforeAcquire, this); \ + sem.acquire(); \ + QDBusLockerBase::reportThreadAction(action, QDBusLockerBase::AfterAcquire, this); \ + } while (0) + +# define SEM_RELEASE(action, sem) \ + do { \ + QDBusLockerBase::reportThreadAction(action, QDBusLockerBase::BeforeRelease, that); \ + sem.release(); \ + QDBusLockerBase::reportThreadAction(action, QDBusLockerBase::AfterRelease, that); \ + } while (0) + +#else +# define SEM_ACQUIRE(action, sem) sem.acquire() +# define SEM_RELEASE(action, sem) sem.release() +#endif + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusunixfiledescriptor.cpp b/src/dbus/qdbusunixfiledescriptor.cpp new file mode 100644 index 0000000000..f45b6cc2ec --- /dev/null +++ b/src/dbus/qdbusunixfiledescriptor.cpp @@ -0,0 +1,316 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include "qdbusunixfiledescriptor.h" +#include <QSharedData> + +#ifdef Q_OS_UNIX +# include <private/qcore_unix_p.h> +#endif + +QT_BEGIN_NAMESPACE + +/*! + \class QDBusUnixFileDescriptor + \inmodule QtDBus + \since 4.8 + + \brief The QDBusUnixFileDescriptor class holds one Unix file descriptor. + + The QDBusUnixFileDescriptor class is used to hold one Unix file + descriptor for use with the QtDBus module. This allows applications to + send and receive Unix file descriptors over the D-Bus connection, mapping + automatically to the D-Bus type 'h'. + + Objects of type QDBusUnixFileDescriptors can be used also as parameters + in signals and slots that get exported to D-Bus by registering with + QDBusConnection::registerObject. + + QDBusUnixFileDescriptor does not take ownership of the file descriptor. + Instead, it will use the Unix system call \c dup(2) to make a copy of the + file descriptor. This file descriptor belongs to the + QDBusUnixFileDescriptor object and should not be stored or closed by the + user. Instead, you should make your own copy if you need that. + + \section2 Availability + + Unix file descriptor passing is not available in all D-Bus connections. + This feature is present with D-Bus library and bus daemon version 1.4 and + upwards on Unix systems. QtDBus automatically enables the feature if such + a version was found at compile-time and run-time. + + To verify that your connection does support passing file descriptors, + check if the QDBusConnection::UnixFileDescriptorPassing capability is set + with QDBusConnection::connectionCapabilities(). If the flag is not + active, then you will not be able to make calls to methods that have + QDBusUnixFileDescriptor as arguments or even embed such a type in a + variant. You will also not receive calls containing that type. + + Note also that remote applications may not have support for Unix file + descriptor passing. If you make a D-Bus to a remote application that + cannot receive such a type, you will receive an error reply. If you try + to send a signal containing a D-Bus file descriptor or return one from a + method call, the message will be silently dropped. + + Even if the feature is not available, QDBusUnixFileDescriptor will + continue to operate, so code need not have compile-time checks for the + availability of this feature. + + On non-Unix systems, QDBusUnixFileDescriptor will always report an + invalid state and QDBusUnixFileDescriptor::isSupported() will return + false. + + \sa QDBusConnection::ConnectionCapabilities, QDBusConnection::connectionCapabilities +*/ + +class QDBusUnixFileDescriptorPrivate : public QSharedData { +public: + QDBusUnixFileDescriptorPrivate() : fd(-1) { } + QDBusUnixFileDescriptorPrivate(const QDBusUnixFileDescriptorPrivate &other) + : QSharedData(other), fd(-1) + { } + ~QDBusUnixFileDescriptorPrivate(); + + QAtomicInt fd; +}; + +template<> inline +QExplicitlySharedDataPointer<QDBusUnixFileDescriptorPrivate>::~QExplicitlySharedDataPointer() +{ if (d && !d->ref.deref()) delete d; } + +/*! + Constructs a QDBusUnixFileDescriptor without a wrapped file descriptor. + This is equivalent to constructing the object with an invalid file + descriptor (like -1). + + \sa fileDescriptor, isValid +*/ +QDBusUnixFileDescriptor::QDBusUnixFileDescriptor() + : d(0) +{ +} + +/*! + Constructs a QDBusUnixFileDescriptor object by copying the \a + fileDescriptor parameter. The original file descriptor is not touched and + must be closed by the user. + + Note that the value returned by fileDescriptor() will be different from + the \a fileDescriptor parameter passed. + + If the \a fileDescriptor parameter is not valid, isValid() will return + false and fileDescriptor() will return -1. + + \sa setFileDescriptor, fileDescriptor +*/ +QDBusUnixFileDescriptor::QDBusUnixFileDescriptor(int fileDescriptor) + : d(0) +{ + if (fileDescriptor != -1) + setFileDescriptor(fileDescriptor); +} + +/*! + Constructs a QDBusUnixFileDescriptor object by copying \a other. +*/ +QDBusUnixFileDescriptor::QDBusUnixFileDescriptor(const QDBusUnixFileDescriptor &other) + : d(other.d) +{ +} + +/*! + Copies the Unix file descriptor from the \a other QDBusUnixFileDescriptor + object. If the current object contained a file descriptor, it will be + properly disposed of before. +*/ +QDBusUnixFileDescriptor &QDBusUnixFileDescriptor::operator=(const QDBusUnixFileDescriptor &other) +{ + if (this != &other) + d.operator=(other.d); + return *this; +} + +/*! + Destroys this QDBusUnixFileDescriptor object and disposes of the Unix file descriptor that it contained. +*/ +QDBusUnixFileDescriptor::~QDBusUnixFileDescriptor() +{ +} + +/*! + Returns true if this Unix file descriptor is valid. A valid Unix file + descriptor is not -1. + + \sa fileDescriptor() +*/ +bool QDBusUnixFileDescriptor::isValid() const +{ + return d ? d->fd != -1 : false; +} + +/*! + Returns the Unix file descriptor contained by this + QDBusUnixFileDescriptor object. An invalid file descriptor is represented + by the value -1. + + Note that the file descriptor returned by this function is owned by the + QDBusUnixFileDescriptor object and must not be stored past the lifetime + of this object. It is ok to use it while this object is valid, but if one + wants to store it for longer use, the file descriptor should be cloned + using the Unix \c dup(2), \c dup2(2) or \c dup3(2) functions. + + \sa isValid() +*/ +int QDBusUnixFileDescriptor::fileDescriptor() const +{ + return d ? d->fd.operator int() : -1; +} + +// actual implementation +#ifdef Q_OS_UNIX + +// qdoc documentation is generated on Unix + +/*! + Returns true if Unix file descriptors are supported on this platform. In + other words, this function returns true if this is a Unix platform. + + Note that QDBusUnixFileDescriptor continues to operate even if this + function returns false. The only difference is that the + QDBusUnixFileDescriptor objects will always be in the isValid() == false + state and fileDescriptor() will always return -1. The class will not + consume any operating system resources. +*/ +bool QDBusUnixFileDescriptor::isSupported() +{ + return true; +} + +/*! + Sets the file descriptor that this QDBusUnixFileDescriptor object holds + to a copy of \a fileDescriptor.T he original file descriptor is not + touched and must be closed by the user. + + Note that the value returned by fileDescriptor() will be different from + the \a fileDescriptor parameter passed. + + If the \a fileDescriptor parameter is not valid, isValid() will return + false and fileDescriptor() will return -1. + + \sa isValid(), fileDescriptor() +*/ +void QDBusUnixFileDescriptor::setFileDescriptor(int fileDescriptor) +{ + if (fileDescriptor != -1) + giveFileDescriptor(qt_safe_dup(fileDescriptor)); +} + +/*! + \internal + Sets the Unix file descriptor to \a fileDescriptor without copying. + + \sa setFileDescriptor() +*/ +void QDBusUnixFileDescriptor::giveFileDescriptor(int fileDescriptor) +{ + // if we are the sole ref, d remains unchanged + // if detaching happens, d->fd will be -1 + if (d) + d.detach(); + else + d = new QDBusUnixFileDescriptorPrivate; + + if (d->fd != -1) + qt_safe_close(d->fd); + + if (fileDescriptor != -1) + d->fd = fileDescriptor; +} + +/*! + \internal + Extracts the Unix file descriptor from the QDBusUnixFileDescriptor object + and transfers ownership. + + Note: since QDBusUnixFileDescriptor is implicitly shared, this function + is inherently racy and should be avoided. +*/ +int QDBusUnixFileDescriptor::takeFileDescriptor() +{ + if (!d) + return -1; + + return d->fd.fetchAndStoreRelaxed(-1); +} + +QDBusUnixFileDescriptorPrivate::~QDBusUnixFileDescriptorPrivate() +{ + if (fd != -1) + qt_safe_close(fd); +} + +#else +bool QDBusUnixFileDescriptor::isSupported() +{ + return false; +} + +void QDBusUnixFileDescriptor::setFileDescriptor(int) +{ +} + +void QDBusUnixFileDescriptor::giveFileDescriptor(int) +{ +} + +int QDBusUnixFileDescriptor::takeFileDescriptor() +{ + return -1; +} + +QDBusUnixFileDescriptorPrivate::~QDBusUnixFileDescriptorPrivate() +{ +} + +#endif + +QT_END_NAMESPACE diff --git a/src/dbus/qdbusunixfiledescriptor.h b/src/dbus/qdbusunixfiledescriptor.h new file mode 100644 index 0000000000..d0a2f3c174 --- /dev/null +++ b/src/dbus/qdbusunixfiledescriptor.h @@ -0,0 +1,103 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#ifndef QDBUSUNIXFILEDESCRIPTOR_H +#define QDBUSUNIXFILEDESCRIPTOR_H + +#include <QtCore/QSharedDataPointer> +#include <QtDBus/qdbusmacros.h> + +#ifndef QT_NO_DBUS + +#ifdef Q_COMPILER_RVALUE_REFS +# include <utility> +#endif + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(DBus) + +class QDBusUnixFileDescriptorPrivate; +template<> QExplicitlySharedDataPointer<QDBusUnixFileDescriptorPrivate>::~QExplicitlySharedDataPointer(); + +class Q_DBUS_EXPORT QDBusUnixFileDescriptor +{ +public: + QDBusUnixFileDescriptor(); + explicit QDBusUnixFileDescriptor(int fileDescriptor); + QDBusUnixFileDescriptor(const QDBusUnixFileDescriptor &other); + QDBusUnixFileDescriptor &operator=(const QDBusUnixFileDescriptor &other); + ~QDBusUnixFileDescriptor(); + + bool isValid() const; + + int fileDescriptor() const; + void setFileDescriptor(int fileDescriptor); + + void giveFileDescriptor(int fileDescriptor); + int takeFileDescriptor(); + + static bool isSupported(); + +#if defined(Q_COMPILER_RVALUE_REFS) + QDBusUnixFileDescriptor(QDBusUnixFileDescriptor &&other) : d(static_cast<Data &&>(other.d)) + { } + inline QDBusUnixFileDescriptor &operator=(QDBusUnixFileDescriptor &&other) + { d.swap(other.d); return *this; } +#endif + +protected: + typedef QExplicitlySharedDataPointer<QDBusUnixFileDescriptorPrivate> Data; + Data d; +}; + +QT_END_NAMESPACE + +Q_DECLARE_METATYPE(QDBusUnixFileDescriptor) +Q_DECLARE_METATYPE(QList<QDBusUnixFileDescriptor>) + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif // QDBUSUNIXFILEDESCRIPTOR_H diff --git a/src/dbus/qdbusutil.cpp b/src/dbus/qdbusutil.cpp new file mode 100644 index 0000000000..a4bd16864e --- /dev/null +++ b/src/dbus/qdbusutil.cpp @@ -0,0 +1,568 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusutil_p.h" + +#include "qdbus_symbols_p.h" + +#include <QtCore/qstringlist.h> + +#include "qdbusargument.h" +#include "qdbusunixfiledescriptor.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +static inline bool isValidCharacterNoDash(const QChar &c) +{ + register ushort u = c.unicode(); + return (u >= 'a' && u <= 'z') + || (u >= 'A' && u <= 'Z') + || (u >= '0' && u <= '9') + || (u == '_'); +} + +static inline bool isValidCharacter(const QChar &c) +{ + register ushort u = c.unicode(); + return (u >= 'a' && u <= 'z') + || (u >= 'A' && u <= 'Z') + || (u >= '0' && u <= '9') + || (u == '_') || (u == '-'); +} + +static inline bool isValidNumber(const QChar &c) +{ + register ushort u = c.unicode(); + return (u >= '0' && u <= '9'); +} + +static bool argToString(const QDBusArgument &arg, QString &out); + +static bool variantToString(const QVariant &arg, QString &out) +{ + int argType = arg.userType(); + + if (argType == QVariant::StringList) { + out += QLatin1Char('{'); + QStringList list = arg.toStringList(); + foreach (QString item, list) + out += QLatin1Char('\"') + item + QLatin1String("\", "); + if (!list.isEmpty()) + out.chop(2); + out += QLatin1Char('}'); + } else if (argType == QVariant::ByteArray) { + out += QLatin1Char('{'); + QByteArray list = arg.toByteArray(); + for (int i = 0; i < list.count(); ++i) { + out += QString::number(list.at(i)); + out += QLatin1String(", "); + } + if (!list.isEmpty()) + out.chop(2); + out += QLatin1Char('}'); + } else if (argType == QVariant::List) { + out += QLatin1Char('{'); + QList<QVariant> list = arg.toList(); + foreach (QVariant item, list) { + if (!variantToString(item, out)) + return false; + out += QLatin1String(", "); + } + if (!list.isEmpty()) + out.chop(2); + out += QLatin1Char('}'); + } else if (argType == QMetaType::Char || argType == QMetaType::Short || argType == QMetaType::Int + || argType == QMetaType::Long || argType == QMetaType::LongLong) { + out += QString::number(arg.toLongLong()); + } else if (argType == QMetaType::UChar || argType == QMetaType::UShort || argType == QMetaType::UInt + || argType == QMetaType::ULong || argType == QMetaType::ULongLong) { + out += QString::number(arg.toULongLong()); + } else if (argType == QMetaType::Double) { + out += QString::number(arg.toDouble()); + } else if (argType == QMetaType::Bool) { + out += QLatin1String(arg.toBool() ? "true" : "false"); + } else if (argType == qMetaTypeId<QDBusArgument>()) { + argToString(qvariant_cast<QDBusArgument>(arg), out); + } else if (argType == qMetaTypeId<QDBusObjectPath>()) { + const QString path = qvariant_cast<QDBusObjectPath>(arg).path(); + out += QLatin1String("[ObjectPath: "); + out += path; + out += QLatin1Char(']'); + } else if (argType == qMetaTypeId<QDBusSignature>()) { + out += QLatin1String("[Signature: ") + qvariant_cast<QDBusSignature>(arg).signature(); + out += QLatin1Char(']'); + } else if (argType == qMetaTypeId<QDBusUnixFileDescriptor>()) { + out += QLatin1String("[Unix FD: "); + out += QLatin1String(qvariant_cast<QDBusUnixFileDescriptor>(arg).isValid() ? "valid" : "not valid"); + out += QLatin1Char(']'); + } else if (argType == qMetaTypeId<QDBusVariant>()) { + const QVariant v = qvariant_cast<QDBusVariant>(arg).variant(); + out += QLatin1String("[Variant"); + int vUserType = v.userType(); + if (vUserType != qMetaTypeId<QDBusVariant>() + && vUserType != qMetaTypeId<QDBusSignature>() + && vUserType != qMetaTypeId<QDBusObjectPath>() + && vUserType != qMetaTypeId<QDBusArgument>()) + out += QLatin1Char('(') + QLatin1String(v.typeName()) + QLatin1Char(')'); + out += QLatin1String(": "); + if (!variantToString(v, out)) + return false; + out += QLatin1Char(']'); + } else if (arg.canConvert(QVariant::String)) { + out += QLatin1Char('\"') + arg.toString() + QLatin1Char('\"'); + } else { + out += QLatin1Char('['); + out += QLatin1String(arg.typeName()); + out += QLatin1Char(']'); + } + + return true; +} + +bool argToString(const QDBusArgument &busArg, QString &out) +{ + QString busSig = busArg.currentSignature(); + bool doIterate = false; + QDBusArgument::ElementType elementType = busArg.currentType(); + + if (elementType != QDBusArgument::BasicType && elementType != QDBusArgument::VariantType + && elementType != QDBusArgument::MapEntryType) + out += QLatin1String("[Argument: ") + busSig + QLatin1Char(' '); + + switch (elementType) { + case QDBusArgument::BasicType: + case QDBusArgument::VariantType: + if (!variantToString(busArg.asVariant(), out)) + return false; + break; + case QDBusArgument::StructureType: + busArg.beginStructure(); + doIterate = true; + break; + case QDBusArgument::ArrayType: + busArg.beginArray(); + out += QLatin1Char('{'); + doIterate = true; + break; + case QDBusArgument::MapType: + busArg.beginMap(); + out += QLatin1Char('{'); + doIterate = true; + break; + case QDBusArgument::MapEntryType: + busArg.beginMapEntry(); + if (!variantToString(busArg.asVariant(), out)) + return false; + out += QLatin1String(" = "); + if (!argToString(busArg, out)) + return false; + busArg.endMapEntry(); + break; + case QDBusArgument::UnknownType: + default: + out += QLatin1String("<ERROR - Unknown Type>"); + return false; + } + if (doIterate && !busArg.atEnd()) { + while (!busArg.atEnd()) { + if (!argToString(busArg, out)) + return false; + out += QLatin1String(", "); + } + out.chop(2); + } + switch (elementType) { + case QDBusArgument::BasicType: + case QDBusArgument::VariantType: + case QDBusArgument::UnknownType: + case QDBusArgument::MapEntryType: + // nothing to do + break; + case QDBusArgument::StructureType: + busArg.endStructure(); + break; + case QDBusArgument::ArrayType: + out += QLatin1Char('}'); + busArg.endArray(); + break; + case QDBusArgument::MapType: + out += QLatin1Char('}'); + busArg.endMap(); + break; + } + + if (elementType != QDBusArgument::BasicType && elementType != QDBusArgument::VariantType + && elementType != QDBusArgument::MapEntryType) + out += QLatin1Char(']'); + + return true; +} + +//------- D-Bus Types -------- +static const char oneLetterTypes[] = "vsogybnqiuxtdh"; +static const char basicTypes[] = "sogybnqiuxtdh"; +static const char fixedTypes[] = "ybnqiuxtdh"; + +static bool isBasicType(int c) +{ + return c != DBUS_TYPE_INVALID && strchr(basicTypes, c) != NULL; +} + +static bool isFixedType(int c) +{ + return c != DBUS_TYPE_INVALID && strchr(fixedTypes, c) != NULL; +} + +// Returns a pointer to one-past-end of this type if it's valid; +// returns NULL if it isn't valid. +static const char *validateSingleType(const char *signature) +{ + register char c = *signature; + if (c == DBUS_TYPE_INVALID) + return false; + + // is it one of the one-letter types? + if (strchr(oneLetterTypes, c) != NULL) + return signature + 1; + + // is it an array? + if (c == DBUS_TYPE_ARRAY) { + // then it's valid if the next type is valid + // or if it's a dict-entry + c = *++signature; + if (c == DBUS_DICT_ENTRY_BEGIN_CHAR) { + // beginning of a dictionary entry + // a dictionary entry has a key which is of basic types + // and a free value + c = *++signature; + if (!isBasicType(c)) + return 0; + signature = validateSingleType(signature + 1); + return signature && *signature == DBUS_DICT_ENTRY_END_CHAR ? signature + 1 : 0; + } + + return validateSingleType(signature); + } + + if (c == DBUS_STRUCT_BEGIN_CHAR) { + // beginning of a struct + ++signature; + while (true) { + signature = validateSingleType(signature); + if (!signature) + return 0; + if (*signature == DBUS_STRUCT_END_CHAR) + return signature + 1; + } + } + + // invalid/unknown type + return 0; +} + +/*! + \namespace QDBusUtil + \inmodule QtDBus + \internal + + \brief The QDBusUtil namespace contains a few functions that are of general use when + dealing with D-Bus strings. +*/ +namespace QDBusUtil +{ + /*! + \internal + \since 4.5 + Dumps the contents of a QtDBus argument from \a arg into a string. + */ + QString argumentToString(const QVariant &arg) + { + QString out; + + variantToString(arg, out); + + return out; + } + + /*! + \internal + \fn bool QDBusUtil::isValidPartOfObjectPath(const QString &part) + See QDBusUtil::isValidObjectPath + */ + bool isValidPartOfObjectPath(const QString &part) + { + if (part.isEmpty()) + return false; // can't be valid if it's empty + + const QChar *c = part.unicode(); + for (int i = 0; i < part.length(); ++i) + if (!isValidCharacterNoDash(c[i])) + return false; + + return true; + } + + /*! + \fn bool 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 + + for (int i = 0; i < parts.count(); ++i) + if (!isValidMemberName(parts.at(i))) + return false; + + return true; + } + + /*! + \fn bool 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 hyphen 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; + + for (int i = 0; i < parts.count(); ++i) { + const QString &part = parts.at(i); + if (part.isEmpty()) + return false; + + const QChar* c = part.unicode(); + for (int j = 0; j < part.length(); ++j) + if (!isValidCharacter(c[j])) + return false; + } + + return true; + } + + /*! + \fn bool 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; + + for (int i = 0; i < parts.count(); ++i) { + const QString &part = parts.at(i); + if (part.isEmpty()) + return false; + + const QChar *c = part.unicode(); + if (isValidNumber(c[0])) + return false; + for (int j = 0; j < part.length(); ++j) + if (!isValidCharacter(c[j])) + return false; + } + + return true; + } + + /*! + \fn bool 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; + + const QChar* c = memberName.unicode(); + if (isValidNumber(c[0])) + return false; + for (int j = 0; j < memberName.length(); ++j) + if (!isValidCharacterNoDash(c[j])) + return false; + return true; + } + + /*! + \fn bool 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 bool 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 + + for (int i = 0; i < parts.count(); ++i) + if (!isValidPartOfObjectPath(parts.at(i))) + return false; + + return true; + } + + /*! + \fn bool QDBusUtil::isValidBasicType(int type) + Returns true if \a c is a valid, basic D-Bus type. + */ + bool isValidBasicType(int c) + { + return isBasicType(c); + } + + /*! + \fn bool QDBusUtil::isValidFixedType(int type) + Returns true if \a c is a valid, fixed D-Bus type. + */ + bool isValidFixedType(int c) + { + return isFixedType(c); + } + + + /*! + \fn bool 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) + { + QByteArray ba = signature.toLatin1(); + const char *data = ba.constData(); + while (true) { + data = validateSingleType(data); + if (!data) + return false; + if (*data == '\0') + return true; + } + } + + /*! + \fn bool 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) + { + QByteArray ba = signature.toLatin1(); + const char *data = validateSingleType(ba.constData()); + return data && *data == '\0'; + } + +} // namespace QDBusUtil + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusutil_p.h b/src/dbus/qdbusutil_p.h new file mode 100644 index 0000000000..24b5cea847 --- /dev/null +++ b/src/dbus/qdbusutil_p.h @@ -0,0 +1,167 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of the QLibrary class. This header file may change from +// version to version without notice, or even be removed. +// +// We mean it. +// + +#ifndef QDBUSUTIL_H +#define QDBUSUTIL_H + +#include <QtCore/qstring.h> +#include <QtCore/qvariant.h> + +#include <QtDBus/qdbusmacros.h> +#include <QtDBus/qdbuserror.h> + +#ifndef QT_NO_DBUS + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +namespace QDBusUtil +{ + Q_DBUS_EXPORT bool isValidInterfaceName(const QString &ifaceName); + + Q_DBUS_EXPORT bool isValidUniqueConnectionName(const QString &busName); + + Q_DBUS_EXPORT bool isValidBusName(const QString &busName); + + Q_DBUS_EXPORT bool isValidMemberName(const QString &memberName); + + Q_DBUS_EXPORT bool isValidErrorName(const QString &errorName); + + Q_DBUS_EXPORT bool isValidPartOfObjectPath(const QString &path); + + Q_DBUS_EXPORT bool isValidObjectPath(const QString &path); + + Q_DBUS_EXPORT bool isValidFixedType(int c); + + Q_DBUS_EXPORT bool isValidBasicType(int c); + + Q_DBUS_EXPORT bool isValidSignature(const QString &signature); + + Q_DBUS_EXPORT bool isValidSingleSignature(const QString &signature); + + Q_DBUS_EXPORT QString argumentToString(const QVariant &variant); + + enum AllowEmptyFlag { + EmptyAllowed, + EmptyNotAllowed + }; + + inline bool checkInterfaceName(const QString &name, AllowEmptyFlag empty, QDBusError *error) + { + if (name.isEmpty()) { + if (empty == EmptyAllowed) return true; + *error = QDBusError(QDBusError::InvalidInterface, QLatin1String("Interface name cannot be empty")); + return false; + } + if (isValidInterfaceName(name)) return true; + *error = QDBusError(QDBusError::InvalidInterface, QString::fromLatin1("Invalid interface class: %1").arg(name)); + return false; + } + + inline bool checkBusName(const QString &name, AllowEmptyFlag empty, QDBusError *error) + { + if (name.isEmpty()) { + if (empty == EmptyAllowed) return true; + *error = QDBusError(QDBusError::InvalidService, QLatin1String("Service name cannot be empty")); + return false; + } + if (isValidBusName(name)) return true; + *error = QDBusError(QDBusError::InvalidService, QString::fromLatin1("Invalid service name: %1").arg(name)); + return false; + } + + inline bool checkObjectPath(const QString &path, AllowEmptyFlag empty, QDBusError *error) + { + if (path.isEmpty()) { + if (empty == EmptyAllowed) return true; + *error = QDBusError(QDBusError::InvalidObjectPath, QLatin1String("Object path cannot be empty")); + return false; + } + if (isValidObjectPath(path)) return true; + *error = QDBusError(QDBusError::InvalidObjectPath, QString::fromLatin1("Invalid object path: %1").arg(path)); + return false; + } + + inline bool checkMemberName(const QString &name, AllowEmptyFlag empty, QDBusError *error, const char *nameType = 0) + { + if (!nameType) nameType = "member"; + if (name.isEmpty()) { + if (empty == EmptyAllowed) return true; + *error = QDBusError(QDBusError::InvalidMember, QLatin1String(nameType) + QLatin1String(" name cannot be empty")); + return false; + } + if (isValidMemberName(name)) return true; + *error = QDBusError(QDBusError::InvalidMember, QString::fromLatin1("Invalid %1 name: %2") + .arg(QString::fromLatin1(nameType), name)); + return false; + } + + inline bool checkErrorName(const QString &name, AllowEmptyFlag empty, QDBusError *error) + { + if (name.isEmpty()) { + if (empty == EmptyAllowed) return true; + *error = QDBusError(QDBusError::InvalidInterface, QLatin1String("Error name cannot be empty")); + return false; + } + if (isValidErrorName(name)) return true; + *error = QDBusError(QDBusError::InvalidInterface, QString::fromLatin1("Invalid error name: %1").arg(name)); + return false; + } +} + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QT_NO_DBUS +#endif diff --git a/src/dbus/qdbusxmlgenerator.cpp b/src/dbus/qdbusxmlgenerator.cpp new file mode 100644 index 0000000000..930290c653 --- /dev/null +++ b/src/dbus/qdbusxmlgenerator.cpp @@ -0,0 +1,308 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#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 "qdbusmetatype_p.h" +#include "qdbusmetatype.h" +#include "qdbusutil_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +extern Q_DBUS_EXPORT QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo, + const QMetaObject *base, int flags); + +static inline QString typeNameToXml(const char *typeName) +{ + // ### copied from qtextdocument.cpp + // ### move this into QtCore at some point + QString plain = QLatin1String(typeName); + QString rich; + rich.reserve(int(plain.length() * 1.1)); + for (int i = 0; i < plain.length(); ++i) { + if (plain.at(i) == QLatin1Char('<')) + rich += QLatin1String("<"); + else if (plain.at(i) == QLatin1Char('>')) + rich += QLatin1String(">"); + else if (plain.at(i) == QLatin1Char('&')) + rich += QLatin1String("&"); + else + rich += plain.at(i); + } + return rich; +} + +// 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::ExportScriptableProperties | + QDBusConnection::ExportNonScriptableProperties)) { + 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::ExportScriptableProperties)) || + (!mp.isScriptable() && (flags & QDBusConnection::ExportNonScriptableProperties)))) + continue; + + int access = 0; + if (mp.isReadable()) + access |= 1; + if (mp.isWritable()) + access |= 2; + + int typeId = qDBusNameToTypeId(mp.typeName()); + if (!typeId) + continue; + const char *signature = QDBusMetaType::typeToSignature(typeId); + if (!signature) + continue; + + retval += QString::fromLatin1(" <property name=\"%1\" type=\"%2\" access=\"%3\"") + .arg(QLatin1String(mp.name())) + .arg(QLatin1String(signature)) + .arg(QLatin1String(accessvalues[access])); + + if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) { + const char *typeName = QVariant::typeToName(QVariant::Type(typeId)); + retval += QString::fromLatin1(">\n <annotation name=\"com.trolltech.QtDBus.QtTypeName\" value=\"%3\"/>\n </property>\n") + .arg(typeNameToXml(typeName)); + } else { + retval += QLatin1String("/>\n"); + } + } + } + + // 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.access() == QMetaMethod::Public && (mm.methodType() == QMetaMethod::Slot || mm.methodType() == QMetaMethod::Method)) + isSignal = false; + else + continue; // neither signal nor public slot + + if (isSignal && !(flags & (QDBusConnection::ExportScriptableSignals | + QDBusConnection::ExportNonScriptableSignals))) + continue; // we're not exporting any signals + if (!isSignal && (!(flags & (QDBusConnection::ExportScriptableSlots | QDBusConnection::ExportNonScriptableSlots)) && + !(flags & (QDBusConnection::ExportScriptableInvokables | QDBusConnection::ExportNonScriptableInvokables)))) + continue; // we're not exporting any slots or invokables + + QString xml = QString::fromLatin1(" <%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) { + const char *typeName = QDBusMetaType::typeToSignature(typeId); + if (typeName) { + xml += QString::fromLatin1(" <arg type=\"%1\" direction=\"out\"/>\n") + .arg(typeNameToXml(typeName)); + + // do we need to describe this argument? + if (QDBusMetaType::signatureToType(typeName) == QVariant::Invalid) + xml += QString::fromLatin1(" <annotation name=\"com.trolltech.QtDBus.QtTypeName.Out0\" value=\"%1\"/>\n") + .arg(typeNameToXml(QVariant::typeToName(QVariant::Type(typeId)))); + } else + continue; + } + 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) == QDBusMetaTypeId::message) + continue; // signal with QDBusMessage argument? + if (isSignal && mm.attributes() & QMetaMethod::Cloned) + continue; // cloned signal? + + 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) == QDBusMetaTypeId::message) { + isScriptable = true; + continue; + } + + QString name; + if (!names.at(j - 1).isEmpty()) + name = QString::fromLatin1("name=\"%1\" ").arg(QLatin1String(names.at(j - 1))); + + bool isOutput = isSignal || j > inputCount; + + const char *signature = QDBusMetaType::typeToSignature(types.at(j)); + xml += QString::fromLatin1(" <arg %1type=\"%2\" direction=\"%3\"/>\n") + .arg(name) + .arg(QLatin1String(signature)) + .arg(isOutput ? QLatin1String("out") : QLatin1String("in")); + + // do we need to describe this argument? + if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) { + const char *typeName = QVariant::typeToName( QVariant::Type(types.at(j)) ); + xml += QString::fromLatin1(" <annotation name=\"com.trolltech.QtDBus.QtTypeName.%1%2\" value=\"%3\"/>\n") + .arg(isOutput ? QLatin1String("Out") : QLatin1String("In")) + .arg(isOutput && !isSignal ? j - inputCount : j - 1) + .arg(typeNameToXml(typeName)); + } + } + + int wantedMask; + if (isScriptable) + wantedMask = isSignal ? QDBusConnection::ExportScriptableSignals + : QDBusConnection::ExportScriptableSlots; + else + wantedMask = isSignal ? QDBusConnection::ExportNonScriptableSignals + : QDBusConnection::ExportNonScriptableSlots; + if ((flags & wantedMask) != wantedMask) + continue; + + if (qDBusCheckAsyncTag(mm.tag())) + // add the no-reply annotation + xml += QLatin1String(" <annotation name=\"" ANNOTATION_NO_WAIT "\"" + " value=\"true\"/>\n"); + + retval += xml; + retval += QString::fromLatin1(" </%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 + interface = qDBusInterfaceFromMetaObject(mo); + + 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::fromLatin1(" <interface name=\"%1\">\n%2 </interface>\n") + .arg(interface, xml); +} +#if 0 +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')) && + interface.length() >= 2 && interface.at(1).isUpper()) { + // 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('.'), + QString::SkipEmptyParts); + if (domainName.isEmpty()) + interface.prepend(QLatin1String("local.")); + else + for (int i = 0; i < domainName.count(); ++i) + interface.prepend(QLatin1Char('.')).prepend(domainName.at(i)); + } + } + } + + 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::fromLatin1(" <interface name=\"%1\">\n%2 </interface>\n") + .arg(interface, xml); +} + +#endif + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusxmlparser.cpp b/src/dbus/qdbusxmlparser.cpp new file mode 100644 index 0000000000..3feeddec5a --- /dev/null +++ b/src/dbus/qdbusxmlparser.cpp @@ -0,0 +1,378 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdbusxmlparser_p.h" +#include "qdbusinterface.h" +#include "qdbusinterface_p.h" +#include "qdbusconnection_p.h" +#include "qdbusutil_p.h" + +#include <QtXml/qdom.h> +#include <QtCore/qmap.h> +#include <QtCore/qvariant.h> +#include <QtCore/qtextstream.h> + +#ifndef QT_NO_DBUS + +//#define QDBUS_PARSER_DEBUG +#ifdef QDBUS_PARSER_DEBUG +# define qDBusParserError qWarning +#else +# define qDBusParserError if (true) {} else qDebug +#endif + +QT_BEGIN_NAMESPACE + +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 (!QDBusUtil::isValidInterfaceName(name)) { + qDBusParserError("Invalid D-BUS annotation '%s' found while parsing introspection", + qPrintable(name)); + continue; + } + + retval.insert(name, value); + } + + return retval; +} + +static QDBusIntrospection::Arguments +parseArgs(const QDomElement& elem, const QLatin1String& direction, bool acceptEmpty) +{ + 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)) { + qDBusParserError("Invalid D-BUS type signature '%s' found while parsing introspection", + qPrintable(argData.type)); + } + + 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 interfaceList = m_node.elementsByTagName(QLatin1String("interface")); + for (int i = 0; i < interfaceList.count(); ++i) + { + QDomElement iface = interfaceList.item(i).toElement(); + QString ifaceName = iface.attribute(QLatin1String("name")); + if (iface.isNull()) + continue; // for whatever reason + if (!QDBusUtil::isValidInterfaceName(ifaceName)) { + qDBusParserError("Invalid D-BUS interface name '%s' found while parsing introspection", + qPrintable(ifaceName)); + continue; + } + + 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()) + continue; + if (!QDBusUtil::isValidMemberName(methodName)) { + qDBusParserError("Invalid D-BUS member name '%s' found in interface '%s' while parsing introspection", + qPrintable(methodName), qPrintable(ifaceName)); + continue; + } + + QDBusIntrospection::Method methodData; + methodData.name = methodName; + + // parse arguments + methodData.inputArgs = parseArgs(method, QLatin1String("in"), true); + methodData.outputArgs = parseArgs(method, QLatin1String("out"), false); + 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()) + continue; + if (!QDBusUtil::isValidMemberName(signalName)) { + qDBusParserError("Invalid D-BUS member name '%s' found in interface '%s' while parsing introspection", + qPrintable(signalName), qPrintable(ifaceName)); + 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()) + continue; + if (!QDBusUtil::isValidMemberName(propertyName)) { + qDBusParserError("Invalid D-BUS member name '%s' found in interface '%s' while parsing introspection", + qPrintable(propertyName), qPrintable(ifaceName)); + 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! + qDBusParserError("Invalid D-BUS type signature '%s' found in property '%s.%s' while parsing introspection", + qPrintable(propertyData.type), qPrintable(ifaceName), + qPrintable(propertyName)); + } + + QString access = property.attribute(QLatin1String("access")); + 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 { + qDBusParserError("Invalid D-BUS property access '%s' found in property '%s.%s' while parsing introspection", + qPrintable(access), qPrintable(ifaceName), + qPrintable(propertyName)); + 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()) + continue; // for whatever reason + if (!QDBusUtil::isValidObjectPath(m_path + QLatin1Char('/') + objName)) { + qDBusParserError("Invalid D-BUS object path '%s/%s' found while parsing introspection", + qPrintable(m_path), qPrintable(objName)); + continue; + } + + objData->childObjects.append(objName); + } + + QDomNodeList interfaceList = m_node.elementsByTagName(QLatin1String("interface")); + for (int i = 0; i < interfaceList.count(); ++i) { + QDomElement iface = interfaceList.item(i).toElement(); + QString ifaceName = iface.attribute(QLatin1String("name")); + if (iface.isNull()) + continue; + if (!QDBusUtil::isValidInterfaceName(ifaceName)) { + qDBusParserError("Invalid D-BUS interface name '%s' found while parsing introspection", + qPrintable(ifaceName)); + 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 ts2(&xml); + obj.save(ts2,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 ); +} + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS diff --git a/src/dbus/qdbusxmlparser_p.h b/src/dbus/qdbusxmlparser_p.h new file mode 100644 index 0000000000..2869539f31 --- /dev/null +++ b/src/dbus/qdbusxmlparser_p.h @@ -0,0 +1,88 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDBUSXMLPARSER_H +#define QDBUSXMLPARSER_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of the QLibrary class. This header file may change from +// version to version without notice, or even be removed. +// +// We mean it. +// + +#include <QtCore/qmap.h> +#include <QtXml/qdom.h> +#include <qdbusmacros.h> +#include "qdbusintrospection_p.h" + +#ifndef QT_NO_DBUS + +QT_BEGIN_NAMESPACE + +/*! + \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; +}; + +QT_END_NAMESPACE + +#endif // QT_NO_DBUS +#endif |