1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
*
* D-Bus helper library
*
* Copyright (C) 2004-2011 Marcel Holtmann <marcel@holtmann.org>
* Copyright 2024 NXP
*
*
*/
#ifndef __GDBUS_H
#define __GDBUS_H
#ifdef __cplusplus
extern "C" {
#endif
#include <dbus/dbus.h>
#include <glib.h>
typedef struct GDBusArgInfo GDBusArgInfo;
typedef struct GDBusMethodTable GDBusMethodTable;
typedef struct GDBusSignalTable GDBusSignalTable;
typedef struct GDBusPropertyTable GDBusPropertyTable;
typedef struct GDBusSecurityTable GDBusSecurityTable;
typedef void (* GDBusWatchFunction) (DBusConnection *connection,
void *user_data);
typedef void (* GDBusMessageFunction) (DBusConnection *connection,
DBusMessage *message, void *user_data);
typedef gboolean (* GDBusSignalFunction) (DBusConnection *connection,
DBusMessage *message, void *user_data);
DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name,
DBusError *error);
DBusConnection *g_dbus_setup_private(DBusBusType type, const char *name,
DBusError *error);
gboolean g_dbus_request_name(DBusConnection *connection, const char *name,
DBusError *error);
gboolean g_dbus_set_disconnect_function(DBusConnection *connection,
GDBusWatchFunction function,
void *user_data, DBusFreeFunction destroy);
typedef void (* GDBusDestroyFunction) (void *user_data);
typedef DBusMessage * (* GDBusMethodFunction) (DBusConnection *connection,
DBusMessage *message, void *user_data);
typedef gboolean (*GDBusPropertyGetter)(const GDBusPropertyTable *property,
DBusMessageIter *iter, void *data);
typedef guint32 GDBusPendingPropertySet;
typedef void (*GDBusPropertySetter)(const GDBusPropertyTable *property,
DBusMessageIter *value, GDBusPendingPropertySet id,
void *data);
typedef gboolean (*GDBusPropertyExists)(const GDBusPropertyTable *property,
void *data);
typedef guint32 GDBusPendingReply;
typedef void (* GDBusSecurityFunction) (DBusConnection *connection,
const char *action,
gboolean interaction,
GDBusPendingReply pending);
enum GDBusFlags {
G_DBUS_FLAG_ENABLE_EXPERIMENTAL = (1 << 0),
G_DBUS_FLAG_ENABLE_TESTING = (1 << 1),
};
enum GDBusMethodFlags {
G_DBUS_METHOD_FLAG_DEPRECATED = (1 << 0),
G_DBUS_METHOD_FLAG_NOREPLY = (1 << 1),
G_DBUS_METHOD_FLAG_ASYNC = (1 << 2),
G_DBUS_METHOD_FLAG_EXPERIMENTAL = (1 << 3),
G_DBUS_METHOD_FLAG_TESTING = (1 << 4),
};
enum GDBusSignalFlags {
G_DBUS_SIGNAL_FLAG_DEPRECATED = (1 << 0),
G_DBUS_SIGNAL_FLAG_EXPERIMENTAL = (1 << 1),
G_DBUS_SIGNAL_FLAG_TESTING = (1 << 2),
};
enum GDBusPropertyFlags {
G_DBUS_PROPERTY_FLAG_DEPRECATED = (1 << 0),
G_DBUS_PROPERTY_FLAG_EXPERIMENTAL = (1 << 1),
G_DBUS_PROPERTY_FLAG_TESTING = (1 << 2),
};
enum GDBusSecurityFlags {
G_DBUS_SECURITY_FLAG_DEPRECATED = (1 << 0),
G_DBUS_SECURITY_FLAG_BUILTIN = (1 << 1),
G_DBUS_SECURITY_FLAG_ALLOW_INTERACTION = (1 << 2),
};
enum GDbusPropertyChangedFlags {
G_DBUS_PROPERTY_CHANGED_FLAG_FLUSH = (1 << 0),
};
typedef enum GDBusMethodFlags GDBusMethodFlags;
typedef enum GDBusSignalFlags GDBusSignalFlags;
typedef enum GDBusPropertyFlags GDBusPropertyFlags;
typedef enum GDBusSecurityFlags GDBusSecurityFlags;
typedef enum GDbusPropertyChangedFlags GDbusPropertyChangedFlags;
struct GDBusArgInfo {
const char *name;
const char *signature;
};
struct GDBusMethodTable {
const char *name;
GDBusMethodFunction function;
GDBusMethodFlags flags;
unsigned int privilege;
const GDBusArgInfo *in_args;
const GDBusArgInfo *out_args;
};
struct GDBusSignalTable {
const char *name;
GDBusSignalFlags flags;
const GDBusArgInfo *args;
};
struct GDBusPropertyTable {
const char *name;
const char *type;
GDBusPropertyGetter get;
GDBusPropertySetter set;
GDBusPropertyExists exists;
GDBusPropertyFlags flags;
};
struct GDBusSecurityTable {
unsigned int privilege;
const char *action;
GDBusSecurityFlags flags;
GDBusSecurityFunction function;
};
#define GDBUS_ARGS(args...) (const GDBusArgInfo[]) { args, { } }
#define GDBUS_METHOD(_name, _in_args, _out_args, _function) \
.name = _name, \
.in_args = _in_args, \
.out_args = _out_args, \
.function = _function
#define GDBUS_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
.name = _name, \
.in_args = _in_args, \
.out_args = _out_args, \
.function = _function, \
.flags = G_DBUS_METHOD_FLAG_ASYNC
#define GDBUS_DEPRECATED_METHOD(_name, _in_args, _out_args, _function) \
.name = _name, \
.in_args = _in_args, \
.out_args = _out_args, \
.function = _function, \
.flags = G_DBUS_METHOD_FLAG_DEPRECATED
#define GDBUS_DEPRECATED_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
.name = _name, \
.in_args = _in_args, \
.out_args = _out_args, \
.function = _function, \
.flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_DEPRECATED
#define GDBUS_EXPERIMENTAL_METHOD(_name, _in_args, _out_args, _function) \
.name = _name, \
.in_args = _in_args, \
.out_args = _out_args, \
.function = _function, \
.flags = G_DBUS_METHOD_FLAG_EXPERIMENTAL
#define GDBUS_EXPERIMENTAL_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
.name = _name, \
.in_args = _in_args, \
.out_args = _out_args, \
.function = _function, \
.flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_EXPERIMENTAL
#define GDBUS_TESTING_METHOD(_name, _in_args, _out_args, _function) \
.name = _name, \
.in_args = _in_args, \
.out_args = _out_args, \
.function = _function, \
.flags = G_DBUS_METHOD_FLAG_TESTING
#define GDBUS_TESTING_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
.name = _name, \
.in_args = _in_args, \
.out_args = _out_args, \
.function = _function, \
.flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_TESTING
#define GDBUS_NOREPLY_METHOD(_name, _in_args, _out_args, _function) \
.name = _name, \
.in_args = _in_args, \
.out_args = _out_args, \
.function = _function, \
.flags = G_DBUS_METHOD_FLAG_NOREPLY
#define GDBUS_SIGNAL(_name, _args) \
.name = _name, \
.args = _args
#define GDBUS_DEPRECATED_SIGNAL(_name, _args) \
.name = _name, \
.args = _args, \
.flags = G_DBUS_SIGNAL_FLAG_DEPRECATED
#define GDBUS_EXPERIMENTAL_SIGNAL(_name, _args) \
.name = _name, \
.args = _args, \
.flags = G_DBUS_SIGNAL_FLAG_EXPERIMENTAL
#define GDBUS_TESTING_SIGNAL(_name, _args) \
.name = _name, \
.args = _args, \
.flags = G_DBUS_SIGNAL_FLAG_EXPERIMENTAL
void g_dbus_set_flags(int flags);
int g_dbus_get_flags(void);
typedef void (*g_dbus_destroy_func_t)(void *user_data);
typedef void (*g_dbus_debug_func_t)(const char *str, void *user_data);
void g_dbus_set_debug(g_dbus_debug_func_t cb, void *user_data,
g_dbus_destroy_func_t destroy);
gboolean g_dbus_register_interface(DBusConnection *connection,
const char *path, const char *name,
const GDBusMethodTable *methods,
const GDBusSignalTable *signals,
const GDBusPropertyTable *properties,
void *user_data,
GDBusDestroyFunction destroy);
gboolean g_dbus_unregister_interface(DBusConnection *connection,
const char *path, const char *name);
gboolean g_dbus_register_security(const GDBusSecurityTable *security);
gboolean g_dbus_unregister_security(const GDBusSecurityTable *security);
void g_dbus_pending_success(DBusConnection *connection,
GDBusPendingReply pending);
void g_dbus_pending_error(DBusConnection *connection,
GDBusPendingReply pending,
const char *name, const char *format, ...)
__attribute__((format(printf, 4, 5)));
void g_dbus_pending_error_valist(DBusConnection *connection,
GDBusPendingReply pending, const char *name,
const char *format, va_list args);
DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name,
const char *format, ...)
__attribute__((format(printf, 3, 4)));
DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name,
const char *format, va_list args);
DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...);
DBusMessage *g_dbus_create_reply_valist(DBusMessage *message,
int type, va_list args);
gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message);
gboolean g_dbus_send_message_with_reply(DBusConnection *connection,
DBusMessage *message,
DBusPendingCall **call, int timeout);
gboolean g_dbus_send_error(DBusConnection *connection, DBusMessage *message,
const char *name, const char *format, ...)
__attribute__((format(printf, 4, 5)));
gboolean g_dbus_send_error_valist(DBusConnection *connection,
DBusMessage *message, const char *name,
const char *format, va_list args);
gboolean g_dbus_send_reply(DBusConnection *connection,
DBusMessage *message, int type, ...);
gboolean g_dbus_send_reply_valist(DBusConnection *connection,
DBusMessage *message, int type, va_list args);
gboolean g_dbus_emit_signal(DBusConnection *connection,
const char *path, const char *interface,
const char *name, int type, ...);
gboolean g_dbus_emit_signal_valist(DBusConnection *connection,
const char *path, const char *interface,
const char *name, int type, va_list args);
guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
GDBusWatchFunction connect,
GDBusWatchFunction disconnect,
void *user_data, GDBusDestroyFunction destroy);
guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
GDBusWatchFunction function,
void *user_data, GDBusDestroyFunction destroy);
guint g_dbus_add_signal_watch(DBusConnection *connection,
const char *sender, const char *path,
const char *interface, const char *member,
GDBusSignalFunction function, void *user_data,
GDBusDestroyFunction destroy);
guint g_dbus_add_properties_watch(DBusConnection *connection,
const char *sender, const char *path,
const char *interface,
GDBusSignalFunction function, void *user_data,
GDBusDestroyFunction destroy);
gboolean g_dbus_remove_watch(DBusConnection *connection, guint tag);
void g_dbus_remove_all_watches(DBusConnection *connection);
const char *g_dbus_pending_property_get_sender(GDBusPendingPropertySet id);
void g_dbus_pending_property_success(GDBusPendingPropertySet id);
void g_dbus_pending_property_error_valist(GDBusPendingReply id,
const char *name, const char *format, va_list args);
void g_dbus_pending_property_error(GDBusPendingReply id, const char *name,
const char *format, ...);
/*
* Note that when multiple properties for a given object path are changed
* in the same mainloop iteration, they will be grouped with the last
* property changed. If this behaviour is undesired, use
* g_dbus_emit_property_changed_full() with the
* G_DBUS_PROPERTY_CHANGED_FLAG_FLUSH flag, causing the signal to ignore
* any grouping.
*/
void g_dbus_emit_property_changed(DBusConnection *connection,
const char *path, const char *interface,
const char *name);
void g_dbus_emit_property_changed_full(DBusConnection *connection,
const char *path, const char *interface,
const char *name,
GDbusPropertyChangedFlags flags);
gboolean g_dbus_get_properties(DBusConnection *connection, const char *path,
const char *interface, DBusMessageIter *iter);
gboolean g_dbus_attach_object_manager(DBusConnection *connection);
gboolean g_dbus_detach_object_manager(DBusConnection *connection);
typedef struct GDBusClient GDBusClient;
typedef struct GDBusProxy GDBusProxy;
GDBusProxy *g_dbus_proxy_new(GDBusClient *client, const char *path,
const char *interface);
GDBusProxy *g_dbus_proxy_ref(GDBusProxy *proxy);
void g_dbus_proxy_unref(GDBusProxy *proxy);
const char *g_dbus_proxy_get_path(const GDBusProxy *proxy);
const char *g_dbus_proxy_get_interface(GDBusProxy *proxy);
gboolean g_dbus_proxy_get_property(GDBusProxy *proxy, const char *name,
DBusMessageIter *iter);
GDBusProxy *g_dbus_proxy_lookup(GList *list, int *index, const char *path,
const char *interface);
char *g_dbus_proxy_path_lookup(GList *list, int *index, const char *path);
gboolean g_dbus_proxy_refresh_property(GDBusProxy *proxy, const char *name);
typedef void (* GDBusResultFunction) (const DBusError *error, void *user_data);
gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy,
const char *name, int type, const void *value,
GDBusResultFunction function, void *user_data,
GDBusDestroyFunction destroy);
gboolean g_dbus_proxy_set_property_dict(GDBusProxy *proxy,
const char *name, GDBusResultFunction function,
void *user_data, GDBusDestroyFunction destroy,
char *entry, ...);
gboolean g_dbus_proxy_set_property_array(GDBusProxy *proxy,
const char *name, int type, const void *value,
size_t size, GDBusResultFunction function,
void *user_data, GDBusDestroyFunction destroy);
void g_dbus_dict_append_entry(DBusMessageIter *dict,
const char *key, int type, void *val);
void g_dbus_dict_append_basic_array(DBusMessageIter *dict, int key_type,
const void *key, int type, void *val,
int n_elements);
void g_dbus_dict_append_array(DBusMessageIter *dict,
const char *key, int type, void *val,
int n_elements);
typedef void (* GDBusSetupFunction) (DBusMessageIter *iter, void *user_data);
typedef void (* GDBusReturnFunction) (DBusMessage *message, void *user_data);
gboolean g_dbus_proxy_method_call(GDBusProxy *proxy, const char *method,
GDBusSetupFunction setup,
GDBusReturnFunction function, void *user_data,
GDBusDestroyFunction destroy);
typedef void (* GDBusClientFunction) (GDBusClient *client, void *user_data);
typedef void (* GDBusProxyFunction) (GDBusProxy *proxy, void *user_data);
typedef void (* GDBusPropertyFunction) (GDBusProxy *proxy, const char *name,
DBusMessageIter *iter, void *user_data);
gboolean g_dbus_proxy_set_property_watch(GDBusProxy *proxy,
GDBusPropertyFunction function, void *user_data);
gboolean g_dbus_proxy_set_removed_watch(GDBusProxy *proxy,
GDBusProxyFunction destroy, void *user_data);
GDBusClient *g_dbus_client_new(DBusConnection *connection,
const char *service, const char *path);
GDBusClient *g_dbus_client_new_full(DBusConnection *connection,
const char *service,
const char *path,
const char *root_path);
GDBusClient *g_dbus_client_ref(GDBusClient *client);
void g_dbus_client_unref(GDBusClient *client);
gboolean g_dbus_client_set_connect_watch(GDBusClient *client,
GDBusWatchFunction function, void *user_data);
gboolean g_dbus_client_set_disconnect_watch(GDBusClient *client,
GDBusWatchFunction function, void *user_data);
gboolean g_dbus_client_set_signal_watch(GDBusClient *client,
GDBusMessageFunction function, void *user_data);
gboolean g_dbus_client_set_ready_watch(GDBusClient *client,
GDBusClientFunction ready, void *user_data);
gboolean g_dbus_client_set_proxy_handlers(GDBusClient *client,
GDBusProxyFunction proxy_added,
GDBusProxyFunction proxy_removed,
GDBusPropertyFunction property_changed,
void *user_data);
#ifdef __cplusplus
}
#endif
#endif /* __GDBUS_H */
|