5 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
32 #include <dbus/dbus.h>
40 static DBusHandlerResult message_filter(DBusConnection *connection,
41 DBusMessage *message, void *user_data);
43 static guint listener_id = 0;
44 static GSList *listeners = NULL;
46 struct filter_callback {
47 GDBusWatchFunction conn_func;
48 GDBusWatchFunction disc_func;
49 GDBusSignalFunction signal_func;
50 GDBusDestroyFunction destroy_func;
56 DBusConnection *connection;
57 DBusHandleMessageFunction handle_func;
71 static struct filter_data *filter_data_find(DBusConnection *connection,
75 const char *interface,
81 for (current = listeners;
82 current != NULL; current = current->next) {
83 struct filter_data *data = current->data;
85 if (connection != data->connection)
88 if (name && data->name &&
89 g_str_equal(name, data->name) == FALSE)
92 if (owner && data->owner &&
93 g_str_equal(owner, data->owner) == FALSE)
96 if (path && data->path &&
97 g_str_equal(path, data->path) == FALSE)
100 if (interface && data->interface &&
101 g_str_equal(interface, data->interface) == FALSE)
104 if (member && data->member &&
105 g_str_equal(member, data->member) == FALSE)
108 if (argument && data->argument &&
109 g_str_equal(argument, data->argument) == FALSE)
118 static void format_rule(struct filter_data *data, char *rule, size_t size)
123 offset = snprintf(rule, size, "type='signal'");
124 sender = data->name ? : data->owner;
127 offset += snprintf(rule + offset, size - offset,
128 ",sender='%s'", sender);
130 offset += snprintf(rule + offset, size - offset,
131 ",path='%s'", data->path);
133 offset += snprintf(rule + offset, size - offset,
134 ",interface='%s'", data->interface);
136 offset += snprintf(rule + offset, size - offset,
137 ",member='%s'", data->member);
139 snprintf(rule + offset, size - offset,
140 ",arg0='%s'", data->argument);
143 static gboolean add_match(struct filter_data *data,
144 DBusHandleMessageFunction filter)
147 char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
149 format_rule(data, rule, sizeof(rule));
150 dbus_error_init(&err);
152 dbus_bus_add_match(data->connection, rule, &err);
153 if (dbus_error_is_set(&err)) {
154 error("Adding match rule \"%s\" failed: %s", rule,
156 dbus_error_free(&err);
160 data->handle_func = filter;
161 data->registered = TRUE;
166 static gboolean remove_match(struct filter_data *data)
169 char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
171 format_rule(data, rule, sizeof(rule));
173 dbus_error_init(&err);
175 dbus_bus_remove_match(data->connection, rule, &err);
176 if (dbus_error_is_set(&err)) {
177 error("Removing owner match rule for %s failed: %s",
179 dbus_error_free(&err);
186 static struct filter_data *filter_data_get(DBusConnection *connection,
187 DBusHandleMessageFunction filter,
190 const char *interface,
192 const char *argument)
194 struct filter_data *data;
195 const char *name = NULL, *owner = NULL;
197 if (!filter_data_find(connection, NULL, NULL, NULL, NULL, NULL,
199 if (!dbus_connection_add_filter(connection,
200 message_filter, NULL, NULL)) {
201 error("dbus_connection_add_filter() failed");
209 if (sender[0] == ':')
215 data = filter_data_find(connection, name, owner, path, interface,
220 data = g_new0(struct filter_data, 1);
222 data->connection = dbus_connection_ref(connection);
223 data->name = name ? g_strdup(name) : NULL;
224 data->owner = owner ? g_strdup(owner) : NULL;
225 data->path = g_strdup(path);
226 data->interface = g_strdup(interface);
227 data->member = g_strdup(member);
228 data->argument = g_strdup(argument);
230 if (!add_match(data, filter)) {
235 listeners = g_slist_append(listeners, data);
240 static struct filter_callback *filter_data_find_callback(
241 struct filter_data *data,
246 for (l = data->callbacks; l; l = l->next) {
247 struct filter_callback *cb = l->data;
251 for (l = data->processed; l; l = l->next) {
252 struct filter_callback *cb = l->data;
260 static void filter_data_free(struct filter_data *data)
264 for (l = data->callbacks; l != NULL; l = l->next)
267 g_slist_free(data->callbacks);
268 g_dbus_remove_watch(data->connection, data->name_watch);
272 g_free(data->interface);
273 g_free(data->member);
274 g_free(data->argument);
275 dbus_connection_unref(data->connection);
279 static void filter_data_call_and_free(struct filter_data *data)
283 for (l = data->callbacks; l != NULL; l = l->next) {
284 struct filter_callback *cb = l->data;
286 cb->disc_func(data->connection, cb->user_data);
287 if (cb->destroy_func)
288 cb->destroy_func(cb->user_data);
292 filter_data_free(data);
295 static struct filter_callback *filter_data_add_callback(
296 struct filter_data *data,
297 GDBusWatchFunction connect,
298 GDBusWatchFunction disconnect,
299 GDBusSignalFunction signal,
300 GDBusDestroyFunction destroy,
303 struct filter_callback *cb = NULL;
305 cb = g_new(struct filter_callback, 1);
307 cb->conn_func = connect;
308 cb->disc_func = disconnect;
309 cb->signal_func = signal;
310 cb->destroy_func = destroy;
311 cb->user_data = user_data;
312 cb->id = ++listener_id;
315 data->processed = g_slist_append(data->processed, cb);
317 data->callbacks = g_slist_append(data->callbacks, cb);
322 static gboolean filter_data_remove_callback(struct filter_data *data,
323 struct filter_callback *cb)
325 DBusConnection *connection;
327 data->callbacks = g_slist_remove(data->callbacks, cb);
328 data->processed = g_slist_remove(data->processed, cb);
330 if (cb->destroy_func)
331 cb->destroy_func(cb->user_data);
335 /* Don't remove the filter if other callbacks exist or data is lock
336 * processing callbacks */
337 if (data->callbacks || data->lock)
340 if (data->registered && !remove_match(data))
343 connection = dbus_connection_ref(data->connection);
344 listeners = g_slist_remove(listeners, data);
345 filter_data_free(data);
347 /* Remove filter if there are no listeners left for the connection */
348 data = filter_data_find(connection, NULL, NULL, NULL, NULL, NULL,
351 dbus_connection_remove_filter(connection, message_filter,
354 dbus_connection_unref(connection);
359 static DBusHandlerResult signal_filter(DBusConnection *connection,
360 DBusMessage *message, void *user_data)
362 struct filter_data *data = user_data;
363 struct filter_callback *cb;
365 while (data->callbacks) {
366 cb = data->callbacks->data;
368 if (cb->signal_func && !cb->signal_func(connection, message,
370 filter_data_remove_callback(data, cb);
374 /* Check if the watch was removed/freed by the callback
376 if (!g_slist_find(data->callbacks, cb))
379 data->callbacks = g_slist_remove(data->callbacks, cb);
380 data->processed = g_slist_append(data->processed, cb);
383 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
386 static void update_name_cache(const char *name, const char *owner)
390 for (l = listeners; l != NULL; l = l->next) {
391 struct filter_data *data = l->data;
393 if (g_strcmp0(data->name, name) != 0)
397 data->owner = g_strdup(owner);
401 static const char *check_name_cache(const char *name)
405 for (l = listeners; l != NULL; l = l->next) {
406 struct filter_data *data = l->data;
408 if (g_strcmp0(data->name, name) != 0)
417 static DBusHandlerResult service_filter(DBusConnection *connection,
418 DBusMessage *message, void *user_data)
420 struct filter_data *data = user_data;
421 struct filter_callback *cb;
422 char *name, *old, *new;
424 if (!dbus_message_get_args(message, NULL,
425 DBUS_TYPE_STRING, &name,
426 DBUS_TYPE_STRING, &old,
427 DBUS_TYPE_STRING, &new,
428 DBUS_TYPE_INVALID)) {
429 error("Invalid arguments for NameOwnerChanged signal");
430 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
433 update_name_cache(name, new);
435 while (data->callbacks) {
436 cb = data->callbacks->data;
440 cb->disc_func(connection, cb->user_data);
443 cb->conn_func(connection, cb->user_data);
446 /* Only auto remove if it is a bus name watch */
447 if (data->argument[0] == ':' &&
448 (!cb->conn_func || !cb->disc_func)) {
449 filter_data_remove_callback(data, cb);
453 /* Check if the watch was removed/freed by the callback
455 if (!g_slist_find(data->callbacks, cb))
458 data->callbacks = g_slist_remove(data->callbacks, cb);
459 data->processed = g_slist_append(data->processed, cb);
462 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
466 static DBusHandlerResult message_filter(DBusConnection *connection,
467 DBusMessage *message, void *user_data)
469 struct filter_data *data;
470 const char *sender, *path, *iface, *member, *arg = NULL;
472 /* Only filter signals */
473 if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
474 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
476 sender = dbus_message_get_sender(message);
477 path = dbus_message_get_path(message);
478 iface = dbus_message_get_interface(message);
479 member = dbus_message_get_member(message);
480 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID);
482 /* Sender is always bus name */
483 data = filter_data_find(connection, NULL, sender, path, iface, member,
486 error("Got %s.%s signal which has no listeners", iface, member);
487 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
490 if (data->handle_func) {
493 data->handle_func(connection, message, data);
495 data->callbacks = data->processed;
496 data->processed = NULL;
501 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
505 listeners = g_slist_remove(listeners, data);
506 filter_data_free(data);
508 /* Remove filter if there no listener left for the connection */
509 data = filter_data_find(connection, NULL, NULL, NULL, NULL, NULL,
512 dbus_connection_remove_filter(connection, message_filter,
515 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
518 struct service_data {
519 DBusConnection *conn;
522 GDBusWatchFunction conn_func;
526 static void service_data_free(struct service_data *data)
528 dbus_connection_unref(data->conn);
533 static gboolean update_service(void *user_data)
535 struct service_data *data = user_data;
537 update_name_cache(data->name, data->owner);
539 data->conn_func(data->conn, data->user_data);
541 service_data_free(data);
546 static void service_reply(DBusPendingCall *call, void *user_data)
548 struct service_data *data = user_data;
552 reply = dbus_pending_call_steal_reply(call);
556 dbus_error_init(&err);
558 if (dbus_set_error_from_message(&err, reply))
561 if (dbus_message_get_args(reply, &err,
562 DBUS_TYPE_STRING, &data->owner,
563 DBUS_TYPE_INVALID) == FALSE)
566 update_service(data);
571 error("%s", err.message);
572 dbus_error_free(&err);
573 service_data_free(data);
575 dbus_message_unref(reply);
578 static void check_service(DBusConnection *connection, const char *name,
579 GDBusWatchFunction connect, void *user_data)
581 DBusMessage *message;
582 DBusPendingCall *call;
583 struct service_data *data;
585 data = g_try_malloc0(sizeof(*data));
587 error("Can't allocate data structure");
591 data->conn = dbus_connection_ref(connection);
592 data->name = g_strdup(name);
593 data->conn_func = connect;
594 data->user_data = user_data;
596 data->owner = check_name_cache(name);
597 if (data->owner != NULL) {
598 g_idle_add(update_service, data);
602 message = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
603 DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner");
604 if (message == NULL) {
605 error("Can't allocate new message");
610 dbus_message_append_args(message, DBUS_TYPE_STRING, &name,
613 if (dbus_connection_send_with_reply(connection, message,
614 &call, -1) == FALSE) {
615 error("Failed to execute method call");
621 error("D-Bus connection not available");
626 dbus_pending_call_set_notify(call, service_reply, data, g_free);
628 dbus_pending_call_unref(call);
631 dbus_message_unref(message);
634 guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
635 GDBusWatchFunction connect,
636 GDBusWatchFunction disconnect,
637 void *user_data, GDBusDestroyFunction destroy)
639 struct filter_data *data;
640 struct filter_callback *cb;
645 data = filter_data_get(connection, service_filter, NULL, NULL,
646 DBUS_INTERFACE_DBUS, "NameOwnerChanged",
651 cb = filter_data_add_callback(data, connect, disconnect, NULL, NULL,
657 check_service(connection, name, connect, user_data);
662 guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
663 GDBusWatchFunction func,
664 void *user_data, GDBusDestroyFunction destroy)
666 return g_dbus_add_service_watch(connection, name, NULL, func,
670 guint g_dbus_add_signal_watch(DBusConnection *connection,
671 const char *sender, const char *path,
672 const char *interface, const char *member,
673 GDBusSignalFunction function, void *user_data,
674 GDBusDestroyFunction destroy)
676 struct filter_data *data;
677 struct filter_callback *cb;
679 data = filter_data_get(connection, signal_filter, sender, path,
680 interface, member, NULL);
684 cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
689 if (data->name != NULL && data->name_watch == 0)
690 data->name_watch = g_dbus_add_service_watch(connection,
697 gboolean g_dbus_remove_watch(DBusConnection *connection, guint id)
699 struct filter_data *data;
700 struct filter_callback *cb;
706 for (ldata = listeners; ldata; ldata = ldata->next) {
709 cb = filter_data_find_callback(data, id);
711 filter_data_remove_callback(data, cb);
719 void g_dbus_remove_all_watches(DBusConnection *connection)
721 struct filter_data *data;
723 while ((data = filter_data_find(connection, NULL, NULL, NULL, NULL,
725 listeners = g_slist_remove(listeners, data);
726 filter_data_call_and_free(data);
729 dbus_connection_remove_filter(connection, message_filter, NULL);