1// Copyright (C) 2016 The Qt Company Ltd.
2// Copyright (C) 2016 Intel Corporation.
3// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
4// Qt-Security score:significant reason:default
5
6//
7// W A R N I N G
8// -------------
9//
10// This file is not part of the public API. This header file may
11// change from version to version without notice, or even be
12// removed.
13//
14// We mean it.
15//
16//
17
18#ifndef QDBUS_SYMBOLS_P_H
19#define QDBUS_SYMBOLS_P_H
20
21#include <QtDBus/private/qtdbusglobal_p.h>
22
23#ifndef QT_NO_DBUS
24
25#ifdef QT_LINKED_LIBDBUS
26# include <dbus/dbus.h>
27#else
28# include "dbus_minimal_p.h"
29#endif
30
31#include <atomic>
32
33#ifdef interface
34# undef interface
35#endif
36
37QT_BEGIN_NAMESPACE
38
39#if !defined QT_LINKED_LIBDBUS
40
41QFunctionPointer qdbus_resolve_conditionally(const char *name); // doesn't print a warning
42QFunctionPointer qdbus_resolve_me(const char *name); // prints a warning
43bool qdbus_loadLibDBus();
44
45//# define TRACE_DBUS_CALLS
46# ifdef TRACE_DBUS_CALLS
47namespace QtDBusCallTracing {
48struct TraceDBusCall
49{
50 struct ThreadData {
51 TraceDBusCall *ptr;
52 int level;
53 bool finishedPrinted;
54 };
55
56 static inline ThreadData &td()
57 {
58 Q_CONSTINIT static thread_local ThreadData value;
59 return value;
60 }
61
62 ThreadData savedData;
63 QDebug s;
64 TraceDBusCall(QDebug s, const char *fname)
65 : savedData(td()), s(s.nospace() << QByteArray(savedData.level * 3, ' ').constData() << fname)
66 {
67 if (savedData.ptr && !savedData.finishedPrinted) {
68 savedData.ptr->s << " ...unfinished";
69 savedData.ptr->s = qDebug().nospace() << QByteArray(savedData.level * 3 - 3, ' ').constData();
70 savedData.finishedPrinted = true;
71 }
72 ThreadData &data = td();
73 data.ptr = this;
74 data.level++;
75 data.finishedPrinted = false;
76 }
77 ~TraceDBusCall()
78 {
79 td() = savedData;
80 }
81
82 void operator()() { s << ")"; }
83 template <typename... Args> void operator()(const char *arg1, Args &&... args)
84 {
85 s << '"' << arg1 << '"';
86 if (sizeof...(args))
87 s << ", ";
88 operator()(args...);
89 }
90 template <typename Arg1, typename... Args> void operator()(Arg1 &&arg1, Args &&... args)
91 {
92 s << arg1;
93 if (sizeof...(args))
94 s << ", ";
95 operator()(args...);
96 }
97};
98template <typename T> T operator,(TraceDBusCall &&tc, T &&ret)
99{
100 tc.s << " = " << ret;
101 return ret;
102}
103inline const char *operator,(TraceDBusCall &&tc, const char *ret)
104{
105 tc.s << " = \"" << ret << '"';
106 return ret;
107}
108
109template <typename T> struct TraceReturn { typedef TraceDBusCall Type; };
110template <> struct TraceReturn<void> { typedef void Type; };
111}
112
113# define DEBUGCALL(name, argcall) QtDBusCallTracing::TraceDBusCall tc(qDebug(), name "("); tc argcall
114# define DEBUGRET(ret) (QtDBusCallTracing::TraceReturn<ret>::Type) tc ,
115# else
116# define DEBUGCALL(name, argcall)
117# define DEBUGRET(ret)
118# endif
119
120# define DEFINEFUNC(ret, func, args, argcall, funcret) \
121 static inline ret q_##func args \
122 { \
123 using func_ptr = ret (*) args; \
124 static std::atomic<func_ptr> atomic_ptr; \
125 func_ptr ptr = atomic_ptr.load(std::memory_order_relaxed); \
126 DEBUGCALL(#func, argcall); \
127 if (!ptr) { \
128 ptr = reinterpret_cast<func_ptr>(qdbus_resolve_me(#func)); \
129 atomic_ptr.store(ptr, std::memory_order_relaxed); \
130 } \
131 funcret DEBUGRET(ret) ptr argcall; \
132 }
133
134# define DEFINEFUNC_CONDITIONALLY(ret, func, args, argcall, funcret, failret) \
135 static inline ret q_##func args \
136 { \
137 using func_ptr = ret (*) args; \
138 static std::atomic<func_ptr> atomic_ptr; \
139 func_ptr ptr = atomic_ptr.load(std::memory_order_relaxed); \
140 DEBUGCALL(#func, argcall); \
141 if (!ptr) { \
142 ptr = reinterpret_cast<func_ptr>(qdbus_resolve_conditionally(#func)); \
143 atomic_ptr.store(ptr, std::memory_order_relaxed); \
144 } \
145 if (!ptr) \
146 failret; \
147 funcret DEBUGRET(ret) ptr argcall; \
148 }
149
150#else // defined QT_LINKED_LIBDBUS
151
152inline bool qdbus_loadLibDBus() { return true; }
153
154# define DEFINEFUNC(ret, func, args, argcall, funcret) \
155 static inline ret q_##func args { funcret func argcall; }
156
157#endif // defined QT_LINKED_LIBDBUS
158
159/* dbus-bus.h */
160DEFINEFUNC(void, dbus_bus_add_match, (DBusConnection *connection,
161 const char *rule,
162 DBusError *error),
163 (connection, rule, error), )
164DEFINEFUNC(void, dbus_bus_remove_match, (DBusConnection *connection,
165 const char *rule,
166 DBusError *error),
167 (connection, rule, error), )
168DEFINEFUNC(dbus_bool_t, dbus_bus_register,(DBusConnection *connection,
169 DBusError *error),
170 (connection, error), return)
171DEFINEFUNC(DBusConnection *, dbus_bus_get_private, (DBusBusType type,
172 DBusError *error),
173 (type, error), return)
174DEFINEFUNC(const char*, dbus_bus_get_unique_name, (DBusConnection *connection),
175 (connection), return)
176
177/* dbus-connection.h */
178DEFINEFUNC(dbus_bool_t , dbus_connection_add_filter, (DBusConnection *connection,
179 DBusHandleMessageFunction function,
180 void *user_data,
181 DBusFreeFunction free_data_function),
182 (connection, function, user_data, free_data_function), return)
183DEFINEFUNC(void , dbus_connection_close, (DBusConnection *connection),
184 (connection), return)
185DEFINEFUNC(DBusDispatchStatus , dbus_connection_dispatch, (DBusConnection *connection),
186 (connection), return)
187DEFINEFUNC(DBusDispatchStatus , dbus_connection_get_dispatch_status, (DBusConnection *connection),
188 (connection), return)
189DEFINEFUNC(dbus_bool_t, dbus_connection_get_is_authenticated, (DBusConnection * connection),
190 (connection), return )
191DEFINEFUNC(dbus_bool_t , dbus_connection_get_is_connected, (DBusConnection *connection),
192 (connection), return)
193DEFINEFUNC(DBusConnection* , dbus_connection_open_private, (const char *address,
194 DBusError *error),
195 (address, error), return)
196DEFINEFUNC(DBusConnection* , dbus_connection_ref, (DBusConnection *connection),
197 (connection), return)
198DEFINEFUNC(dbus_bool_t , dbus_connection_send, (DBusConnection *connection,
199 DBusMessage *message,
200 dbus_uint32_t *client_serial),
201 (connection, message, client_serial), return)
202DEFINEFUNC(dbus_bool_t , dbus_connection_send_with_reply, (DBusConnection *connection,
203 DBusMessage *message,
204 DBusPendingCall **pending_return,
205 int timeout_milliseconds),
206 (connection, message, pending_return, timeout_milliseconds), return)
207DEFINEFUNC(void , dbus_connection_set_exit_on_disconnect, (DBusConnection *connection,
208 dbus_bool_t exit_on_disconnect),
209 (connection, exit_on_disconnect), )
210DEFINEFUNC(dbus_bool_t , dbus_connection_set_timeout_functions, (DBusConnection *connection,
211 DBusAddTimeoutFunction add_function,
212 DBusRemoveTimeoutFunction remove_function,
213 DBusTimeoutToggledFunction toggled_function,
214 void *data,
215 DBusFreeFunction free_data_function),
216 (connection, add_function, remove_function, toggled_function, data, free_data_function), return)
217DEFINEFUNC(dbus_bool_t , dbus_connection_set_watch_functions, (DBusConnection *connection,
218 DBusAddWatchFunction add_function,
219 DBusRemoveWatchFunction remove_function,
220 DBusWatchToggledFunction toggled_function,
221 void *data,
222 DBusFreeFunction free_data_function),
223 (connection, add_function, remove_function, toggled_function, data, free_data_function), return)
224DEFINEFUNC(void , dbus_connection_set_wakeup_main_function, (DBusConnection *connection,
225 DBusWakeupMainFunction wakeup_main_function,
226 void *data,
227 DBusFreeFunction free_data_function),
228 (connection, wakeup_main_function, data, free_data_function), )
229DEFINEFUNC(void , dbus_connection_set_dispatch_status_function, (DBusConnection *connection,
230 DBusDispatchStatusFunction function,
231 void *data,
232 DBusFreeFunction free_data_function),
233 (connection, function, data, free_data_function), )
234
235DEFINEFUNC(void , dbus_connection_unref, (DBusConnection *connection),
236 (connection), )
237DEFINEFUNC(dbus_bool_t , dbus_timeout_get_enabled, (DBusTimeout *timeout),
238 (timeout), return)
239DEFINEFUNC(int , dbus_timeout_get_interval, (DBusTimeout *timeout),
240 (timeout), return)
241DEFINEFUNC(dbus_bool_t , dbus_timeout_handle, (DBusTimeout *timeout),
242 (timeout), return)
243
244DEFINEFUNC(dbus_bool_t , dbus_watch_get_enabled, (DBusWatch *watch),
245 (watch), return)
246DEFINEFUNC(int , dbus_watch_get_unix_fd, (DBusWatch *watch),
247 (watch), return)
248DEFINEFUNC(unsigned int , dbus_watch_get_flags, (DBusWatch *watch),
249 (watch), return)
250DEFINEFUNC(dbus_bool_t , dbus_watch_handle, (DBusWatch *watch,
251 unsigned int flags),
252 (watch, flags), return)
253DEFINEFUNC(void , dbus_connection_set_allow_anonymous, (DBusConnection *connection,
254 dbus_bool_t value),
255 (connection, value), return)
256
257/* dbus-errors.h */
258DEFINEFUNC(void , dbus_error_free, (DBusError *error),
259 (error), )
260DEFINEFUNC(void , dbus_error_init, (DBusError *error),
261 (error), )
262DEFINEFUNC(dbus_bool_t , dbus_error_is_set, (const DBusError *error),
263 (error), return)
264
265/* dbus-memory.h */
266DEFINEFUNC(void , dbus_free, (void *memory), (memory), )
267
268/* dbus-message.h */
269DEFINEFUNC(DBusMessage* , dbus_message_copy, (const DBusMessage *message),
270 (message), return)
271DEFINEFUNC(dbus_bool_t , dbus_message_get_auto_start, (DBusMessage *message),
272 (message), return)
273DEFINEFUNC(const char* , dbus_message_get_error_name, (DBusMessage *message),
274 (message), return)
275DEFINEFUNC(const char* , dbus_message_get_interface, (DBusMessage *message),
276 (message), return)
277DEFINEFUNC(const char* , dbus_message_get_member, (DBusMessage *message),
278 (message), return)
279DEFINEFUNC(dbus_bool_t , dbus_message_get_no_reply, (DBusMessage *message),
280 (message), return)
281DEFINEFUNC(const char* , dbus_message_get_path, (DBusMessage *message),
282 (message), return)
283DEFINEFUNC(const char* , dbus_message_get_sender, (DBusMessage *message),
284 (message), return)
285DEFINEFUNC(dbus_uint32_t , dbus_message_get_serial, (DBusMessage *message),
286 (message), return)
287DEFINEFUNC(const char* , dbus_message_get_signature, (DBusMessage *message),
288 (message), return)
289DEFINEFUNC(int , dbus_message_get_type, (DBusMessage *message),
290 (message), return)
291
292#if !defined QT_LINKED_LIBDBUS
293
294DEFINEFUNC_CONDITIONALLY(dbus_bool_t , dbus_message_get_allow_interactive_authorization, (DBusMessage *message),
295 (message), return, return false)
296
297#else // defined QT_LINKED_LIBDBUS
298
299static inline dbus_bool_t q_dbus_message_get_allow_interactive_authorization(DBusMessage *message)
300{
301#ifdef DBUS_HEADER_FLAG_ALLOW_INTERACTIVE_AUTHORIZATION
302 return dbus_message_get_allow_interactive_authorization(message);
303#else
304 Q_UNUSED(message);
305 return false;
306#endif
307}
308
309#endif // defined QT_LINKED_LIBDBUS
310
311DEFINEFUNC(dbus_bool_t , dbus_message_iter_append_basic, (DBusMessageIter *iter,
312 int type,
313 const void *value),
314 (iter, type, value), return)
315DEFINEFUNC(dbus_bool_t , dbus_message_iter_append_fixed_array, (DBusMessageIter *iter,
316 int element_type,
317 const void *value,
318 int n_elements),
319 (iter, element_type, value, n_elements), return)
320DEFINEFUNC(dbus_bool_t , dbus_message_iter_close_container, (DBusMessageIter *iter,
321 DBusMessageIter *sub),
322 (iter, sub), return)
323DEFINEFUNC(int , dbus_message_iter_get_arg_type, (DBusMessageIter *iter),
324 (iter), return)
325DEFINEFUNC(void , dbus_message_iter_get_basic, (DBusMessageIter *iter,
326 void *value),
327 (iter, value), )
328DEFINEFUNC(int , dbus_message_iter_get_element_type, (DBusMessageIter *iter),
329 (iter), return)
330DEFINEFUNC(void , dbus_message_iter_get_fixed_array, (DBusMessageIter *iter,
331 void *value,
332 int *n_elements),
333 (iter, value, n_elements), return)
334DEFINEFUNC(char* , dbus_message_iter_get_signature, (DBusMessageIter *iter),
335 (iter), return)
336DEFINEFUNC(dbus_bool_t , dbus_message_iter_init, (DBusMessage *message,
337 DBusMessageIter *iter),
338 (message, iter), return)
339DEFINEFUNC(void , dbus_message_iter_init_append, (DBusMessage *message,
340 DBusMessageIter *iter),
341 (message, iter), return)
342DEFINEFUNC(dbus_bool_t , dbus_message_iter_next, (DBusMessageIter *iter),
343 (iter), return)
344DEFINEFUNC(dbus_bool_t , dbus_message_iter_open_container, (DBusMessageIter *iter,
345 int type,
346 const char *contained_signature,
347 DBusMessageIter *sub),
348 (iter, type, contained_signature, sub), return)
349DEFINEFUNC(void , dbus_message_iter_recurse, (DBusMessageIter *iter,
350 DBusMessageIter *sub),
351 (iter, sub), )
352DEFINEFUNC(DBusMessage* , dbus_message_new, (int message_type),
353 (message_type), return)
354DEFINEFUNC(DBusMessage* , dbus_message_new_method_call, (const char *bus_name,
355 const char *path,
356 const char *interface,
357 const char *method),
358 (bus_name, path, interface, method), return)
359DEFINEFUNC(DBusMessage* , dbus_message_new_signal, (const char *path,
360 const char *interface,
361 const char *name),
362 (path, interface, name), return)
363DEFINEFUNC(DBusMessage* , dbus_message_ref, (DBusMessage *message),
364 (message), return)
365DEFINEFUNC(void , dbus_message_set_auto_start, (DBusMessage *message,
366 dbus_bool_t auto_start),
367 (message, auto_start), return)
368DEFINEFUNC(dbus_bool_t , dbus_message_set_destination, (DBusMessage *message,
369 const char *destination),
370 (message, destination), return)
371DEFINEFUNC(dbus_bool_t , dbus_message_set_error_name, (DBusMessage *message,
372 const char *name),
373 (message, name), return)
374DEFINEFUNC(void , dbus_message_set_no_reply, (DBusMessage *message,
375 dbus_bool_t no_reply),
376 (message, no_reply), return)
377DEFINEFUNC(dbus_bool_t , dbus_message_set_path, (DBusMessage *message,
378 const char *object_path),
379 (message, object_path), return)
380DEFINEFUNC(dbus_bool_t , dbus_message_set_reply_serial, (DBusMessage *message,
381 dbus_uint32_t reply_serial),
382 (message, reply_serial), return)
383DEFINEFUNC(dbus_bool_t , dbus_message_set_sender, (DBusMessage *message,
384 const char *sender),
385 (message, sender), return)
386DEFINEFUNC(void , dbus_message_unref, (DBusMessage *message),
387 (message), )
388
389#if !defined QT_LINKED_LIBDBUS
390
391DEFINEFUNC_CONDITIONALLY(void, dbus_message_set_allow_interactive_authorization,
392 (DBusMessage *message, dbus_bool_t allow), (message, allow), return, return)
393
394
395#else // defined QT_LINKED_LIBDBUS
396
397static inline void q_dbus_message_set_allow_interactive_authorization(DBusMessage *message, dbus_bool_t allow)
398{
399#ifdef DBUS_HEADER_FLAG_ALLOW_INTERACTIVE_AUTHORIZATION
400 dbus_message_set_allow_interactive_authorization(message, allow);
401#else
402 Q_UNUSED(message);
403 Q_UNUSED(allow);
404#endif
405}
406
407#endif // defined QT_LINKED_LIBDBUS
408
409/* dbus-misc.h */
410DEFINEFUNC(char* , dbus_get_local_machine_id , (void), (), return)
411
412DEFINEFUNC(void , dbus_get_version , (int *major_version, int *minor_version, int *micro_version)
413 , (major_version, minor_version, micro_version)
414 , return)
415
416
417/* dbus-pending-call.h */
418DEFINEFUNC(dbus_bool_t , dbus_pending_call_set_notify, (DBusPendingCall *pending,
419 DBusPendingCallNotifyFunction function,
420 void *user_data,
421 DBusFreeFunction free_user_data),
422 (pending, function, user_data, free_user_data), return)
423DEFINEFUNC(void , dbus_pending_call_block, (DBusPendingCall *pending),
424 (pending), )
425DEFINEFUNC(void , dbus_pending_call_cancel, (DBusPendingCall *pending),
426 (pending), )
427DEFINEFUNC(dbus_bool_t , dbus_pending_call_get_completed, (DBusPendingCall *pending),
428 (pending), return)
429DEFINEFUNC(DBusMessage* , dbus_pending_call_steal_reply, (DBusPendingCall *pending),
430 (pending), return)
431DEFINEFUNC(void , dbus_pending_call_unref, (DBusPendingCall *pending),
432 (pending), return)
433
434/* dbus-server.h */
435DEFINEFUNC(dbus_bool_t , dbus_server_allocate_data_slot, (dbus_int32_t *slot_p),
436 (slot_p), return)
437DEFINEFUNC(void , dbus_server_free_data_slot, (dbus_int32_t *slot_p),
438 (slot_p), return)
439DEFINEFUNC(void , dbus_server_disconnect, (DBusServer *server),
440 (server), )
441DEFINEFUNC(char* , dbus_server_get_address, (DBusServer *server),
442 (server), return)
443DEFINEFUNC(dbus_bool_t , dbus_server_get_is_connected, (DBusServer *server),
444 (server), return)
445DEFINEFUNC(DBusServer* , dbus_server_listen, (const char *address,
446 DBusError *error),
447 (address, error), return)
448DEFINEFUNC(dbus_bool_t , dbus_server_set_data, (DBusServer *server,
449 int slot,
450 void *data,
451 DBusFreeFunction free_data_func),
452 (server, slot, data, free_data_func), return)
453DEFINEFUNC(void , dbus_server_set_new_connection_function, (DBusServer *server,
454 DBusNewConnectionFunction function,
455 void *data,
456 DBusFreeFunction free_data_function),
457 (server, function, data, free_data_function), )
458DEFINEFUNC(dbus_bool_t , dbus_server_set_timeout_functions, (DBusServer *server,
459 DBusAddTimeoutFunction add_function,
460 DBusRemoveTimeoutFunction remove_function,
461 DBusTimeoutToggledFunction toggled_function,
462 void *data,
463 DBusFreeFunction free_data_function),
464 (server, add_function, remove_function, toggled_function, data, free_data_function), return)
465DEFINEFUNC(dbus_bool_t , dbus_server_set_watch_functions, (DBusServer *server,
466 DBusAddWatchFunction add_function,
467 DBusRemoveWatchFunction remove_function,
468 DBusWatchToggledFunction toggled_function,
469 void *data,
470 DBusFreeFunction free_data_function),
471 (server, add_function, remove_function, toggled_function, data, free_data_function), return)
472DEFINEFUNC(void , dbus_server_unref, (DBusServer *server),
473 (server), )
474
475/* dbus-thread.h */
476DEFINEFUNC(dbus_bool_t , dbus_threads_init_default, (), (), return)
477
478QT_END_NAMESPACE
479
480#endif // QT_NO_DBUS
481#endif // QDBUS_SYMBOLS_P_H
482

source code of qtbase/src/dbus/qdbus_symbols_p.h