* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
- * Public License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* Author: David Zeuthen <davidz@redhat.com>
*/
*
* Convenience API for watching bus names.
*
- * <example id="gdbus-watching-names"><title>Simple application watching a name</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-watch-name.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
+ * A simple example for watching a name can be found in
+ * [gdbus-example-watch-name.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-watch-name.c)
*/
G_LOCK_DEFINE_STATIC (lock);
typedef struct
{
- volatile gint ref_count;
+ gint ref_count; /* (atomic) */
guint id;
gchar *name;
GBusNameWatcherFlags flags;
gboolean initialized;
} Client;
-static guint next_global_id = 1;
+/* Must be accessed atomically. */
+static guint next_global_id = 1; /* (atomic) */
+
+/* Must be accessed with @lock held. */
static GHashTable *map_id_to_client = NULL;
static Client *
}
g_free (client->name);
g_free (client->name_owner);
- if (client->main_context != NULL)
- g_main_context_unref (client->main_context);
+ g_main_context_unref (client->main_context);
if (client->user_data_free_func != NULL)
client->user_data_free_func (client->user_data);
g_free (client);
static void
actually_do_call (Client *client, GDBusConnection *connection, const gchar *name_owner, CallType call_type)
{
+ /* The client might have been cancelled (g_bus_unwatch_name()) while we were
+ * sitting in the #GMainContext dispatch queue. */
+ if (client->cancelled)
+ return;
+
switch (call_type)
{
case CALL_TYPE_NAME_APPEARED:
call_in_idle_cb,
data,
(GDestroyNotify) call_handler_data_free);
+ g_source_set_name (idle_source, "[gio, gdbusnamewatching.c] call_in_idle_cb");
g_source_attach (idle_source, client->main_context);
g_source_unref (idle_source);
}
static void
do_call (Client *client, CallType call_type)
{
+ GMainContext *current_context;
+
/* only schedule in idle if we're not in the right thread */
- if (g_main_context_get_thread_default () != client->main_context)
+ current_context = g_main_context_ref_thread_default ();
+ if (current_context != client->main_context)
schedule_call_in_idle (client, call_type);
else
actually_do_call (client, client->connection, client->name_owner, call_type);
+ g_main_context_unref (current_context);
}
static void
}
static void
-call_vanished_handler (Client *client,
- gboolean ignore_cancelled)
+call_vanished_handler (Client *client)
{
if (client->previous_call != PREVIOUS_CALL_VANISHED)
{
client->previous_call = PREVIOUS_CALL_VANISHED;
- if (((!client->cancelled) || ignore_cancelled) && client->name_vanished_handler != NULL)
+ if (!client->cancelled && client->name_vanished_handler != NULL)
{
do_call (client, CALL_TYPE_NAME_VANISHED);
}
/* ---------------------------------------------------------------------------------------------------- */
+/* Return a reference to the #Client for @watcher_id, or %NULL if it’s been
+ * unwatched. This is safe to call from any thread. */
+static Client *
+dup_client (guint watcher_id)
+{
+ Client *client;
+
+ G_LOCK (lock);
+
+ g_assert (watcher_id != 0);
+ g_assert (map_id_to_client != NULL);
+
+ client = g_hash_table_lookup (map_id_to_client, GUINT_TO_POINTER (watcher_id));
+
+ if (client != NULL)
+ client_ref (client);
+
+ G_UNLOCK (lock);
+
+ return client;
+}
+
+/* Could be called from any thread, so it could be called after client_unref()
+ * has started finalising the #Client. Avoid that by looking up the #Client
+ * atomically. */
static void
on_connection_disconnected (GDBusConnection *connection,
gboolean remote_peer_vanished,
GError *error,
gpointer user_data)
{
- Client *client = user_data;
+ guint watcher_id = GPOINTER_TO_UINT (user_data);
+ Client *client = NULL;
+
+ client = dup_client (watcher_id);
+ if (client == NULL)
+ return;
if (client->name_owner_changed_subscription_id > 0)
g_dbus_connection_signal_unsubscribe (client->connection, client->name_owner_changed_subscription_id);
client->name_owner_changed_subscription_id = 0;
client->connection = NULL;
- call_vanished_handler (client, FALSE);
+ call_vanished_handler (client);
+
+ client_unref (client);
}
/* ---------------------------------------------------------------------------------------------------- */
+/* Will always be called from the thread which acquired client->main_context. */
static void
on_name_owner_changed (GDBusConnection *connection,
const gchar *sender_name,
GVariant *parameters,
gpointer user_data)
{
- Client *client = user_data;
+ guint watcher_id = GPOINTER_TO_UINT (user_data);
+ Client *client = NULL;
const gchar *name;
const gchar *old_owner;
const gchar *new_owner;
+ client = dup_client (watcher_id);
+ if (client == NULL)
+ return;
+
if (!client->initialized)
goto out;
{
g_free (client->name_owner);
client->name_owner = NULL;
- call_vanished_handler (client, FALSE);
+ call_vanished_handler (client);
}
if (new_owner != NULL && strlen (new_owner) > 0)
}
out:
- ;
+ client_unref (client);
}
/* ---------------------------------------------------------------------------------------------------- */
}
else
{
- call_vanished_handler (client, FALSE);
+ call_vanished_handler (client);
}
client->initialized = TRUE;
else
{
g_warning ("Unexpected reply %d from StartServiceByName() method", start_service_result);
- call_vanished_handler (client, FALSE);
+ call_vanished_handler (client);
client->initialized = TRUE;
}
}
client->disconnected_signal_handler_id = g_signal_connect (client->connection,
"closed",
G_CALLBACK (on_connection_disconnected),
- client);
+ GUINT_TO_POINTER (client->id));
/* start listening to NameOwnerChanged messages immediately */
client->name_owner_changed_subscription_id = g_dbus_connection_signal_subscribe (client->connection,
client->name,
G_DBUS_SIGNAL_FLAGS_NONE,
on_name_owner_changed,
- client,
+ GUINT_TO_POINTER (client->id),
NULL);
if (client->flags & G_BUS_NAME_WATCHER_FLAGS_AUTO_START)
client->connection = g_bus_get_finish (res, NULL);
if (client->connection == NULL)
{
- call_vanished_handler (client, FALSE);
+ call_vanished_handler (client);
goto out;
}
* @bus_type: The type of bus to watch a name on.
* @name: The name (well-known or unique) to watch.
* @flags: Flags from the #GBusNameWatcherFlags enumeration.
- * @name_appeared_handler: Handler to invoke when @name is known to exist or %NULL.
- * @name_vanished_handler: Handler to invoke when @name is known to not exist or %NULL.
+ * @name_appeared_handler: (nullable): Handler to invoke when @name is known to exist or %NULL.
+ * @name_vanished_handler: (nullable): Handler to invoke when @name is known to not exist or %NULL.
* @user_data: User data to pass to handlers.
- * @user_data_free_func: Function for freeing @user_data or %NULL.
+ * @user_data_free_func: (nullable): Function for freeing @user_data or %NULL.
*
* Starts watching @name on the bus specified by @bus_type and calls
* @name_appeared_handler and @name_vanished_handler when the name is
- * known to have a owner respectively known to lose its
- * owner. Callbacks will be invoked in the <link
- * linkend="g-main-context-push-thread-default">thread-default main
- * loop</link> of the thread you are calling this function from.
+ * known to have an owner respectively known to lose its
+ * owner. Callbacks will be invoked in the
+ * [thread-default main context][g-main-context-push-thread-default]
+ * of the thread you are calling this function from.
*
* You are guaranteed that one of the handlers will be invoked after
* calling this function. When you are done watching the name, just
* guaranteed that the next time one of the handlers is invoked, it
* will be @name_vanished_handler. The reverse is also true.
*
- * This behavior makes it very simple to write applications that wants
- * to take action when a certain name exists, see <xref
- * linkend="gdbus-watching-names"/>. Basically, the application
- * should create object proxies in @name_appeared_handler and destroy
- * them again (if any) in @name_vanished_handler.
+ * This behavior makes it very simple to write applications that want
+ * to take action when a certain [name exists][gdbus-watching-names].
+ * Basically, the application should create object proxies in
+ * @name_appeared_handler and destroy them again (if any) in
+ * @name_vanished_handler.
*
- * Returns: An identifier (never 0) that an be used with
+ * Returns: An identifier (never 0) that can be used with
* g_bus_unwatch_name() to stop watching the name.
*
* Since: 2.26
client = g_new0 (Client, 1);
client->ref_count = 1;
- client->id = next_global_id++; /* TODO: uh oh, handle overflow */
+ client->id = (guint) g_atomic_int_add (&next_global_id, 1); /* TODO: uh oh, handle overflow */
client->name = g_strdup (name);
client->flags = flags;
client->name_appeared_handler = name_appeared_handler;
client->name_vanished_handler = name_vanished_handler;
client->user_data = user_data;
client->user_data_free_func = user_data_free_func;
- client->main_context = g_main_context_get_thread_default ();
- if (client->main_context != NULL)
- g_main_context_ref (client->main_context);
+ client->main_context = g_main_context_ref_thread_default ();
if (map_id_to_client == NULL)
{
* @connection: A #GDBusConnection.
* @name: The name (well-known or unique) to watch.
* @flags: Flags from the #GBusNameWatcherFlags enumeration.
- * @name_appeared_handler: Handler to invoke when @name is known to exist or %NULL.
- * @name_vanished_handler: Handler to invoke when @name is known to not exist or %NULL.
+ * @name_appeared_handler: (nullable): Handler to invoke when @name is known to exist or %NULL.
+ * @name_vanished_handler: (nullable): Handler to invoke when @name is known to not exist or %NULL.
* @user_data: User data to pass to handlers.
- * @user_data_free_func: Function for freeing @user_data or %NULL.
+ * @user_data_free_func: (nullable): Function for freeing @user_data or %NULL.
*
* Like g_bus_watch_name() but takes a #GDBusConnection instead of a
* #GBusType.
*
- * Returns: An identifier (never 0) that an be used with
+ * Returns: An identifier (never 0) that can be used with
* g_bus_unwatch_name() to stop watching the name.
*
* Since: 2.26
client = g_new0 (Client, 1);
client->ref_count = 1;
- client->id = next_global_id++; /* TODO: uh oh, handle overflow */
+ client->id = (guint) g_atomic_int_add (&next_global_id, 1); /* TODO: uh oh, handle overflow */
client->name = g_strdup (name);
client->flags = flags;
client->name_appeared_handler = name_appeared_handler;
client->name_vanished_handler = name_vanished_handler;
client->user_data = user_data;
client->user_data_free_func = user_data_free_func;
- client->main_context = g_main_context_get_thread_default ();
- if (client->main_context != NULL)
- g_main_context_ref (client->main_context);
+ client->main_context = g_main_context_ref_thread_default ();
if (map_id_to_client == NULL)
map_id_to_client = g_hash_table_new (g_direct_hash, g_direct_equal);
gpointer user_data)
{
WatchNameData *data = user_data;
- GValue params[3] = { { 0, }, { 0, }, { 0, } };
+ GValue params[3] = { G_VALUE_INIT, G_VALUE_INIT, G_VALUE_INIT };
g_value_init (¶ms[0], G_TYPE_DBUS_CONNECTION);
g_value_set_object (¶ms[0], connection);
gpointer user_data)
{
WatchNameData *data = user_data;
- GValue params[2] = { { 0, }, { 0, } };
+ GValue params[2] = { G_VALUE_INIT, G_VALUE_INIT };
g_value_init (¶ms[0], G_TYPE_DBUS_CONNECTION);
g_value_set_object (¶ms[0], connection);
}
/**
- * g_bus_watch_name_with_closures:
+ * g_bus_watch_name_with_closures: (rename-to g_bus_watch_name)
* @bus_type: The type of bus to watch a name on.
* @name: The name (well-known or unique) to watch.
* @flags: Flags from the #GBusNameWatcherFlags enumeration.
- * @name_appeared_closure: (allow-none): #GClosure to invoke when @name is known
+ * @name_appeared_closure: (nullable): #GClosure to invoke when @name is known
* to exist or %NULL.
- * @name_vanished_closure: (allow-none): #GClosure to invoke when @name is known
+ * @name_vanished_closure: (nullable): #GClosure to invoke when @name is known
* to not exist or %NULL.
*
* Version of g_bus_watch_name() using closures instead of callbacks for
* easier binding in other languages.
*
- * Returns: An identifier (never 0) that an be used with
+ * Returns: An identifier (never 0) that can be used with
* g_bus_unwatch_name() to stop watching the name.
*
- * Rename to: g_bus_watch_name
- *
* Since: 2.26
*/
guint
}
/**
- * g_bus_watch_name_on_connection_with_closures:
+ * g_bus_watch_name_on_connection_with_closures: (rename-to g_bus_watch_name_on_connection)
* @connection: A #GDBusConnection.
* @name: The name (well-known or unique) to watch.
* @flags: Flags from the #GBusNameWatcherFlags enumeration.
- * @name_appeared_closure: (allow-none): #GClosure to invoke when @name is known
+ * @name_appeared_closure: (nullable): #GClosure to invoke when @name is known
* to exist or %NULL.
- * @name_vanished_closure: (allow-none): #GClosure to invoke when @name is known
+ * @name_vanished_closure: (nullable): #GClosure to invoke when @name is known
* to not exist or %NULL.
*
* Version of g_bus_watch_name_on_connection() using closures instead of callbacks for
* easier binding in other languages.
*
- * Returns: An identifier (never 0) that an be used with
+ * Returns: An identifier (never 0) that can be used with
* g_bus_unwatch_name() to stop watching the name.
*
- * Rename to: g_bus_watch_name_on_connection
- *
* Since: 2.26
*/
guint g_bus_watch_name_on_connection_with_closures (
*
* Stops watching a name.
*
+ * Note that there may still be D-Bus traffic to process (relating to watching
+ * and unwatching the name) in the current thread-default #GMainContext after
+ * this function has returned. You should continue to iterate the #GMainContext
+ * until the #GDestroyNotify function passed to g_bus_watch_name() is called, in
+ * order to avoid memory leaks through callbacks queued on the #GMainContext
+ * after it’s stopped being iterated.
+ *
* Since: 2.26
*/
void
projects / platform / upstream / glib.git / blobdiff