From 3651eeda8e7c1fb324c84ff9d87d4981dfd6e50f Mon Sep 17 00:00:00 2001

From: Ray Strode <rstrode@redhat.com>

Date: Sun, 27 Sep 2020 01:06:37 -0400

Subject: [PATCH 13/15] libgdm: Fix client leaks from

 g_async_result_get_source_object

There are are few places in the code where the client object is

retrieved via g_async_result_get_source_object.  Those calls

return a fresh reference that is never unreferenced later.

This commit plugs those leaks by using g_autoptr's

---

 libgdm/gdm-client.c | 6 +++---

 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/libgdm/gdm-client.c b/libgdm/gdm-client.c

index f9e3faee2..66f6102ec 100644

--- a/libgdm/gdm-client.c

+++ b/libgdm/gdm-client.c

@@ -166,84 +166,84 @@ complete_user_verifier_proxy_operation (GdmClient          *client,

 {

         g_task_return_pointer (data->task,

                                g_object_ref (data->user_verifier),

                                (GDestroyNotify) g_object_unref);

         user_verifier_data_free (data);

 }

 static void

 maybe_complete_user_verifier_proxy_operation (GdmClient          *client,

                                               UserVerifierData   *data)

 {

         GHashTableIter iter;

         gpointer key, value;

         if (client->priv->user_verifier_extensions != NULL) {

                 g_hash_table_iter_init (&iter, client->priv->user_verifier_extensions);

                 while (g_hash_table_iter_next (&iter, &key, &value)) {

                         if (value == NULL)

                                 return;

                 }

         }

         complete_user_verifier_proxy_operation (client, data);

 }

 static void

 on_user_verifier_choice_list_proxy_created (GObject            *source,

                                             GAsyncResult       *result,

                                             UserVerifierData   *data)

 {

-        GdmClient                 *client;

+        g_autoptr(GdmClient)       client = NULL;

         GdmUserVerifierChoiceList *choice_list;

         g_autoptr(GError)          error = NULL;

         client = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (data->task)));

         choice_list = gdm_user_verifier_choice_list_proxy_new_finish (result, &error);

         if (choice_list == NULL) {

                 g_debug ("Couldn't create UserVerifier ChoiceList proxy: %s", error->message);

                 g_hash_table_remove (client->priv->user_verifier_extensions, gdm_user_verifier_choice_list_interface_info ()->name);

         } else {

                 g_hash_table_replace (client->priv->user_verifier_extensions, gdm_user_verifier_choice_list_interface_info ()->name, choice_list);

         }

         maybe_complete_user_verifier_proxy_operation (client, data);

 }

 static void

 on_user_verifier_extensions_enabled (GdmUserVerifier    *user_verifier,

                                      GAsyncResult       *result,

                                      UserVerifierData   *data)

 {

-        GdmClient *client;

+        g_autoptr(GdmClient)       client = NULL;

         GCancellable *cancellable;

         GDBusConnection *connection;

         g_autoptr(GError) error = NULL;

         size_t     i;

         client = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (data->task)));

         cancellable = g_task_get_cancellable (data->task);

         gdm_user_verifier_call_enable_extensions_finish (user_verifier, result, &error);

         if (error != NULL) {

                 g_debug ("Couldn't enable user verifier extensions: %s",

                          error->message);

                 complete_user_verifier_proxy_operation (client, data);

                 return;

         }

         connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (user_verifier));

         for (i = 0; client->priv->enabled_extensions[i] != NULL; i++) {

                 g_debug ("Enabled extensions[%lu] = %s", i, client->priv->enabled_extensions[i]);

                 g_hash_table_insert (client->priv->user_verifier_extensions, client->priv->enabled_extensions[i], NULL);

                 if (strcmp (client->priv->enabled_extensions[i],

                             gdm_user_verifier_choice_list_interface_info ()->name) == 0) {

                         g_hash_table_insert (client->priv->user_verifier_extensions, client->priv->enabled_extensions[i], NULL);

                         gdm_user_verifier_choice_list_proxy_new (connection,

                                                                  G_DBUS_PROXY_FLAGS_NONE,

                                                                  NULL,

                                                                  SESSION_DBUS_PATH,

@@ -252,61 +252,61 @@ on_user_verifier_extensions_enabled (GdmUserVerifier    *user_verifier,

                                                                  on_user_verifier_choice_list_proxy_created,

                                                                  data);

                 } else {

                         g_debug ("User verifier extension %s is unsupported", client->priv->enabled_extensions[i]);

                         g_hash_table_remove (client->priv->user_verifier_extensions,

                                              client->priv->enabled_extensions[i]);

                 }

         }

         if (g_hash_table_size (client->priv->user_verifier_extensions) == 0) {

                 g_debug ("No supported user verifier extensions");

                 complete_user_verifier_proxy_operation (client, data);

         }

 }

 static void

 free_interface_skeleton (GDBusInterfaceSkeleton *interface)

 {

         if (interface == NULL)

                 return;

         g_object_unref (interface);

 }

 static void

 on_user_verifier_proxy_created (GObject            *source,

                                 GAsyncResult       *result,

                                 gpointer            user_data)

 {

-        GdmClient       *self;

+        g_autoptr(GdmClient)       self = NULL;

         GCancellable    *cancellable = NULL;

         g_autoptr(GdmUserVerifier) user_verifier = NULL;

         g_autoptr(GTask)           task = user_data;

         g_autoptr(GError)          error = NULL;

         user_verifier = gdm_user_verifier_proxy_new_finish (result, &error);

         if (user_verifier == NULL) {

                 g_task_return_error (task, g_steal_pointer (&error));

                 return;

         }

         g_debug ("UserVerifier %p created", user_verifier);

         self = GDM_CLIENT (g_async_result_get_source_object (G_ASYNC_RESULT (task)));

         if (self->priv->enabled_extensions == NULL) {

                 g_debug ("no enabled extensions");

                 g_task_return_pointer (task,

                                        g_steal_pointer (&user_verifier),

                                        (GDestroyNotify) g_object_unref);

                 return;

         }

         self->priv->user_verifier_extensions = g_hash_table_new_full (g_str_hash,

                                                                       g_str_equal,

                                                                       NULL,

                                                                       (GDestroyNotify)

                                                                       free_interface_skeleton);

         cancellable = g_task_get_cancellable (task);

         gdm_user_verifier_call_enable_extensions (user_verifier,

                                                   (const char * const *)

-- 

2.25.1