/**************************************************************************** ** ** Copyright (C) 2016 The Qt Company Ltd. ** Copyright (C) 2016 Intel Corporation. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtDBus module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms ** and conditions see https://www.qt.io/terms-conditions. For further ** information use the contact form at https://www.qt.io/contact-us. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 3 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL3 included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 3 requirements ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU ** General Public License version 2.0 or (at your option) the GNU General ** Public license version 3 or any later version approved by the KDE Free ** Qt Foundation. The licenses are as published by the Free Software ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 ** included in the packaging of this file. Please review the following ** information to ensure the GNU General Public License requirements will ** be met: https://www.gnu.org/licenses/gpl-2.0.html and ** https://www.gnu.org/licenses/gpl-3.0.html. ** ** $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 #ifndef QT_NO_DBUS #ifdef QT_LINKED_LIBDBUS # include #else # include "dbus_minimal_p.h" #endif #ifdef interface # undef interface #endif 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 TRACE_DBUS_CALLS # ifdef TRACE_DBUS_CALLS namespace QtDBusCallTracing { struct TraceDBusCall { struct ThreadData { TraceDBusCall *ptr; int level; bool finishedPrinted; }; static inline ThreadData &td() { static thread_local ThreadData value; return value; } ThreadData savedData; QDebug s; TraceDBusCall(QDebug s, const char *fname) : savedData(td()), s(s.nospace() << QByteArray(savedData.level * 3, ' ').constData() << fname) { if (savedData.ptr && !savedData.finishedPrinted) { savedData.ptr->s << " ...unfinished"; savedData.ptr->s = qDebug().nospace() << QByteArray(savedData.level * 3 - 3, ' ').constData(); savedData.finishedPrinted = true; } ThreadData &data = td(); data.ptr = this; data.level++; data.finishedPrinted = false; } ~TraceDBusCall() { td() = savedData; } void operator()() { s << ")"; } template void operator()(const char *arg1, Args &&... args) { s << '"' << arg1 << '"'; if (sizeof...(args)) s << ", "; operator()(args...); } template void operator()(Arg1 &&arg1, Args &&... args) { s << arg1; if (sizeof...(args)) s << ", "; operator()(args...); } }; template T operator,(TraceDBusCall &&tc, T &&ret) { tc.s << " = " << ret; return ret; } inline const char *operator,(TraceDBusCall &&tc, const char *ret) { tc.s << " = \"" << ret << '"'; return ret; } template struct TraceReturn { typedef TraceDBusCall Type; }; template <> struct TraceReturn { typedef void Type; }; } # define DEBUGCALL(name, argcall) QtDBusCallTracing::TraceDBusCall tc(qDebug(), name "("); tc argcall # define DEBUGRET(ret) (QtDBusCallTracing::TraceReturn::Type) tc , # else # define DEBUGCALL(name, argcall) # define DEBUGRET(ret) # endif # define DEFINEFUNC(ret, func, args, argcall, funcret) \ typedef ret (* _q_PTR_##func) args; \ static inline ret q_##func args \ { \ static _q_PTR_##func ptr; \ DEBUGCALL(#func, argcall); \ if (!ptr) \ ptr = (_q_PTR_##func) qdbus_resolve_me(#func); \ funcret DEBUGRET(ret) ptr argcall; \ } # define DEFINEFUNC_CONDITIONALLY(ret, func, args, argcall, funcret, failret) \ typedef ret (* _q_PTR_##func) args; \ static inline ret q_##func args \ { \ static _q_PTR_##func ptr; \ DEBUGCALL(#func, argcall); \ if (!ptr) \ ptr = (_q_PTR_##func) qdbus_resolve_conditionally(#func); \ if (!ptr) \ failret; \ funcret DEBUGRET(ret) 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(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_unix_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) DEFINEFUNC(void , dbus_connection_set_allow_anonymous, (DBusConnection *connection, dbus_bool_t value), (connection, value), 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) #if !defined QT_LINKED_LIBDBUS DEFINEFUNC_CONDITIONALLY(dbus_bool_t , dbus_message_get_allow_interactive_authorization, (DBusMessage *message), (message), return, return false) #else // defined QT_LINKED_LIBDBUS static inline dbus_bool_t q_dbus_message_get_allow_interactive_authorization(DBusMessage *message) { #ifdef DBUS_HEADER_FLAG_ALLOW_INTERACTIVE_AUTHORIZATION return dbus_message_get_allow_interactive_authorization(message); #else Q_UNUSED(message); return false; #endif } #endif // defined QT_LINKED_LIBDBUS 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), ) #if !defined QT_LINKED_LIBDBUS DEFINEFUNC_CONDITIONALLY(void, dbus_message_set_allow_interactive_authorization, (DBusMessage *message, dbus_bool_t allow), (message, allow), return, return) #else // defined QT_LINKED_LIBDBUS static inline void q_dbus_message_set_allow_interactive_authorization(DBusMessage *message, dbus_bool_t allow) { #ifdef DBUS_HEADER_FLAG_ALLOW_INTERACTIVE_AUTHORIZATION dbus_message_set_allow_interactive_authorization(message, allow); #else Q_UNUSED(message); Q_UNUSED(allow); #endif } #endif // defined QT_LINKED_LIBDBUS /* dbus-misc.h */ DEFINEFUNC(char* , dbus_get_local_machine_id , (void), (), return) DEFINEFUNC(void , dbus_get_version , (int *major_version, int *minor_version, int *micro_version) , (major_version, minor_version, micro_version) , return) /* 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_free_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) QT_END_NAMESPACE #endif // QT_NO_DBUS #endif // QDBUS_SYMBOLS_P_H