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(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 (name && data->name &&
99 g_str_equal(name, data->name) == FALSE)
102 if (owner && data->owner &&
103 g_str_equal(owner, data->owner) == FALSE)
106 if (path && data->path &&
107 g_str_equal(path, data->path) == FALSE)
110 if (interface && data->interface &&
111 g_str_equal(interface, data->interface) == FALSE)
114 if (member && data->member &&
115 g_str_equal(member, data->member) == FALSE)
118 if (argument && data->argument &&
119 g_str_equal(argument, data->argument) == FALSE)
128 static void format_rule(struct filter_data *data, char *rule, size_t size)
133 offset = snprintf(rule, size, "type='signal'");
134 sender = data->name ? : data->owner;
137 offset += snprintf(rule + offset, size - offset,
138 ",sender='%s'", sender);
140 offset += snprintf(rule + offset, size - offset,
141 ",path='%s'", data->path);
143 offset += snprintf(rule + offset, size - offset,
144 ",interface='%s'", data->interface);
146 offset += snprintf(rule + offset, size - offset,
147 ",member='%s'", data->member);
149 snprintf(rule + offset, size - offset,
150 ",arg0='%s'", data->argument);
153 static gboolean add_match(struct filter_data *data,
154 DBusHandleMessageFunction filter)
157 char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
159 format_rule(data, rule, sizeof(rule));
160 dbus_error_init(&err);
162 dbus_bus_add_match(data->connection, rule, &err);
163 if (dbus_error_is_set(&err)) {
164 error("Adding match rule \"%s\" failed: %s", rule,
166 dbus_error_free(&err);
170 data->handle_func = filter;
171 data->registered = TRUE;
176 static gboolean remove_match(struct filter_data *data)
179 char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
181 format_rule(data, rule, sizeof(rule));
183 dbus_error_init(&err);
185 dbus_bus_remove_match(data->connection, rule, &err);
186 if (dbus_error_is_set(&err)) {
187 error("Removing owner match rule for %s failed: %s",
189 dbus_error_free(&err);
196 static struct filter_data *filter_data_get(DBusConnection *connection,
197 DBusHandleMessageFunction filter,
200 const char *interface,
202 const char *argument)
204 struct filter_data *data;
205 const char *name = NULL, *owner = NULL;
207 if (filter_data_find(connection, NULL, NULL, NULL, NULL, NULL, NULL) == NULL) {
208 if (!dbus_connection_add_filter(connection,
209 message_filter, NULL, NULL)) {
210 error("dbus_connection_add_filter() failed");
218 if (sender[0] == ':')
224 data = filter_data_find(connection, name, owner, path, interface,
229 data = g_new0(struct filter_data, 1);
231 data->connection = dbus_connection_ref(connection);
232 data->name = name ? g_strdup(name) : NULL;
233 data->owner = owner ? g_strdup(owner) : NULL;
234 data->path = g_strdup(path);
235 data->interface = g_strdup(interface);
236 data->member = g_strdup(member);
237 data->argument = g_strdup(argument);
239 if (!add_match(data, filter)) {
244 listeners = g_slist_append(listeners, data);
249 static struct filter_callback *filter_data_find_callback(
250 struct filter_data *data,
255 for (l = data->callbacks; l; l = l->next) {
256 struct filter_callback *cb = l->data;
260 for (l = data->processed; l; l = l->next) {
261 struct filter_callback *cb = l->data;
269 static void filter_data_free(struct filter_data *data)
273 for (l = data->callbacks; l != NULL; l = l->next)
276 g_slist_free(data->callbacks);
277 g_dbus_remove_watch(data->connection, data->name_watch);
281 g_free(data->interface);
282 g_free(data->member);
283 g_free(data->argument);
284 dbus_connection_unref(data->connection);
288 static void filter_data_call_and_free(struct filter_data *data)
292 for (l = data->callbacks; l != NULL; l = l->next) {
293 struct filter_callback *cb = l->data;
295 cb->disc_func(data->connection, cb->user_data);
296 if (cb->destroy_func)
297 cb->destroy_func(cb->user_data);
301 filter_data_free(data);
304 static struct filter_callback *filter_data_add_callback(
305 struct filter_data *data,
306 GDBusWatchFunction connect,
307 GDBusWatchFunction disconnect,
308 GDBusSignalFunction signal,
309 GDBusDestroyFunction destroy,
312 struct filter_callback *cb = NULL;
314 cb = g_new0(struct filter_callback, 1);
316 cb->conn_func = connect;
317 cb->disc_func = disconnect;
318 cb->signal_func = signal;
319 cb->destroy_func = destroy;
320 cb->user_data = user_data;
321 cb->id = ++listener_id;
324 data->processed = g_slist_append(data->processed, cb);
326 data->callbacks = g_slist_append(data->callbacks, cb);
331 static void service_data_free(struct service_data *data)
333 struct filter_callback *callback = data->callback;
335 dbus_connection_unref(data->conn);
338 dbus_pending_call_unref(data->call);
341 g_source_remove(data->id);
346 callback->data = NULL;
349 static gboolean filter_data_remove_callback(struct filter_data *data,
350 struct filter_callback *cb)
352 DBusConnection *connection;
354 data->callbacks = g_slist_remove(data->callbacks, cb);
355 data->processed = g_slist_remove(data->processed, cb);
357 /* Cancel pending operations */
360 dbus_pending_call_cancel(cb->data->call);
361 service_data_free(cb->data);
364 if (cb->destroy_func)
365 cb->destroy_func(cb->user_data);
369 /* Don't remove the filter if other callbacks exist or data is lock
370 * processing callbacks */
371 if (data->callbacks || data->lock)
374 if (data->registered && !remove_match(data))
377 connection = dbus_connection_ref(data->connection);
378 listeners = g_slist_remove(listeners, data);
380 /* Remove filter if there are no listeners left for the connection */
381 if (filter_data_find(connection, NULL, NULL, NULL, NULL, NULL,
383 dbus_connection_remove_filter(connection, message_filter,
386 filter_data_free(data);
387 dbus_connection_unref(connection);
392 static DBusHandlerResult signal_filter(DBusConnection *connection,
393 DBusMessage *message, void *user_data)
395 struct filter_data *data = user_data;
396 struct filter_callback *cb;
398 while (data->callbacks) {
399 cb = data->callbacks->data;
401 if (cb->signal_func && !cb->signal_func(connection, message,
403 filter_data_remove_callback(data, cb);
407 /* Check if the watch was removed/freed by the callback
409 if (!g_slist_find(data->callbacks, cb))
412 data->callbacks = g_slist_remove(data->callbacks, cb);
413 data->processed = g_slist_append(data->processed, cb);
416 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
419 static void update_name_cache(const char *name, const char *owner)
423 for (l = listeners; l != NULL; l = l->next) {
424 struct filter_data *data = l->data;
426 if (g_strcmp0(data->name, name) != 0)
430 data->owner = g_strdup(owner);
434 static const char *check_name_cache(const char *name)
438 for (l = listeners; l != NULL; l = l->next) {
439 struct filter_data *data = l->data;
441 if (g_strcmp0(data->name, name) != 0)
450 static DBusHandlerResult service_filter(DBusConnection *connection,
451 DBusMessage *message, void *user_data)
453 struct filter_data *data = user_data;
454 struct filter_callback *cb;
455 char *name, *old, *new;
457 if (!dbus_message_get_args(message, NULL,
458 DBUS_TYPE_STRING, &name,
459 DBUS_TYPE_STRING, &old,
460 DBUS_TYPE_STRING, &new,
461 DBUS_TYPE_INVALID)) {
462 error("Invalid arguments for NameOwnerChanged signal");
463 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
466 update_name_cache(name, new);
468 while (data->callbacks) {
469 cb = data->callbacks->data;
473 cb->disc_func(connection, cb->user_data);
476 cb->conn_func(connection, cb->user_data);
479 /* Check if the watch was removed/freed by the callback
481 if (!g_slist_find(data->callbacks, cb))
484 /* Only auto remove if it is a bus name watch */
485 if (data->argument[0] == ':' &&
486 (cb->conn_func == NULL || cb->disc_func == NULL)) {
487 filter_data_remove_callback(data, cb);
491 data->callbacks = g_slist_remove(data->callbacks, cb);
492 data->processed = g_slist_append(data->processed, cb);
495 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
499 static DBusHandlerResult message_filter(DBusConnection *connection,
500 DBusMessage *message, void *user_data)
502 struct filter_data *data;
503 const char *sender, *path, *iface, *member, *arg = NULL;
505 /* Only filter signals */
506 if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
507 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
509 sender = dbus_message_get_sender(message);
510 path = dbus_message_get_path(message);
511 iface = dbus_message_get_interface(message);
512 member = dbus_message_get_member(message);
513 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID);
515 /* Sender is always bus name */
516 data = filter_data_find(connection, NULL, sender, path, iface, member,
519 error("Got %s.%s signal which has no listeners", iface, member);
520 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
523 if (data->handle_func) {
526 data->handle_func(connection, message, data);
528 data->callbacks = data->processed;
529 data->processed = NULL;
534 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
538 listeners = g_slist_remove(listeners, data);
540 /* Remove filter if there are no listeners left for the connection */
541 if (filter_data_find(connection, NULL, NULL, NULL, NULL, NULL,
543 dbus_connection_remove_filter(connection, message_filter,
546 filter_data_free(data);
548 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
551 static gboolean update_service(void *user_data)
553 struct service_data *data = user_data;
554 struct filter_callback *cb = data->callback;
556 update_name_cache(data->name, data->owner);
558 cb->conn_func(data->conn, cb->user_data);
560 service_data_free(data);
565 static void service_reply(DBusPendingCall *call, void *user_data)
567 struct service_data *data = user_data;
571 reply = dbus_pending_call_steal_reply(call);
575 dbus_error_init(&err);
577 if (dbus_set_error_from_message(&err, reply))
580 if (dbus_message_get_args(reply, &err,
581 DBUS_TYPE_STRING, &data->owner,
582 DBUS_TYPE_INVALID) == FALSE)
585 update_service(data);
590 error("%s", err.message);
591 dbus_error_free(&err);
592 service_data_free(data);
594 dbus_message_unref(reply);
597 static void check_service(DBusConnection *connection,
599 struct filter_callback *callback)
601 DBusMessage *message;
602 struct service_data *data;
604 data = g_try_malloc0(sizeof(*data));
606 error("Can't allocate data structure");
610 data->conn = dbus_connection_ref(connection);
611 data->name = g_strdup(name);
612 data->callback = callback;
613 callback->data = data;
615 data->owner = check_name_cache(name);
616 if (data->owner != NULL) {
617 data->id = g_idle_add(update_service, data);
621 message = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
622 DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner");
623 if (message == NULL) {
624 error("Can't allocate new message");
629 dbus_message_append_args(message, DBUS_TYPE_STRING, &name,
632 if (dbus_connection_send_with_reply(connection, message,
633 &data->call, -1) == FALSE) {
634 error("Failed to execute method call");
639 if (data->call == NULL) {
640 error("D-Bus connection not available");
645 dbus_pending_call_set_notify(data->call, service_reply, data, NULL);
648 dbus_message_unref(message);
651 guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
652 GDBusWatchFunction connect,
653 GDBusWatchFunction disconnect,
654 void *user_data, GDBusDestroyFunction destroy)
656 struct filter_data *data;
657 struct filter_callback *cb;
662 data = filter_data_get(connection, service_filter, NULL, NULL,
663 DBUS_INTERFACE_DBUS, "NameOwnerChanged",
668 cb = filter_data_add_callback(data, connect, disconnect, NULL, destroy,
674 check_service(connection, name, cb);
679 guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
680 GDBusWatchFunction func,
681 void *user_data, GDBusDestroyFunction destroy)
683 return g_dbus_add_service_watch(connection, name, NULL, func,
687 guint g_dbus_add_signal_watch(DBusConnection *connection,
688 const char *sender, const char *path,
689 const char *interface, const char *member,
690 GDBusSignalFunction function, void *user_data,
691 GDBusDestroyFunction destroy)
693 struct filter_data *data;
694 struct filter_callback *cb;
696 data = filter_data_get(connection, signal_filter, sender, path,
697 interface, member, NULL);
701 cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
706 if (data->name != NULL && data->name_watch == 0)
707 data->name_watch = g_dbus_add_service_watch(connection,
714 gboolean g_dbus_remove_watch(DBusConnection *connection, guint id)
716 struct filter_data *data;
717 struct filter_callback *cb;
723 for (ldata = listeners; ldata; ldata = ldata->next) {
726 cb = filter_data_find_callback(data, id);
728 filter_data_remove_callback(data, cb);
736 void g_dbus_remove_all_watches(DBusConnection *connection)
738 struct filter_data *data;
740 while ((data = filter_data_find(connection, NULL, NULL, NULL, NULL,
742 listeners = g_slist_remove(listeners, data);
743 filter_data_call_and_free(data);
746 dbus_connection_remove_filter(connection, message_filter, NULL);