text: /*
   *
   *  D-Bus helper library
   *
   *  Copyright (C) 2004-2011  Marcel Holtmann <marcel@holtmann.org>
   *
   *
   *  This program is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation; either version 2 of the License, or
   *  (at your option) any later version.
   *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
   *
   */
  
  #ifdef HAVE_CONFIG_H
  #include <config.h>
  #endif
  
  #include <stdio.h>
  #include <string.h>
  
  #include <glib.h>
  #include <dbus/dbus.h>
  
  #include "gdbus.h"
  
  #define info(fmt...)
  #define error(fmt...)
  #define debug(fmt...)
  
  static DBusHandlerResult message_filter(DBusConnection *connection,
  					DBusMessage *message, void *user_data);
  
  static guint listener_id = 0;
  static GSList *listeners = NULL;
  
  struct service_data {
  	DBusConnection *conn;
  	DBusPendingCall *call;
  	char *name;
  	const char *owner;
  	guint id;
  	struct filter_callback *callback;
  };
  
  struct filter_callback {
  	GDBusWatchFunction conn_func;
  	GDBusWatchFunction disc_func;
  	GDBusSignalFunction signal_func;
  	GDBusDestroyFunction destroy_func;
  	struct service_data *data;
  	void *user_data;
  	guint id;
  };
  
  struct filter_data {
  	DBusConnection *connection;
  	DBusHandleMessageFunction handle_func;
  	char *name;
  	char *owner;
  	char *path;
  	char *interface;
  	char *member;
  	char *argument;
  	GSList *callbacks;
  	GSList *processed;
  	guint name_watch;
  	gboolean lock;
  	gboolean registered;
  };
  
  static struct filter_data *filter_data_find_match(DBusConnection *connection,
  							const char *name,
  							const char *owner,
  							const char *path,
  							const char *interface,
  							const char *member,
  							const char *argument)
  {
  	GSList *current;
  
  	for (current = listeners;
  			current != NULL; current = current->next) {
  		struct filter_data *data = current->data;
  
  		if (connection != data->connection)
  			continue;
  
  		if (g_strcmp0(name, data->name) != 0)
  			continue;
  
  		if (g_strcmp0(owner, data->owner) != 0)
  			continue;
  
  		if (g_strcmp0(path, data->path) != 0)
  			continue;
  
  		if (g_strcmp0(interface, data->interface) != 0)
  			continue;
  
  		if (g_strcmp0(member, data->member) != 0)
  			continue;
  
  		if (g_strcmp0(argument, data->argument) != 0)
  			continue;
  
  		return data;
  	}
  
  	return NULL;
  }
  
  static struct filter_data *filter_data_find(DBusConnection *connection)
  {
  	GSList *current;
  
  	for (current = listeners;
  			current != NULL; current = current->next) {
  		struct filter_data *data = current->data;
  
  		if (connection != data->connection)
  			continue;
  
  		return data;
  	}
  
  	return NULL;
  }
  
  static void format_rule(struct filter_data *data, char *rule, size_t size)
  {
  	const char *sender;
  	int offset;
  
  	offset = snprintf(rule, size, "type='signal'");
  	sender = data->name ? : data->owner;
  
  	if (sender)
  		offset += snprintf(rule + offset, size - offset,
  				",sender='%s'", sender);
  	if (data->path)
  		offset += snprintf(rule + offset, size - offset,
  				",path='%s'", data->path);
  	if (data->interface)
  		offset += snprintf(rule + offset, size - offset,
  				",interface='%s'", data->interface);
  	if (data->member)
  		offset += snprintf(rule + offset, size - offset,
  				",member='%s'", data->member);
  	if (data->argument)
  		snprintf(rule + offset, size - offset,
  				",arg0='%s'", data->argument);
  }
  
  static gboolean add_match(struct filter_data *data,
  				DBusHandleMessageFunction filter)
  {
  	DBusError err;
  	char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
  
  	format_rule(data, rule, sizeof(rule));
  	dbus_error_init(&err);
  
  	dbus_bus_add_match(data->connection, rule, &err);
  	if (dbus_error_is_set(&err)) {
  		error("Adding match rule \"%s\" failed: %s", rule,
  				err.message);
  		dbus_error_free(&err);
  		return FALSE;
  	}
  
  	data->handle_func = filter;
  	data->registered = TRUE;
  
  	return TRUE;
  }
  
  static gboolean remove_match(struct filter_data *data)
  {
  	DBusError err;
  	char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
  
  	format_rule(data, rule, sizeof(rule));
  
  	dbus_error_init(&err);
  
  	dbus_bus_remove_match(data->connection, rule, &err);
  	if (dbus_error_is_set(&err)) {
  		error("Removing owner match rule for %s failed: %s",
  				rule, err.message);
  		dbus_error_free(&err);
  		return FALSE;
  	}
  
  	return TRUE;
  }
  
  static void filter_data_free(struct filter_data *data)
  {
  	GSList *l;
  
  	/* Remove filter if there are no listeners left for the connection */
  	if (filter_data_find(data->connection) == NULL)
  		dbus_connection_remove_filter(data->connection, message_filter,
  									NULL);
  
  	for (l = data->callbacks; l != NULL; l = l->next)
  		g_free(l->data);
  
  	g_slist_free(data->callbacks);
  	g_dbus_remove_watch(data->connection, data->name_watch);
  	g_free(data->name);
  	g_free(data->owner);
  	g_free(data->path);
  	g_free(data->interface);
  	g_free(data->member);
  	g_free(data->argument);
  	dbus_connection_unref(data->connection);
  	g_free(data);
  }
  
  static struct filter_data *filter_data_get(DBusConnection *connection,
  					DBusHandleMessageFunction filter,
  					const char *sender,
  					const char *path,
  					const char *interface,
  					const char *member,
  					const char *argument)
  {
  	struct filter_data *data;
  	const char *name = NULL, *owner = NULL;
  
  	if (filter_data_find(connection) == NULL) {
  		if (!dbus_connection_add_filter(connection,
  					message_filter, NULL, NULL)) {
  			error("dbus_connection_add_filter() failed");
  			return NULL;
  		}
  	}
  
  	if (sender == NULL)
  		goto proceed;
  
  	if (sender[0] == ':')
  		owner = sender;
  	else
  		name = sender;
  
  proceed:
  	data = filter_data_find_match(connection, name, owner, path,
  						interface, member, argument);
  	if (data)
  		return data;
  
  	data = g_new0(struct filter_data, 1);
  
  	data->connection = dbus_connection_ref(connection);
  	data->name = g_strdup(name);
  	data->owner = g_strdup(owner);
  	data->path = g_strdup(path);
  	data->interface = g_strdup(interface);
  	data->member = g_strdup(member);
  	data->argument = g_strdup(argument);
  
  	if (!add_match(data, filter)) {
  		filter_data_free(data);
  		return NULL;
  	}
  
  	listeners = g_slist_append(listeners, data);
  
  	return data;
  }
  
  static struct filter_callback *filter_data_find_callback(
  						struct filter_data *data,
  						guint id)
  {
  	GSList *l;
  
  	for (l = data->callbacks; l; l = l->next) {
  		struct filter_callback *cb = l->data;
  		if (cb->id == id)
  			return cb;
  	}
  	for (l = data->processed; l; l = l->next) {
  		struct filter_callback *cb = l->data;
  		if (cb->id == id)
  			return cb;
  	}
  
  	return NULL;
  }
  
  static void filter_data_call_and_free(struct filter_data *data)
  {
  	GSList *l;
  
  	for (l = data->callbacks; l != NULL; l = l->next) {
  		struct filter_callback *cb = l->data;
  		if (cb->disc_func)
  			cb->disc_func(data->connection, cb->user_data);
  		if (cb->destroy_func)
  			cb->destroy_func(cb->user_data);
  		g_free(cb);
  	}
  
  	filter_data_free(data);
  }
  
  static struct filter_callback *filter_data_add_callback(
  						struct filter_data *data,
  						GDBusWatchFunction connect,
  						GDBusWatchFunction disconnect,
  						GDBusSignalFunction signal,
  						GDBusDestroyFunction destroy,
  						void *user_data)
  {
  	struct filter_callback *cb = NULL;
  
  	cb = g_new0(struct filter_callback, 1);
  
  	cb->conn_func = connect;
  	cb->disc_func = disconnect;
  	cb->signal_func = signal;
  	cb->destroy_func = destroy;
  	cb->user_data = user_data;
  	cb->id = ++listener_id;
  
  	if (data->lock)
  		data->processed = g_slist_append(data->processed, cb);
  	else
  		data->callbacks = g_slist_append(data->callbacks, cb);
  
  	return cb;
  }
  
  static void service_data_free(struct service_data *data)
  {
  	struct filter_callback *callback = data->callback;
  
  	dbus_connection_unref(data->conn);
  
  	if (data->call)
  		dbus_pending_call_unref(data->call);
  
  	if (data->id)
  		g_source_remove(data->id);
  
  	g_free(data->name);
  	g_free(data);
  
  	callback->data = NULL;
  }
  
  /* Returns TRUE if data is freed */
  static gboolean filter_data_remove_callback(struct filter_data *data,
  						struct filter_callback *cb)
  {
  	data->callbacks = g_slist_remove(data->callbacks, cb);
  	data->processed = g_slist_remove(data->processed, cb);
  
  	/* Cancel pending operations */
  	if (cb->data) {
  		if (cb->data->call)
  			dbus_pending_call_cancel(cb->data->call);
  		service_data_free(cb->data);
  	}
  
  	if (cb->destroy_func)
  		cb->destroy_func(cb->user_data);
  
  	g_free(cb);
  
  	/* Don't remove the filter if other callbacks exist or data is lock
  	 * processing callbacks */
  	if (data->callbacks || data->lock)
  		return FALSE;
  
  	if (data->registered && !remove_match(data))
  		return FALSE;
  
  	listeners = g_slist_remove(listeners, data);
  	filter_data_free(data);
  
  	return TRUE;
  }
  
  static DBusHandlerResult signal_filter(DBusConnection *connection,
  					DBusMessage *message, void *user_data)
  {
  	struct filter_data *data = user_data;
  	struct filter_callback *cb;
  
  	while (data->callbacks) {
  		cb = data->callbacks->data;
  
  		if (cb->signal_func && !cb->signal_func(connection, message,
  							cb->user_data)) {
  			if (filter_data_remove_callback(data, cb))
  				break;
  
  			continue;
  		}
  
  		/* Check if the watch was removed/freed by the callback
  		 * function */
  		if (!g_slist_find(data->callbacks, cb))
  			continue;
  
  		data->callbacks = g_slist_remove(data->callbacks, cb);
  		data->processed = g_slist_append(data->processed, cb);
  	}
  
  	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  }
  
  static void update_name_cache(const char *name, const char *owner)
  {
  	GSList *l;
  
  	for (l = listeners; l != NULL; l = l->next) {
  		struct filter_data *data = l->data;
  
  		if (g_strcmp0(data->name, name) != 0)
  			continue;
  
  		g_free(data->owner);
  		data->owner = g_strdup(owner);
  	}
  }
  
  static const char *check_name_cache(const char *name)
  {
  	GSList *l;
  
  	for (l = listeners; l != NULL; l = l->next) {
  		struct filter_data *data = l->data;
  
  		if (g_strcmp0(data->name, name) != 0)
  			continue;
  
  		return data->owner;
  	}
  
  	return NULL;
  }
  
  static DBusHandlerResult service_filter(DBusConnection *connection,
  					DBusMessage *message, void *user_data)
  {
  	struct filter_data *data = user_data;
  	struct filter_callback *cb;
  	char *name, *old, *new;
  
  	if (!dbus_message_get_args(message, NULL,
  				DBUS_TYPE_STRING, &name,
  				DBUS_TYPE_STRING, &old,
  				DBUS_TYPE_STRING, &new,
  				DBUS_TYPE_INVALID)) {
  		error("Invalid arguments for NameOwnerChanged signal");
  		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  	}
  
  	update_name_cache(name, new);
  
  	while (data->callbacks) {
  		cb = data->callbacks->data;
  
  		if (*new == '\0') {
  			if (cb->disc_func)
  				cb->disc_func(connection, cb->user_data);
  		} else {
  			if (cb->conn_func)
  				cb->conn_func(connection, cb->user_data);
  		}
  
  		/* Check if the watch was removed/freed by the callback
  		 * function */
  		if (!g_slist_find(data->callbacks, cb))
  			continue;
  
  		/* Only auto remove if it is a bus name watch */
  		if (data->argument[0] == ':' &&
  				(cb->conn_func == NULL || cb->disc_func == NULL)) {
  			if (filter_data_remove_callback(data, cb))
  				break;
  
  			continue;
  		}
  
  		data->callbacks = g_slist_remove(data->callbacks, cb);
  		data->processed = g_slist_append(data->processed, cb);
  	}
  
  	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  }
  
  
  static DBusHandlerResult message_filter(DBusConnection *connection,
  					DBusMessage *message, void *user_data)
  {
  	struct filter_data *data;
  	const char *sender, *path, *iface, *member, *arg = NULL;
  	GSList *current, *delete_listener = NULL;
  
  	/* Only filter signals */
  	if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
  		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  
  	sender = dbus_message_get_sender(message);
  	path = dbus_message_get_path(message);
  	iface = dbus_message_get_interface(message);
  	member = dbus_message_get_member(message);
  	dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID);
  
  	/* If sender != NULL it is always the owner */
  
  	for (current = listeners; current != NULL; current = current->next) {
  		data = current->data;
  
  		if (connection != data->connection)
  			continue;
  
  		if (!sender && data->owner)
  			continue;
  
  		if (data->owner && g_str_equal(sender, data->owner) == FALSE)
  			continue;
  
  		if (data->path && g_str_equal(path, data->path) == FALSE)
  			continue;
  
  		if (data->interface && g_str_equal(iface,
  						data->interface) == FALSE)
  			continue;
  
  		if (data->member && g_str_equal(member, data->member) == FALSE)
  			continue;
  
  		if (data->argument && g_str_equal(arg,
  						data->argument) == FALSE)
  			continue;
  
  		if (data->handle_func) {
  			data->lock = TRUE;
  
  			data->handle_func(connection, message, data);
  
  			data->callbacks = data->processed;
  			data->processed = NULL;
  			data->lock = FALSE;
  		}
  
  		if (!data->callbacks)
  			delete_listener = g_slist_prepend(delete_listener,
  								current);
  	}
  
  	if (delete_listener == NULL)
  		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  
  	for (current = delete_listener; current != NULL;
  					current = delete_listener->next) {
  		GSList *l = current->data;
  
  		data = l->data;
  
  		/* Has any other callback added callbacks back to this data? */
  		if (data->callbacks != NULL)
  			continue;
  
  		remove_match(data);
  		listeners = g_slist_delete_link(listeners, l);
  
  		filter_data_free(data);
  	}
  
  	g_slist_free(delete_listener);
  
  	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  }
  
  static gboolean update_service(void *user_data)
  {
  	struct service_data *data = user_data;
  	struct filter_callback *cb = data->callback;
  	DBusConnection *conn;
  
  	conn = dbus_connection_ref(data->conn);
  	service_data_free(data);
  
  	if (cb->conn_func)
  		cb->conn_func(conn, cb->user_data);
  
  	dbus_connection_unref(conn);
  
  	return FALSE;
  }
  
  static void service_reply(DBusPendingCall *call, void *user_data)
  {
  	struct service_data *data = user_data;
  	DBusMessage *reply;
  	DBusError err;
  
  	reply = dbus_pending_call_steal_reply(call);
  	if (reply == NULL)
  		return;
  
  	dbus_error_init(&err);
  
  	if (dbus_set_error_from_message(&err, reply))
  		goto fail;
  
  	if (dbus_message_get_args(reply, &err,
  					DBUS_TYPE_STRING, &data->owner,
  						DBUS_TYPE_INVALID) == FALSE)
  		goto fail;
  
  	update_service(data);
  
  	goto done;
  
  fail:
  	error("%s", err.message);
  	dbus_error_free(&err);
  	service_data_free(data);
  done:
  	dbus_message_unref(reply);
  }
  
  static void check_service(DBusConnection *connection,
  					const char *name,
  					struct filter_callback *callback)
  {
  	DBusMessage *message;
  	struct service_data *data;
  
  	data = g_try_malloc0(sizeof(*data));
  	if (data == NULL) {
  		error("Can't allocate data structure");
  		return;
  	}
  
  	data->conn = dbus_connection_ref(connection);
  	data->name = g_strdup(name);
  	data->callback = callback;
  	callback->data = data;
  
  	data->owner = check_name_cache(name);
  	if (data->owner != NULL) {
  		data->id = g_idle_add(update_service, data);
  		return;
  	}
  
  	message = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
  			DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner");
  	if (message == NULL) {
  		error("Can't allocate new message");
  		g_free(data);
  		return;
  	}
  
  	dbus_message_append_args(message, DBUS_TYPE_STRING, &name,
  							DBUS_TYPE_INVALID);
  
  	if (dbus_connection_send_with_reply(connection, message,
  							&data->call, -1) == FALSE) {
  		error("Failed to execute method call");
  		g_free(data);
  		goto done;
  	}
  
  	if (data->call == NULL) {
  		error("D-Bus connection not available");
  		g_free(data);
  		goto done;
  	}
  
  	dbus_pending_call_set_notify(data->call, service_reply, data, NULL);
  
  done:
  	dbus_message_unref(message);
  }
  
  guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
  				GDBusWatchFunction connect,
  				GDBusWatchFunction disconnect,
  				void *user_data, GDBusDestroyFunction destroy)
  {
  	struct filter_data *data;
  	struct filter_callback *cb;
  
  	if (name == NULL)
  		return 0;
  
  	data = filter_data_get(connection, service_filter,
  				DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
  				DBUS_INTERFACE_DBUS, "NameOwnerChanged",
  				name);
  	if (data == NULL)
  		return 0;
  
  	cb = filter_data_add_callback(data, connect, disconnect, NULL, destroy,
  					user_data);
  	if (cb == NULL)
  		return 0;
  
  	if (connect)
  		check_service(connection, name, cb);
  
  	return cb->id;
  }
  
  guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
  				GDBusWatchFunction func,
  				void *user_data, GDBusDestroyFunction destroy)
  {
  	return g_dbus_add_service_watch(connection, name, NULL, func,
  							user_data, destroy);
  }
  
  guint g_dbus_add_signal_watch(DBusConnection *connection,
  				const char *sender, const char *path,
  				const char *interface, const char *member,
  				GDBusSignalFunction function, void *user_data,
  				GDBusDestroyFunction destroy)
  {
  	struct filter_data *data;
  	struct filter_callback *cb;
  
  	data = filter_data_get(connection, signal_filter, sender, path,
  				interface, member, NULL);
  	if (data == NULL)
  		return 0;
  
  	cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
  					user_data);
  	if (cb == NULL)
  		return 0;
  
  	if (data->name != NULL && data->name_watch == 0)
  		data->name_watch = g_dbus_add_service_watch(connection,
  							data->name, NULL,
  							NULL, NULL, NULL);
  
  	return cb->id;
  }
  
  guint g_dbus_add_properties_watch(DBusConnection *connection,
  				const char *sender, const char *path,
  				const char *interface,
  				GDBusSignalFunction function, void *user_data,
  				GDBusDestroyFunction destroy)
  {
  	struct filter_data *data;
  	struct filter_callback *cb;
  
  	data = filter_data_get(connection, signal_filter, sender, path,
  				DBUS_INTERFACE_PROPERTIES, "PropertiesChanged",
  				interface);
  	if (data == NULL)
  		return 0;
  
  	cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
  					user_data);
  	if (cb == NULL)
  		return 0;
  
  	if (data->name != NULL && data->name_watch == 0)
  		data->name_watch = g_dbus_add_service_watch(connection,
  							data->name, NULL,
  							NULL, NULL, NULL);
  
  	return cb->id;
  }
  
  gboolean g_dbus_remove_watch(DBusConnection *connection, guint id)
  {
  	struct filter_data *data;
  	struct filter_callback *cb;
  	GSList *ldata;
  
  	if (id == 0)
  		return FALSE;
  
  	for (ldata = listeners; ldata; ldata = ldata->next) {
  		data = ldata->data;
  
  		cb = filter_data_find_callback(data, id);
  		if (cb) {
  			filter_data_remove_callback(data, cb);
  			return TRUE;
  		}
  	}
  
  	return FALSE;
  }
  
  void g_dbus_remove_all_watches(DBusConnection *connection)
  {
  	struct filter_data *data;
  
  	while ((data = filter_data_find(connection))) {
  		listeners = g_slist_remove(listeners, data);
  		filter_data_call_and_free(data);
  	}
  }
  