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 for (current = listeners;
127 current != NULL; current = current->next) {
128 struct filter_data *data = current->data;
130 if (connection != data->connection)
139 static void format_rule(struct filter_data *data, char *rule, size_t size)
144 offset = snprintf(rule, size, "type='signal'");
145 sender = data->name ? : data->owner;
148 offset += snprintf(rule + offset, size - offset,
149 ",sender='%s'", sender);
151 offset += snprintf(rule + offset, size - offset,
152 ",path='%s'", data->path);
154 offset += snprintf(rule + offset, size - offset,
155 ",interface='%s'", data->interface);
157 offset += snprintf(rule + offset, size - offset,
158 ",member='%s'", data->member);
160 snprintf(rule + offset, size - offset,
161 ",arg0='%s'", data->argument);
164 static gboolean add_match(struct filter_data *data,
165 DBusHandleMessageFunction filter)
168 char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
170 format_rule(data, rule, sizeof(rule));
171 dbus_error_init(&err);
173 dbus_bus_add_match(data->connection, rule, &err);
174 if (dbus_error_is_set(&err)) {
175 error("Adding match rule \"%s\" failed: %s", rule,
177 dbus_error_free(&err);
181 data->handle_func = filter;
182 data->registered = TRUE;
187 static gboolean remove_match(struct filter_data *data)
190 char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
192 format_rule(data, rule, sizeof(rule));
194 dbus_error_init(&err);
196 dbus_bus_remove_match(data->connection, rule, &err);
197 if (dbus_error_is_set(&err)) {
198 error("Removing owner match rule for %s failed: %s",
200 dbus_error_free(&err);
207 static struct filter_data *filter_data_get(DBusConnection *connection,
208 DBusHandleMessageFunction filter,
211 const char *interface,
213 const char *argument)
215 struct filter_data *data;
216 const char *name = NULL, *owner = NULL;
218 if (filter_data_find(connection) == NULL) {
219 if (!dbus_connection_add_filter(connection,
220 message_filter, NULL, NULL)) {
221 error("dbus_connection_add_filter() failed");
229 if (sender[0] == ':')
235 data = filter_data_find_match(connection, name, owner, path,
236 interface, member, argument);
240 data = g_new0(struct filter_data, 1);
242 data->connection = dbus_connection_ref(connection);
243 data->name = g_strdup(name);
244 data->owner = g_strdup(owner);
245 data->path = g_strdup(path);
246 data->interface = g_strdup(interface);
247 data->member = g_strdup(member);
248 data->argument = g_strdup(argument);
250 if (!add_match(data, filter)) {
255 listeners = g_slist_append(listeners, data);
260 static struct filter_callback *filter_data_find_callback(
261 struct filter_data *data,
266 for (l = data->callbacks; l; l = l->next) {
267 struct filter_callback *cb = l->data;
271 for (l = data->processed; l; l = l->next) {
272 struct filter_callback *cb = l->data;
280 static void filter_data_free(struct filter_data *data)
284 /* Remove filter if there are no listeners left for the connection */
285 if (filter_data_find(data->connection) == NULL)
286 dbus_connection_remove_filter(data->connection, message_filter,
289 for (l = data->callbacks; l != NULL; l = l->next)
292 g_slist_free(data->callbacks);
293 g_dbus_remove_watch(data->connection, data->name_watch);
297 g_free(data->interface);
298 g_free(data->member);
299 g_free(data->argument);
300 dbus_connection_unref(data->connection);
304 static void filter_data_call_and_free(struct filter_data *data)
308 for (l = data->callbacks; l != NULL; l = l->next) {
309 struct filter_callback *cb = l->data;
311 cb->disc_func(data->connection, cb->user_data);
312 if (cb->destroy_func)
313 cb->destroy_func(cb->user_data);
317 filter_data_free(data);
320 static struct filter_callback *filter_data_add_callback(
321 struct filter_data *data,
322 GDBusWatchFunction connect,
323 GDBusWatchFunction disconnect,
324 GDBusSignalFunction signal,
325 GDBusDestroyFunction destroy,
328 struct filter_callback *cb = NULL;
330 cb = g_new0(struct filter_callback, 1);
332 cb->conn_func = connect;
333 cb->disc_func = disconnect;
334 cb->signal_func = signal;
335 cb->destroy_func = destroy;
336 cb->user_data = user_data;
337 cb->id = ++listener_id;
340 data->processed = g_slist_append(data->processed, cb);
342 data->callbacks = g_slist_append(data->callbacks, cb);
347 static void service_data_free(struct service_data *data)
349 struct filter_callback *callback = data->callback;
351 dbus_connection_unref(data->conn);
354 dbus_pending_call_unref(data->call);
357 g_source_remove(data->id);
362 callback->data = NULL;
365 static gboolean filter_data_remove_callback(struct filter_data *data,
366 struct filter_callback *cb)
368 data->callbacks = g_slist_remove(data->callbacks, cb);
369 data->processed = g_slist_remove(data->processed, cb);
371 /* Cancel pending operations */
374 dbus_pending_call_cancel(cb->data->call);
375 service_data_free(cb->data);
378 if (cb->destroy_func)
379 cb->destroy_func(cb->user_data);
383 /* Don't remove the filter if other callbacks exist or data is lock
384 * processing callbacks */
385 if (data->callbacks || data->lock)
388 if (data->registered && !remove_match(data))
391 listeners = g_slist_remove(listeners, data);
392 filter_data_free(data);
397 static DBusHandlerResult signal_filter(DBusConnection *connection,
398 DBusMessage *message, void *user_data)
400 struct filter_data *data = user_data;
401 struct filter_callback *cb;
403 while (data->callbacks) {
404 cb = data->callbacks->data;
406 if (cb->signal_func && !cb->signal_func(connection, message,
408 filter_data_remove_callback(data, cb);
412 /* Check if the watch was removed/freed by the callback
414 if (!g_slist_find(data->callbacks, cb))
417 data->callbacks = g_slist_remove(data->callbacks, cb);
418 data->processed = g_slist_append(data->processed, cb);
421 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
424 static void update_name_cache(const char *name, const char *owner)
428 for (l = listeners; l != NULL; l = l->next) {
429 struct filter_data *data = l->data;
431 if (g_strcmp0(data->name, name) != 0)
435 data->owner = g_strdup(owner);
439 static const char *check_name_cache(const char *name)
443 for (l = listeners; l != NULL; l = l->next) {
444 struct filter_data *data = l->data;
446 if (g_strcmp0(data->name, name) != 0)
455 static DBusHandlerResult service_filter(DBusConnection *connection,
456 DBusMessage *message, void *user_data)
458 struct filter_data *data = user_data;
459 struct filter_callback *cb;
460 char *name, *old, *new;
462 if (!dbus_message_get_args(message, NULL,
463 DBUS_TYPE_STRING, &name,
464 DBUS_TYPE_STRING, &old,
465 DBUS_TYPE_STRING, &new,
466 DBUS_TYPE_INVALID)) {
467 error("Invalid arguments for NameOwnerChanged signal");
468 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
471 update_name_cache(name, new);
473 while (data->callbacks) {
474 cb = data->callbacks->data;
478 cb->disc_func(connection, cb->user_data);
481 cb->conn_func(connection, cb->user_data);
484 /* Check if the watch was removed/freed by the callback
486 if (!g_slist_find(data->callbacks, cb))
489 /* Only auto remove if it is a bus name watch */
490 if (data->argument[0] == ':' &&
491 (cb->conn_func == NULL || cb->disc_func == NULL)) {
492 filter_data_remove_callback(data, cb);
496 data->callbacks = g_slist_remove(data->callbacks, cb);
497 data->processed = g_slist_append(data->processed, cb);
500 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
504 static DBusHandlerResult message_filter(DBusConnection *connection,
505 DBusMessage *message, void *user_data)
507 struct filter_data *data;
508 const char *sender, *path, *iface, *member, *arg = NULL;
509 GSList *current, *delete_listener = NULL;
511 /* Only filter signals */
512 if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
513 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
515 sender = dbus_message_get_sender(message);
516 path = dbus_message_get_path(message);
517 iface = dbus_message_get_interface(message);
518 member = dbus_message_get_member(message);
519 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID);
521 /* Sender is always the owner */
523 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
525 for (current = listeners; current != NULL; current = current->next) {
526 data = current->data;
528 if (connection != data->connection)
531 if (data->owner && g_str_equal(sender, data->owner) == FALSE)
534 if (data->path && g_str_equal(path, data->path) == FALSE)
537 if (data->interface && g_str_equal(iface,
538 data->interface) == FALSE)
541 if (data->member && g_str_equal(member, data->member) == FALSE)
544 if (data->argument && g_str_equal(arg,
545 data->argument) == FALSE)
548 if (data->handle_func) {
551 data->handle_func(connection, message, data);
553 data->callbacks = data->processed;
554 data->processed = NULL;
558 if (!data->callbacks)
559 delete_listener = g_slist_prepend(delete_listener,
563 if (delete_listener == NULL)
564 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
566 for (current = delete_listener; current != NULL;
567 current = delete_listener->next) {
568 GSList *l = current->data;
572 /* Has any other callback added callbacks back to this data? */
573 if (data->callbacks != NULL)
577 listeners = g_slist_delete_link(listeners, l);
579 filter_data_free(data);
582 g_slist_free(delete_listener);
584 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
587 static gboolean update_service(void *user_data)
589 struct service_data *data = user_data;
590 struct filter_callback *cb = data->callback;
591 DBusConnection *conn;
593 update_name_cache(data->name, data->owner);
594 conn = dbus_connection_ref(data->conn);
595 service_data_free(data);
598 cb->conn_func(conn, cb->user_data);
600 dbus_connection_unref(conn);
605 static void service_reply(DBusPendingCall *call, void *user_data)
607 struct service_data *data = user_data;
611 reply = dbus_pending_call_steal_reply(call);
615 dbus_error_init(&err);
617 if (dbus_set_error_from_message(&err, reply))
620 if (dbus_message_get_args(reply, &err,
621 DBUS_TYPE_STRING, &data->owner,
622 DBUS_TYPE_INVALID) == FALSE)
625 update_service(data);
630 error("%s", err.message);
631 dbus_error_free(&err);
632 service_data_free(data);
634 dbus_message_unref(reply);
637 static void check_service(DBusConnection *connection,
639 struct filter_callback *callback)
641 DBusMessage *message;
642 struct service_data *data;
644 data = g_try_malloc0(sizeof(*data));
646 error("Can't allocate data structure");
650 data->conn = dbus_connection_ref(connection);
651 data->name = g_strdup(name);
652 data->callback = callback;
653 callback->data = data;
655 data->owner = check_name_cache(name);
656 if (data->owner != NULL) {
657 data->id = g_idle_add(update_service, data);
661 message = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
662 DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner");
663 if (message == NULL) {
664 error("Can't allocate new message");
669 dbus_message_append_args(message, DBUS_TYPE_STRING, &name,
672 if (dbus_connection_send_with_reply(connection, message,
673 &data->call, -1) == FALSE) {
674 error("Failed to execute method call");
679 if (data->call == NULL) {
680 error("D-Bus connection not available");
685 dbus_pending_call_set_notify(data->call, service_reply, data, NULL);
688 dbus_message_unref(message);
691 guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
692 GDBusWatchFunction connect,
693 GDBusWatchFunction disconnect,
694 void *user_data, GDBusDestroyFunction destroy)
696 struct filter_data *data;
697 struct filter_callback *cb;
702 data = filter_data_get(connection, service_filter, NULL, NULL,
703 DBUS_INTERFACE_DBUS, "NameOwnerChanged",
708 cb = filter_data_add_callback(data, connect, disconnect, NULL, destroy,
714 check_service(connection, name, cb);
719 guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
720 GDBusWatchFunction func,
721 void *user_data, GDBusDestroyFunction destroy)
723 return g_dbus_add_service_watch(connection, name, NULL, func,
727 guint g_dbus_add_signal_watch(DBusConnection *connection,
728 const char *sender, const char *path,
729 const char *interface, const char *member,
730 GDBusSignalFunction function, void *user_data,
731 GDBusDestroyFunction destroy)
733 struct filter_data *data;
734 struct filter_callback *cb;
736 data = filter_data_get(connection, signal_filter, sender, path,
737 interface, member, NULL);
741 cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
746 if (data->name != NULL && data->name_watch == 0)
747 data->name_watch = g_dbus_add_service_watch(connection,
754 guint g_dbus_add_properties_watch(DBusConnection *connection,
755 const char *sender, const char *path,
756 const char *interface,
757 GDBusSignalFunction function, void *user_data,
758 GDBusDestroyFunction destroy)
760 struct filter_data *data;
761 struct filter_callback *cb;
763 data = filter_data_get(connection, signal_filter, sender, path,
764 DBUS_INTERFACE_PROPERTIES, "PropertiesChanged",
769 cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
774 if (data->name != NULL && data->name_watch == 0)
775 data->name_watch = g_dbus_add_service_watch(connection,
782 gboolean g_dbus_remove_watch(DBusConnection *connection, guint id)
784 struct filter_data *data;
785 struct filter_callback *cb;
791 for (ldata = listeners; ldata; ldata = ldata->next) {
794 cb = filter_data_find_callback(data, id);
796 filter_data_remove_callback(data, cb);
804 void g_dbus_remove_all_watches(DBusConnection *connection)
806 struct filter_data *data;
808 while ((data = filter_data_find(connection))) {
809 listeners = g_slist_remove(listeners, data);
810 filter_data_call_and_free(data);