5 * Copyright (C) 2004-2011 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;
48 DBusPendingCall *call;
52 struct filter_callback *callback;
55 struct filter_callback {
56 GDBusWatchFunction conn_func;
57 GDBusWatchFunction disc_func;
58 GDBusSignalFunction signal_func;
59 GDBusDestroyFunction destroy_func;
60 struct service_data *data;
66 DBusConnection *connection;
67 DBusHandleMessageFunction handle_func;
81 static struct filter_data *filter_data_find_match(DBusConnection *connection,
85 const char *interface,
91 for (current = listeners;
92 current != NULL; current = current->next) {
93 struct filter_data *data = current->data;
95 if (connection != data->connection)
98 if (g_strcmp0(name, data->name) != 0)
101 if (g_strcmp0(owner, data->owner) != 0)
104 if (g_strcmp0(path, data->path) != 0)
107 if (g_strcmp0(interface, data->interface) != 0)
110 if (g_strcmp0(member, data->member) != 0)
113 if (g_strcmp0(argument, data->argument) != 0)
122 static struct filter_data *filter_data_find(DBusConnection *connection,
126 const char *interface,
128 const char *argument)
132 for (current = listeners;
133 current != NULL; current = current->next) {
134 struct filter_data *data = current->data;
136 if (connection != data->connection)
139 if (name && data->name &&
140 g_str_equal(name, data->name) == FALSE)
143 if (owner && data->owner &&
144 g_str_equal(owner, data->owner) == FALSE)
147 if (path && data->path &&
148 g_str_equal(path, data->path) == FALSE)
151 if (interface && data->interface &&
152 g_str_equal(interface, data->interface) == FALSE)
155 if (member && data->member &&
156 g_str_equal(member, data->member) == FALSE)
159 if (argument && data->argument &&
160 g_str_equal(argument, data->argument) == FALSE)
169 static void format_rule(struct filter_data *data, char *rule, size_t size)
174 offset = snprintf(rule, size, "type='signal'");
175 sender = data->name ? : data->owner;
178 offset += snprintf(rule + offset, size - offset,
179 ",sender='%s'", sender);
181 offset += snprintf(rule + offset, size - offset,
182 ",path='%s'", data->path);
184 offset += snprintf(rule + offset, size - offset,
185 ",interface='%s'", data->interface);
187 offset += snprintf(rule + offset, size - offset,
188 ",member='%s'", data->member);
190 snprintf(rule + offset, size - offset,
191 ",arg0='%s'", data->argument);
194 static gboolean add_match(struct filter_data *data,
195 DBusHandleMessageFunction filter)
198 char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
200 format_rule(data, rule, sizeof(rule));
201 dbus_error_init(&err);
203 dbus_bus_add_match(data->connection, rule, &err);
204 if (dbus_error_is_set(&err)) {
205 error("Adding match rule \"%s\" failed: %s", rule,
207 dbus_error_free(&err);
211 data->handle_func = filter;
212 data->registered = TRUE;
217 static gboolean remove_match(struct filter_data *data)
220 char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
222 format_rule(data, rule, sizeof(rule));
224 dbus_error_init(&err);
226 dbus_bus_remove_match(data->connection, rule, &err);
227 if (dbus_error_is_set(&err)) {
228 error("Removing owner match rule for %s failed: %s",
230 dbus_error_free(&err);
237 static struct filter_data *filter_data_get(DBusConnection *connection,
238 DBusHandleMessageFunction filter,
241 const char *interface,
243 const char *argument)
245 struct filter_data *data;
246 const char *name = NULL, *owner = NULL;
248 if (filter_data_find(connection, NULL, NULL, NULL, NULL, NULL, NULL) == NULL) {
249 if (!dbus_connection_add_filter(connection,
250 message_filter, NULL, NULL)) {
251 error("dbus_connection_add_filter() failed");
259 if (sender[0] == ':')
265 data = filter_data_find_match(connection, name, owner, path,
266 interface, member, argument);
270 data = g_new0(struct filter_data, 1);
272 data->connection = dbus_connection_ref(connection);
273 data->name = name ? g_strdup(name) : NULL;
274 data->owner = owner ? g_strdup(owner) : NULL;
275 data->path = g_strdup(path);
276 data->interface = g_strdup(interface);
277 data->member = g_strdup(member);
278 data->argument = g_strdup(argument);
280 if (!add_match(data, filter)) {
285 listeners = g_slist_append(listeners, data);
290 static struct filter_callback *filter_data_find_callback(
291 struct filter_data *data,
296 for (l = data->callbacks; l; l = l->next) {
297 struct filter_callback *cb = l->data;
301 for (l = data->processed; l; l = l->next) {
302 struct filter_callback *cb = l->data;
310 static void filter_data_free(struct filter_data *data)
314 for (l = data->callbacks; l != NULL; l = l->next)
317 g_slist_free(data->callbacks);
318 g_dbus_remove_watch(data->connection, data->name_watch);
322 g_free(data->interface);
323 g_free(data->member);
324 g_free(data->argument);
325 dbus_connection_unref(data->connection);
329 static void filter_data_call_and_free(struct filter_data *data)
333 for (l = data->callbacks; l != NULL; l = l->next) {
334 struct filter_callback *cb = l->data;
336 cb->disc_func(data->connection, cb->user_data);
337 if (cb->destroy_func)
338 cb->destroy_func(cb->user_data);
342 filter_data_free(data);
345 static struct filter_callback *filter_data_add_callback(
346 struct filter_data *data,
347 GDBusWatchFunction connect,
348 GDBusWatchFunction disconnect,
349 GDBusSignalFunction signal,
350 GDBusDestroyFunction destroy,
353 struct filter_callback *cb = NULL;
355 cb = g_new0(struct filter_callback, 1);
357 cb->conn_func = connect;
358 cb->disc_func = disconnect;
359 cb->signal_func = signal;
360 cb->destroy_func = destroy;
361 cb->user_data = user_data;
362 cb->id = ++listener_id;
365 data->processed = g_slist_append(data->processed, cb);
367 data->callbacks = g_slist_append(data->callbacks, cb);
372 static void service_data_free(struct service_data *data)
374 struct filter_callback *callback = data->callback;
376 dbus_connection_unref(data->conn);
379 dbus_pending_call_unref(data->call);
382 g_source_remove(data->id);
387 callback->data = NULL;
390 static gboolean filter_data_remove_callback(struct filter_data *data,
391 struct filter_callback *cb)
393 DBusConnection *connection;
395 data->callbacks = g_slist_remove(data->callbacks, cb);
396 data->processed = g_slist_remove(data->processed, cb);
398 /* Cancel pending operations */
401 dbus_pending_call_cancel(cb->data->call);
402 service_data_free(cb->data);
405 if (cb->destroy_func)
406 cb->destroy_func(cb->user_data);
410 /* Don't remove the filter if other callbacks exist or data is lock
411 * processing callbacks */
412 if (data->callbacks || data->lock)
415 if (data->registered && !remove_match(data))
418 connection = dbus_connection_ref(data->connection);
419 listeners = g_slist_remove(listeners, data);
421 /* Remove filter if there are no listeners left for the connection */
422 if (filter_data_find(connection, NULL, NULL, NULL, NULL, NULL,
424 dbus_connection_remove_filter(connection, message_filter,
427 filter_data_free(data);
428 dbus_connection_unref(connection);
433 static DBusHandlerResult signal_filter(DBusConnection *connection,
434 DBusMessage *message, void *user_data)
436 struct filter_data *data = user_data;
437 struct filter_callback *cb;
439 while (data->callbacks) {
440 cb = data->callbacks->data;
442 if (cb->signal_func && !cb->signal_func(connection, message,
444 filter_data_remove_callback(data, cb);
448 /* Check if the watch was removed/freed by the callback
450 if (!g_slist_find(data->callbacks, cb))
453 data->callbacks = g_slist_remove(data->callbacks, cb);
454 data->processed = g_slist_append(data->processed, cb);
457 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
460 static void update_name_cache(const char *name, const char *owner)
464 for (l = listeners; l != NULL; l = l->next) {
465 struct filter_data *data = l->data;
467 if (g_strcmp0(data->name, name) != 0)
471 data->owner = g_strdup(owner);
475 static const char *check_name_cache(const char *name)
479 for (l = listeners; l != NULL; l = l->next) {
480 struct filter_data *data = l->data;
482 if (g_strcmp0(data->name, name) != 0)
491 static DBusHandlerResult service_filter(DBusConnection *connection,
492 DBusMessage *message, void *user_data)
494 struct filter_data *data = user_data;
495 struct filter_callback *cb;
496 char *name, *old, *new;
498 if (!dbus_message_get_args(message, NULL,
499 DBUS_TYPE_STRING, &name,
500 DBUS_TYPE_STRING, &old,
501 DBUS_TYPE_STRING, &new,
502 DBUS_TYPE_INVALID)) {
503 error("Invalid arguments for NameOwnerChanged signal");
504 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
507 update_name_cache(name, new);
509 while (data->callbacks) {
510 cb = data->callbacks->data;
514 cb->disc_func(connection, cb->user_data);
517 cb->conn_func(connection, cb->user_data);
520 /* Check if the watch was removed/freed by the callback
522 if (!g_slist_find(data->callbacks, cb))
525 /* Only auto remove if it is a bus name watch */
526 if (data->argument[0] == ':' &&
527 (cb->conn_func == NULL || cb->disc_func == NULL)) {
528 filter_data_remove_callback(data, cb);
532 data->callbacks = g_slist_remove(data->callbacks, cb);
533 data->processed = g_slist_append(data->processed, cb);
536 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
540 static DBusHandlerResult message_filter(DBusConnection *connection,
541 DBusMessage *message, void *user_data)
543 struct filter_data *data;
544 const char *sender, *path, *iface, *member, *arg = NULL;
545 GSList *current, *delete_listener = NULL;
547 /* Only filter signals */
548 if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
549 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
551 sender = dbus_message_get_sender(message);
552 path = dbus_message_get_path(message);
553 iface = dbus_message_get_interface(message);
554 member = dbus_message_get_member(message);
555 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID);
557 /* Sender is always the owner */
559 for (current = listeners; current != NULL; current = current->next) {
560 data = current->data;
562 if (connection != data->connection)
565 if (data->owner && g_str_equal(sender, data->owner) == FALSE)
568 if (data->path && g_str_equal(path, data->path) == FALSE)
571 if (data->interface && g_str_equal(iface,
572 data->interface) == FALSE)
575 if (data->member && g_str_equal(member, data->member) == FALSE)
578 if (data->argument && g_str_equal(arg,
579 data->argument) == FALSE)
582 if (data->handle_func) {
585 data->handle_func(connection, message, data);
587 data->callbacks = data->processed;
588 data->processed = NULL;
592 if (!data->callbacks)
593 delete_listener = g_slist_prepend(delete_listener,
597 for (current = delete_listener; current != NULL;
598 current = delete_listener->next) {
599 GSList *l = current->data;
603 /* Has any other callback added callbacks back to this data? */
604 if (data->callbacks != NULL)
608 listeners = g_slist_remove_link(listeners, l);
610 filter_data_free(data);
613 g_slist_free(delete_listener);
615 /* Remove filter if there are no listeners left for the connection */
616 if (filter_data_find(connection, NULL, NULL, NULL, NULL, NULL,
618 dbus_connection_remove_filter(connection, message_filter,
621 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
624 static gboolean update_service(void *user_data)
626 struct service_data *data = user_data;
627 struct filter_callback *cb = data->callback;
629 update_name_cache(data->name, data->owner);
631 cb->conn_func(data->conn, cb->user_data);
633 service_data_free(data);
638 static void service_reply(DBusPendingCall *call, void *user_data)
640 struct service_data *data = user_data;
644 reply = dbus_pending_call_steal_reply(call);
648 dbus_error_init(&err);
650 if (dbus_set_error_from_message(&err, reply))
653 if (dbus_message_get_args(reply, &err,
654 DBUS_TYPE_STRING, &data->owner,
655 DBUS_TYPE_INVALID) == FALSE)
658 update_service(data);
663 error("%s", err.message);
664 dbus_error_free(&err);
665 service_data_free(data);
667 dbus_message_unref(reply);
670 static void check_service(DBusConnection *connection,
672 struct filter_callback *callback)
674 DBusMessage *message;
675 struct service_data *data;
677 data = g_try_malloc0(sizeof(*data));
679 error("Can't allocate data structure");
683 data->conn = dbus_connection_ref(connection);
684 data->name = g_strdup(name);
685 data->callback = callback;
686 callback->data = data;
688 data->owner = check_name_cache(name);
689 if (data->owner != NULL) {
690 data->id = g_idle_add(update_service, data);
694 message = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
695 DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner");
696 if (message == NULL) {
697 error("Can't allocate new message");
702 dbus_message_append_args(message, DBUS_TYPE_STRING, &name,
705 if (dbus_connection_send_with_reply(connection, message,
706 &data->call, -1) == FALSE) {
707 error("Failed to execute method call");
712 if (data->call == NULL) {
713 error("D-Bus connection not available");
718 dbus_pending_call_set_notify(data->call, service_reply, data, NULL);
721 dbus_message_unref(message);
724 guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
725 GDBusWatchFunction connect,
726 GDBusWatchFunction disconnect,
727 void *user_data, GDBusDestroyFunction destroy)
729 struct filter_data *data;
730 struct filter_callback *cb;
735 data = filter_data_get(connection, service_filter, NULL, NULL,
736 DBUS_INTERFACE_DBUS, "NameOwnerChanged",
741 cb = filter_data_add_callback(data, connect, disconnect, NULL, destroy,
747 check_service(connection, name, cb);
752 guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
753 GDBusWatchFunction func,
754 void *user_data, GDBusDestroyFunction destroy)
756 return g_dbus_add_service_watch(connection, name, NULL, func,
760 guint g_dbus_add_signal_watch(DBusConnection *connection,
761 const char *sender, const char *path,
762 const char *interface, const char *member,
763 GDBusSignalFunction function, void *user_data,
764 GDBusDestroyFunction destroy)
766 struct filter_data *data;
767 struct filter_callback *cb;
769 data = filter_data_get(connection, signal_filter, sender, path,
770 interface, member, NULL);
774 cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
779 if (data->name != NULL && data->name_watch == 0)
780 data->name_watch = g_dbus_add_service_watch(connection,
787 gboolean g_dbus_remove_watch(DBusConnection *connection, guint id)
789 struct filter_data *data;
790 struct filter_callback *cb;
796 for (ldata = listeners; ldata; ldata = ldata->next) {
799 cb = filter_data_find_callback(data, id);
801 filter_data_remove_callback(data, cb);
809 void g_dbus_remove_all_watches(DBusConnection *connection)
811 struct filter_data *data;
813 while ((data = filter_data_find(connection, NULL, NULL, NULL, NULL,
815 listeners = g_slist_remove(listeners, data);
816 filter_data_call_and_free(data);
819 dbus_connection_remove_filter(connection, message_filter, NULL);