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 #if defined TIZEN_EXT
140 #define SENDER_PREFIX ",sender='%s'"
141 #define PATH_PREFIX ",path='%s'"
142 #define IFACE_PREFIX ",interface='%s'"
143 #define MEMBER_PREFIX ",member='%s'"
144 #define ARG0_PREFIX ",arg0='%s'"
146 static gboolean check_rule_length(int remains, const char *prefix, const char *data)
148 if (!prefix || !data)
151 return strlen(prefix) - 2 + strlen(data) < remains;
154 static void format_rule(struct filter_data *data, char *rule, size_t size)
159 offset = snprintf(rule, size, "type='signal'");
160 sender = data->name ? : data->owner;
163 check_rule_length(size - offset, SENDER_PREFIX, sender))
164 offset += snprintf(rule + offset, size - offset,
165 SENDER_PREFIX, sender);
167 check_rule_length(size - offset, PATH_PREFIX, data->path))
168 offset += snprintf(rule + offset, size - offset,
169 PATH_PREFIX, data->path);
170 if (data->interface &&
171 check_rule_length(size - offset, IFACE_PREFIX, data->interface))
172 offset += snprintf(rule + offset, size - offset,
173 IFACE_PREFIX, data->interface);
175 check_rule_length(size - offset, MEMBER_PREFIX, data->member))
176 offset += snprintf(rule + offset, size - offset,
177 MEMBER_PREFIX, data->member);
178 if (data->argument &&
179 check_rule_length(size - offset, ARG0_PREFIX, data->argument))
180 snprintf(rule + offset, size - offset,
181 ARG0_PREFIX, data->argument);
184 static void format_rule(struct filter_data *data, char *rule, size_t size)
189 offset = snprintf(rule, size, "type='signal'");
190 sender = data->name ? : data->owner;
193 offset += snprintf(rule + offset, size - offset,
194 ",sender='%s'", sender);
196 offset += snprintf(rule + offset, size - offset,
197 ",path='%s'", data->path);
199 offset += snprintf(rule + offset, size - offset,
200 ",interface='%s'", data->interface);
202 offset += snprintf(rule + offset, size - offset,
203 ",member='%s'", data->member);
205 snprintf(rule + offset, size - offset,
206 ",arg0='%s'", data->argument);
210 static gboolean add_match(struct filter_data *data,
211 DBusHandleMessageFunction filter)
214 char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
216 format_rule(data, rule, sizeof(rule));
217 dbus_error_init(&err);
219 dbus_bus_add_match(data->connection, rule, &err);
220 if (dbus_error_is_set(&err)) {
221 error("Adding match rule \"%s\" failed: %s", rule,
223 dbus_error_free(&err);
227 data->handle_func = filter;
228 data->registered = TRUE;
233 static gboolean remove_match(struct filter_data *data)
236 char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
238 format_rule(data, rule, sizeof(rule));
240 dbus_error_init(&err);
242 dbus_bus_remove_match(data->connection, rule, &err);
243 if (dbus_error_is_set(&err)) {
244 error("Removing owner match rule for %s failed: %s",
246 dbus_error_free(&err);
253 static void filter_data_free(struct filter_data *data)
257 /* Remove filter if there are no listeners left for the connection */
258 if (filter_data_find(data->connection) == NULL)
259 dbus_connection_remove_filter(data->connection, message_filter,
262 for (l = data->callbacks; l != NULL; l = l->next)
265 g_slist_free(data->callbacks);
266 g_dbus_remove_watch(data->connection, data->name_watch);
270 g_free(data->interface);
271 g_free(data->member);
272 g_free(data->argument);
273 dbus_connection_unref(data->connection);
277 static struct filter_data *filter_data_get(DBusConnection *connection,
278 DBusHandleMessageFunction filter,
281 const char *interface,
283 const char *argument)
285 struct filter_data *data;
286 const char *name = NULL, *owner = NULL;
288 if (filter_data_find(connection) == NULL) {
289 if (!dbus_connection_add_filter(connection,
290 message_filter, NULL, NULL)) {
291 error("dbus_connection_add_filter() failed");
299 if (sender[0] == ':')
305 data = filter_data_find_match(connection, name, owner, path,
306 interface, member, argument);
310 data = g_new0(struct filter_data, 1);
312 data->connection = dbus_connection_ref(connection);
313 data->name = g_strdup(name);
314 data->owner = g_strdup(owner);
315 data->path = g_strdup(path);
316 data->interface = g_strdup(interface);
317 data->member = g_strdup(member);
318 data->argument = g_strdup(argument);
320 if (!add_match(data, filter)) {
321 filter_data_free(data);
325 listeners = g_slist_append(listeners, data);
330 static struct filter_callback *filter_data_find_callback(
331 struct filter_data *data,
336 for (l = data->callbacks; l; l = l->next) {
337 struct filter_callback *cb = l->data;
341 for (l = data->processed; l; l = l->next) {
342 struct filter_callback *cb = l->data;
350 static void filter_data_call_and_free(struct filter_data *data)
354 for (l = data->callbacks; l != NULL; l = l->next) {
355 struct filter_callback *cb = l->data;
357 cb->disc_func(data->connection, cb->user_data);
358 if (cb->destroy_func)
359 cb->destroy_func(cb->user_data);
363 filter_data_free(data);
366 static struct filter_callback *filter_data_add_callback(
367 struct filter_data *data,
368 GDBusWatchFunction connect,
369 GDBusWatchFunction disconnect,
370 GDBusSignalFunction signal,
371 GDBusDestroyFunction destroy,
374 struct filter_callback *cb = NULL;
376 cb = g_new0(struct filter_callback, 1);
378 cb->conn_func = connect;
379 cb->disc_func = disconnect;
380 cb->signal_func = signal;
381 cb->destroy_func = destroy;
382 cb->user_data = user_data;
383 cb->id = ++listener_id;
386 data->processed = g_slist_append(data->processed, cb);
388 data->callbacks = g_slist_append(data->callbacks, cb);
393 static void service_data_free(struct service_data *data)
395 struct filter_callback *callback = data->callback;
397 dbus_connection_unref(data->conn);
400 dbus_pending_call_unref(data->call);
403 g_source_remove(data->id);
408 callback->data = NULL;
411 /* Returns TRUE if data is freed */
412 static gboolean filter_data_remove_callback(struct filter_data *data,
413 struct filter_callback *cb)
415 data->callbacks = g_slist_remove(data->callbacks, cb);
416 data->processed = g_slist_remove(data->processed, cb);
418 /* Cancel pending operations */
421 dbus_pending_call_cancel(cb->data->call);
422 service_data_free(cb->data);
425 if (cb->destroy_func)
426 cb->destroy_func(cb->user_data);
430 /* Don't remove the filter if other callbacks exist or data is lock
431 * processing callbacks */
432 if (data->callbacks || data->lock)
435 if (data->registered && !remove_match(data))
438 listeners = g_slist_remove(listeners, data);
439 filter_data_free(data);
444 static DBusHandlerResult signal_filter(DBusConnection *connection,
445 DBusMessage *message, void *user_data)
447 struct filter_data *data = user_data;
448 struct filter_callback *cb;
450 while (data->callbacks) {
451 cb = data->callbacks->data;
453 if (cb->signal_func && !cb->signal_func(connection, message,
455 if (filter_data_remove_callback(data, cb))
461 /* Check if the watch was removed/freed by the callback
463 if (!g_slist_find(data->callbacks, cb))
466 data->callbacks = g_slist_remove(data->callbacks, cb);
467 data->processed = g_slist_append(data->processed, cb);
470 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
473 static void update_name_cache(const char *name, const char *owner)
477 for (l = listeners; l != NULL; l = l->next) {
478 struct filter_data *data = l->data;
480 if (g_strcmp0(data->name, name) != 0)
484 data->owner = g_strdup(owner);
488 static const char *check_name_cache(const char *name)
492 for (l = listeners; l != NULL; l = l->next) {
493 struct filter_data *data = l->data;
495 if (g_strcmp0(data->name, name) != 0)
504 static DBusHandlerResult service_filter(DBusConnection *connection,
505 DBusMessage *message, void *user_data)
507 struct filter_data *data = user_data;
508 struct filter_callback *cb;
509 char *name, *old, *new;
511 if (!dbus_message_get_args(message, NULL,
512 DBUS_TYPE_STRING, &name,
513 DBUS_TYPE_STRING, &old,
514 DBUS_TYPE_STRING, &new,
515 DBUS_TYPE_INVALID)) {
516 error("Invalid arguments for NameOwnerChanged signal");
517 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
520 update_name_cache(name, new);
522 while (data->callbacks) {
523 cb = data->callbacks->data;
527 cb->disc_func(connection, cb->user_data);
530 cb->conn_func(connection, cb->user_data);
533 /* Check if the watch was removed/freed by the callback
535 if (!g_slist_find(data->callbacks, cb))
538 /* Only auto remove if it is a bus name watch */
539 if (data->argument[0] == ':' &&
540 (cb->conn_func == NULL || cb->disc_func == NULL)) {
541 if (filter_data_remove_callback(data, cb))
547 data->callbacks = g_slist_remove(data->callbacks, cb);
548 data->processed = g_slist_append(data->processed, cb);
551 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
555 static DBusHandlerResult message_filter(DBusConnection *connection,
556 DBusMessage *message, void *user_data)
558 struct filter_data *data;
559 const char *sender, *path, *iface, *member, *arg = NULL;
560 GSList *current, *delete_listener = NULL;
562 /* Only filter signals */
563 if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
564 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
566 sender = dbus_message_get_sender(message);
567 path = dbus_message_get_path(message);
568 iface = dbus_message_get_interface(message);
569 member = dbus_message_get_member(message);
570 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID);
572 /* If sender != NULL it is always the owner */
574 for (current = listeners; current != NULL; current = current->next) {
575 data = current->data;
577 if (connection != data->connection)
580 if (!sender && data->owner)
583 if (data->owner && g_str_equal(sender, data->owner) == FALSE)
586 if (data->path && g_str_equal(path, data->path) == FALSE)
589 if (data->interface && g_str_equal(iface,
590 data->interface) == FALSE)
593 if (data->member && g_str_equal(member, data->member) == FALSE)
596 if (data->argument && g_str_equal(arg,
597 data->argument) == FALSE)
600 if (data->handle_func) {
603 data->handle_func(connection, message, data);
605 data->callbacks = data->processed;
606 data->processed = NULL;
610 if (!data->callbacks)
611 delete_listener = g_slist_prepend(delete_listener,
615 if (delete_listener == NULL)
616 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
618 for (current = delete_listener; current != NULL;
619 current = delete_listener->next) {
620 GSList *l = current->data;
624 /* Has any other callback added callbacks back to this data? */
625 if (data->callbacks != NULL)
629 listeners = g_slist_delete_link(listeners, l);
631 filter_data_free(data);
634 g_slist_free(delete_listener);
636 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
639 static gboolean update_service(void *user_data)
641 struct service_data *data = user_data;
642 struct filter_callback *cb = data->callback;
643 DBusConnection *conn;
645 conn = dbus_connection_ref(data->conn);
646 service_data_free(data);
649 cb->conn_func(conn, cb->user_data);
651 dbus_connection_unref(conn);
656 static void service_reply(DBusPendingCall *call, void *user_data)
658 struct service_data *data = user_data;
662 reply = dbus_pending_call_steal_reply(call);
666 dbus_error_init(&err);
668 if (dbus_set_error_from_message(&err, reply))
671 if (dbus_message_get_args(reply, &err,
672 DBUS_TYPE_STRING, &data->owner,
673 DBUS_TYPE_INVALID) == FALSE)
676 update_service(data);
681 error("%s", err.message);
682 dbus_error_free(&err);
683 service_data_free(data);
685 dbus_message_unref(reply);
688 static void check_service(DBusConnection *connection,
690 struct filter_callback *callback)
692 DBusMessage *message;
693 struct service_data *data;
695 data = g_try_malloc0(sizeof(*data));
697 error("Can't allocate data structure");
701 data->conn = dbus_connection_ref(connection);
702 data->name = g_strdup(name);
703 data->callback = callback;
704 callback->data = data;
706 data->owner = check_name_cache(name);
707 if (data->owner != NULL) {
708 data->id = g_idle_add(update_service, data);
712 message = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
713 DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner");
714 if (message == NULL) {
715 error("Can't allocate new message");
720 dbus_message_append_args(message, DBUS_TYPE_STRING, &name,
723 if (dbus_connection_send_with_reply(connection, message,
724 &data->call, -1) == FALSE) {
725 error("Failed to execute method call");
730 if (data->call == NULL) {
731 error("D-Bus connection not available");
736 dbus_pending_call_set_notify(data->call, service_reply, data, NULL);
739 dbus_message_unref(message);
742 guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
743 GDBusWatchFunction connect,
744 GDBusWatchFunction disconnect,
745 void *user_data, GDBusDestroyFunction destroy)
747 struct filter_data *data;
748 struct filter_callback *cb;
753 data = filter_data_get(connection, service_filter,
754 DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
755 DBUS_INTERFACE_DBUS, "NameOwnerChanged",
760 cb = filter_data_add_callback(data, connect, disconnect, NULL, destroy,
766 check_service(connection, name, cb);
771 guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
772 GDBusWatchFunction func,
773 void *user_data, GDBusDestroyFunction destroy)
775 return g_dbus_add_service_watch(connection, name, NULL, func,
779 guint g_dbus_add_signal_watch(DBusConnection *connection,
780 const char *sender, const char *path,
781 const char *interface, const char *member,
782 GDBusSignalFunction function, void *user_data,
783 GDBusDestroyFunction destroy)
785 struct filter_data *data;
786 struct filter_callback *cb;
788 data = filter_data_get(connection, signal_filter, sender, path,
789 interface, member, NULL);
793 cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
798 if (data->name != NULL && data->name_watch == 0)
799 data->name_watch = g_dbus_add_service_watch(connection,
806 guint g_dbus_add_properties_watch(DBusConnection *connection,
807 const char *sender, const char *path,
808 const char *interface,
809 GDBusSignalFunction function, void *user_data,
810 GDBusDestroyFunction destroy)
812 struct filter_data *data;
813 struct filter_callback *cb;
815 data = filter_data_get(connection, signal_filter, sender, path,
816 DBUS_INTERFACE_PROPERTIES, "PropertiesChanged",
821 cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
826 if (data->name != NULL && data->name_watch == 0)
827 data->name_watch = g_dbus_add_service_watch(connection,
834 gboolean g_dbus_remove_watch(DBusConnection *connection, guint id)
836 struct filter_data *data;
837 struct filter_callback *cb;
843 for (ldata = listeners; ldata; ldata = ldata->next) {
846 cb = filter_data_find_callback(data, id);
848 filter_data_remove_callback(data, cb);
856 void g_dbus_remove_all_watches(DBusConnection *connection)
858 struct filter_data *data;
860 while ((data = filter_data_find(connection))) {
861 listeners = g_slist_remove(listeners, data);
862 filter_data_call_and_free(data);