From 1a590b855f5b5d323334b49707778d4ee88ba873 Mon Sep 17 00:00:00 2001

From: Ray Strode <rstrode@redhat.com>

Date: Mon, 14 May 2018 15:57:14 -0400

Subject: [PATCH 02/15] libgdm: don't keep manager proxy around longer than we

 need it

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

Right now we keep the manager proxy alive long after we need it.

It doesn't get cleared until one of the other proxies go away.

That is not only unnecessary but illogical and confusing.

This commit changes the manager proxy to be transient—only alive

long enough to get what we need from it.

https://bugzilla.gnome.org/show_bug.cgi?id=795940

---

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

 1 file changed, 26 insertions(+), 93 deletions(-)

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

index 06dfe725e..e02e3ea57 100644

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

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

@@ -13,150 +13,130 @@

  * 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 Street, Fifth Floor, Boston, MA 02110-1301, USA.

  *

  */

 #include "config.h"

 #include <stdlib.h>

 #include <stdio.h>

 #include <unistd.h>

 #include <string.h>

 #include <glib.h>

 #include <glib/gi18n.h>

 #include <glib-object.h>

 #include "gdm-client.h"

 #include "gdm-client-glue.h"

 #include "gdm-manager-glue.h"

 #define GDM_CLIENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GDM_TYPE_CLIENT, GdmClientPrivate))

 #define SESSION_DBUS_PATH      "/org/gnome/DisplayManager/Session"

 struct GdmClientPrivate

 {

-        GdmManager         *manager;

-

         GdmUserVerifier    *user_verifier;

         GHashTable         *user_verifier_extensions;

         GdmGreeter         *greeter;

         GdmRemoteGreeter   *remote_greeter;

         GdmChooser         *chooser;

         GDBusConnection    *connection;

         char               *address;

         char              **enabled_extensions;

 };

 static void     gdm_client_class_init  (GdmClientClass *klass);

 static void     gdm_client_init        (GdmClient      *client);

 static void     gdm_client_finalize    (GObject        *object);

 G_DEFINE_TYPE (GdmClient, gdm_client, G_TYPE_OBJECT);

 static gpointer client_object = NULL;

 GQuark

 gdm_client_error_quark (void)

 {

         static GQuark error_quark = 0;

         if (error_quark == 0)

                 error_quark = g_quark_from_static_string ("gdm-client");

         return error_quark;

 }

 static void

-on_got_manager (GdmManager          *manager,

+on_got_manager (GObject             *object,

                 GAsyncResult        *result,

                 GTask               *task)

 {

         GdmClient *client;

-        GdmManager       *new_manager;

-        GError           *error;

+        GError    *error;

+        g_autoptr(GdmManager) manager = NULL;

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

         error = NULL;

-        new_manager = gdm_manager_proxy_new_finish (result, &error);

-

-        if (client->priv->manager == NULL) {

-                client->priv->manager = new_manager;

-

-        } else {

-                g_object_ref (client->priv->manager);

-                g_object_unref (new_manager);

-

-                g_clear_error (&error);

-        }

+        manager = gdm_manager_proxy_new_finish (result, &error);

         if (error != NULL) {

                 g_task_return_error (task, error);

         } else {

                 g_task_return_pointer (task,

-                                       g_object_ref (client->priv->manager),

+                                       g_object_ref (manager),

                                        (GDestroyNotify) g_object_unref);

         }

         g_object_unref (task);

         g_object_unref (client);

 }

 static void

 get_manager (GdmClient           *client,

              GCancellable        *cancellable,

              GAsyncReadyCallback  callback,

              gpointer             user_data)

 {

         GTask *task;

         task = g_task_new (G_OBJECT (client),

                            cancellable,

                            callback,

                            user_data);

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

-                g_task_return_pointer (task,

-                                       g_object_ref (client->priv->manager),

-                                       (GDestroyNotify) g_object_unref);

-                g_object_unref (task);

-                return;

-        }

-

         gdm_manager_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,

                                        G_DBUS_PROXY_FLAGS_NONE,

                                        "org.gnome.DisplayManager",

                                        "/org/gnome/DisplayManager/Manager",

                                        cancellable,

                                        (GAsyncReadyCallback)

                                        on_got_manager,

                                        task);

 }

 typedef struct {

         GTask           *task;

         GdmUserVerifier *user_verifier;

 } UserVerifierData;

 static UserVerifierData *

 user_verifier_data_new (GTask *task, GdmUserVerifier *user_verifier)

 {

         UserVerifierData *data;

         data = g_slice_new (UserVerifierData);

         data->task = g_object_ref (task);

         data->user_verifier = g_object_ref (user_verifier);

         return data;

 }

 static void

 user_verifier_data_free (UserVerifierData *data)

 {

@@ -377,114 +357,113 @@ on_reauthentication_channel_opened (GdmManager         *manager,

         cancellable = g_task_get_cancellable (task);

         g_dbus_connection_new_for_address (address,

                                            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,

                                            NULL,

                                            cancellable,

                                            (GAsyncReadyCallback)

                                            on_reauthentication_channel_connected,

                                            task);

 }

 static void

 on_got_manager_for_reauthentication (GdmClient           *client,

                                      GAsyncResult        *result,

                                      GTask               *task)

 {

         GCancellable *cancellable;

         GdmManager   *manager;

         char         *username;

         GError       *error;

         error = NULL;

         manager = g_task_propagate_pointer (G_TASK (result), &error);

         if (manager == NULL) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 return;

         }

         cancellable = g_task_get_cancellable (task);

         username = g_object_get_data (G_OBJECT (task), "username");

-        gdm_manager_call_open_reauthentication_channel (client->priv->manager,

+        gdm_manager_call_open_reauthentication_channel (manager,

                                                         username,

                                                         cancellable,

                                                         (GAsyncReadyCallback)

                                                         on_reauthentication_channel_opened,

                                                         task);

 }

 static gboolean

 gdm_client_open_connection_sync (GdmClient      *client,

                                  GCancellable   *cancellable,

                                  GError        **error)

 {

+        g_autoptr(GdmManager) manager = NULL;

         gboolean ret;

         g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);

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

                 g_object_ref (client->priv->connection);

                 return TRUE;

         }

-        client->priv->manager = gdm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,

-                                                                    G_DBUS_PROXY_FLAGS_NONE,

-                                                                    "org.gnome.DisplayManager",

-                                                                    "/org/gnome/DisplayManager/Manager",

-                                                                    cancellable,

-                                                                    error);

+        manager = gdm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,

+                                                      G_DBUS_PROXY_FLAGS_NONE,

+                                                      "org.gnome.DisplayManager",

+                                                      "/org/gnome/DisplayManager/Manager",

+                                                      cancellable,

+                                                      error);

-        if (client->priv->manager == NULL) {

+        if (manager == NULL) {

                 goto out;

         }

-        ret = gdm_manager_call_open_session_sync (client->priv->manager,

+        ret = gdm_manager_call_open_session_sync (manager,

                                                   &client->priv->address,

                                                   cancellable,

                                                   error);

         if (!ret) {

-                g_clear_object (&client->priv->manager);

                 goto out;

         }

         g_debug ("GdmClient: connecting to address: %s", client->priv->address);

         client->priv->connection = g_dbus_connection_new_for_address_sync (client->priv->address,

                                                                            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,

                                                                            NULL,

                                                                            cancellable,

                                                                            error);

         if (client->priv->connection == NULL) {

-                g_clear_object (&client->priv->manager);

                 g_clear_pointer (&client->priv->address, g_free);

                 goto out;

         }

         g_object_add_weak_pointer (G_OBJECT (client->priv->connection),

                                    (gpointer *)

                                    &client->priv->connection);

  out:

         return client->priv->connection != NULL;

 }

 static void

 on_connected (GObject            *source_object,

               GAsyncResult       *result,

               GTask              *task)

 {

         GDBusConnection *connection;

         GError *error;

         error = NULL;

         connection = g_dbus_connection_new_for_address_finish (result, &error);

         if (!connection) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 return;

         }

         g_task_return_pointer (task,

                                g_object_ref (connection),

@@ -517,61 +496,61 @@ on_session_opened (GdmManager         *manager,

         cancellable = g_task_get_cancellable (task);

         g_dbus_connection_new_for_address (client->priv->address,

                                            G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,

                                            NULL,

                                            cancellable,

                                            (GAsyncReadyCallback)

                                            on_connected,

                                            task);

         g_object_unref (client);

 }

 static void

 on_got_manager_for_opening_connection (GdmClient           *client,

                                        GAsyncResult        *result,

                                        GTask               *task)

 {

         GCancellable *cancellable;

         GdmManager   *manager;

         GError       *error;

         error = NULL;

         manager = g_task_propagate_pointer (G_TASK (result), &error);

         if (manager == NULL) {

                 g_task_return_error (task, error);

                 g_object_unref (task);

                 return;

         }

         cancellable = g_task_get_cancellable (task);

-        gdm_manager_call_open_session (client->priv->manager,

+        gdm_manager_call_open_session (manager,

                                        cancellable,

                                        (GAsyncReadyCallback)

                                        on_session_opened,

                                        task);

 }

 static gboolean

 gdm_client_open_connection_finish (GdmClient      *client,

                                    GAsyncResult   *result,

                                    GError        **error)

 {

         g_autoptr(GDBusConnection) connection = NULL;

         g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);

         connection = g_task_propagate_pointer (G_TASK (result), error);

         if (connection == NULL) {

                 return FALSE;

         }

         if (client->priv->connection == NULL) {

                 client->priv->connection = g_steal_pointer (&connection);

                 g_object_add_weak_pointer (G_OBJECT (client->priv->connection),

                                            (gpointer *) &client->priv->connection);

         } else if (client->priv->connection == connection) {

                 connection = NULL;

         }

         return TRUE;

 }

@@ -600,122 +579,114 @@ gdm_client_open_connection (GdmClient           *client,

         }

         get_manager (client,

                      cancellable,

                      (GAsyncReadyCallback)

                      on_got_manager_for_opening_connection,

                      task);

 }

 /**

  * gdm_client_open_reauthentication_channel_sync:

  * @client: a #GdmClient

  * @username: user to reauthenticate

  * @cancellable: a #GCancellable

  * @error: a #GError

  *

  * Gets a #GdmUserVerifier object that can be used to

  * reauthenticate an already logged in user. Free with

  * g_object_unref to close reauthentication channel.

  *

  * Returns: (transfer full): #GdmUserVerifier or %NULL if @username is not

  * already logged in.

  */

 GdmUserVerifier *

 gdm_client_open_reauthentication_channel_sync (GdmClient     *client,

                                                const char    *username,

                                                GCancellable  *cancellable,

                                                GError       **error)

 {

         GDBusConnection *connection;

+        g_autoptr(GdmManager) manager = NULL;

         GdmUserVerifier *user_verifier = NULL;

         gboolean         ret;

         char            *address;

         g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);

-        if (client->priv->manager == NULL) {

-                client->priv->manager = gdm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,

-                                                                            G_DBUS_PROXY_FLAGS_NONE,

-                                                                            "org.gnome.DisplayManager",

-                                                                            "/org/gnome/DisplayManager/Manager",

-                                                                            cancellable,

-                                                                            error);

+        manager = gdm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,

+                                                      G_DBUS_PROXY_FLAGS_NONE,

+                                                      "org.gnome.DisplayManager",

+                                                      "/org/gnome/DisplayManager/Manager",

+                                                      cancellable,

+                                                      error);

-                if (client->priv->manager == NULL) {

-                        goto out;

-                }

-        } else {

-                client->priv->manager = g_object_ref (client->priv->manager);

+        if (manager == NULL) {

+                goto out;

         }

-        ret = gdm_manager_call_open_reauthentication_channel_sync (client->priv->manager,

+        ret = gdm_manager_call_open_reauthentication_channel_sync (manager,

                                                                    username,

                                                                    &address,

                                                                    cancellable,

                                                                    error);

         if (!ret) {

                 goto out;

         }

         g_debug ("GdmClient: connecting to address: %s", client->priv->address);

         connection = g_dbus_connection_new_for_address_sync (address,

                                                              G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,

                                                              NULL,

                                                              cancellable,

                                                              error);

         if (connection == NULL) {

                 g_free (address);

                 goto out;

         }

         g_free (address);

         user_verifier = gdm_user_verifier_proxy_new_sync (connection,

                                                           G_DBUS_PROXY_FLAGS_NONE,

                                                           NULL,

                                                           SESSION_DBUS_PATH,

                                                           cancellable,

                                                           error);

         if (user_verifier != NULL) {

                 g_object_weak_ref (G_OBJECT (user_verifier),

                                    (GWeakNotify)

                                    g_object_unref,

                                    connection);

-

-                g_object_weak_ref (G_OBJECT (user_verifier),

-                                   (GWeakNotify)

-                                   g_clear_object,

-                                   &client->priv->manager);

         }

  out:

         return user_verifier;

 }

 /**

  * gdm_client_open_reauthentication_channel:

  * @client: a #GdmClient

  * @username: user to reauthenticate

  * @callback: a #GAsyncReadyCallback to call when the request is satisfied

  * @user_data: The data to pass to @callback

  * @cancellable: a #GCancellable

  *

  * Gets a #GdmUserVerifier object that can be used to

  * reauthenticate an already logged in user.

  */

 void

 gdm_client_open_reauthentication_channel (GdmClient           *client,

                                           const char          *username,

                                           GCancellable        *cancellable,

                                           GAsyncReadyCallback  callback,

                                           gpointer             user_data)

 {

         GTask *task;

         g_return_if_fail (GDM_IS_CLIENT (client));

         task = g_task_new (G_OBJECT (client),

                            cancellable,

@@ -764,64 +735,60 @@ gdm_client_open_reauthentication_channel_finish (GdmClient       *client,

  *

  * Gets a #GdmUserVerifier object that can be used to

  * verify a user's local account.

  *

  * Returns: (transfer full): #GdmUserVerifier or %NULL if not connected

  */

 GdmUserVerifier *

 gdm_client_get_user_verifier_sync (GdmClient     *client,

                                    GCancellable  *cancellable,

                                    GError       **error)

 {

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

                 return g_object_ref (client->priv->user_verifier);

         }

         if (!gdm_client_open_connection_sync (client, cancellable, error)) {

                 return NULL;

         }

         client->priv->user_verifier = gdm_user_verifier_proxy_new_sync (client->priv->connection,

                                                                         G_DBUS_PROXY_FLAGS_NONE,

                                                                         NULL,

                                                                         SESSION_DBUS_PATH,

                                                                         cancellable,

                                                                         error);

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

                 g_object_add_weak_pointer (G_OBJECT (client->priv->user_verifier),

                                            (gpointer *)

                                            &client->priv->user_verifier);

-                g_object_weak_ref (G_OBJECT (client->priv->user_verifier),

-                                   (GWeakNotify)

-                                   g_clear_object,

-                                   &client->priv->manager);

                 g_object_weak_ref (G_OBJECT (client->priv->user_verifier),

                                    (GWeakNotify)

                                    g_object_unref,

                                    client->priv->connection);

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

                         gboolean res;

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

                                                                                         g_str_equal,

                                                                                         NULL,

                                                                                         (GDestroyNotify)

                                                                                         free_interface_skeleton);

                         res = gdm_user_verifier_call_enable_extensions_sync (client->priv->user_verifier,

                                                                             (const char * const *)

                                                                              client->priv->enabled_extensions,

                                                                              cancellable,

                                                                              NULL);

                         if (res) {

                                 size_t i;

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

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

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

                                                         GdmUserVerifierChoiceList *choice_list_interface;

                                                         choice_list_interface = gdm_user_verifier_choice_list_proxy_new_sync (client->priv->connection,

                                                                                                                               G_DBUS_PROXY_FLAGS_NONE,

                                                                                                                               NULL,

                                                                                                                               SESSION_DBUS_PATH,

                                                                                                                               cancellable,

@@ -914,65 +881,60 @@ gdm_client_get_user_verifier (GdmClient           *client,

  *

  * Returns: (transfer full): a #GdmUserVerifier

  */

 GdmUserVerifier *

 gdm_client_get_user_verifier_finish (GdmClient       *client,

                                      GAsyncResult    *result,

                                      GError         **error)

 {

         GdmUserVerifier *user_verifier;

         g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);

         if (client->priv->user_verifier != NULL)

                 return g_object_ref (client->priv->user_verifier);

         user_verifier = g_task_propagate_pointer (G_TASK (result), error);

         if (user_verifier == NULL)

                 return NULL;

         client->priv->user_verifier = user_verifier;

         g_object_add_weak_pointer (G_OBJECT (client->priv->user_verifier),

                                    (gpointer *)

                                    &client->priv->user_verifier);

         g_object_weak_ref (G_OBJECT (client->priv->user_verifier),

                            (GWeakNotify)

                            g_object_unref,

                            client->priv->connection);

-        g_object_weak_ref (G_OBJECT (client->priv->user_verifier),

-                           (GWeakNotify)

-                           g_clear_object,

-                           &client->priv->manager);

-

         return user_verifier;

 }

 /**

  * gdm_client_get_user_verifier_choice_list:

  * @client: a #GdmClient

  *

  * Gets a #GdmUserVerifierChoiceList object that can be used to

  * verify a user's local account.

  *

  * Returns: (transfer none): #GdmUserVerifierChoiceList or %NULL if user

  * verifier isn't yet fetched, or daemon doesn't support choice lists

  */

 GdmUserVerifierChoiceList *

 gdm_client_get_user_verifier_choice_list (GdmClient *client)

 {

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

                 return NULL;

         return g_hash_table_lookup (client->priv->user_verifier_extensions,

                                     gdm_user_verifier_choice_list_interface_info ()->name);

 }

 static void

 on_timed_login_details_got (GdmGreeter   *greeter,

                             GAsyncResult *result)

 {

     gdm_greeter_call_get_timed_login_details_finish (greeter, NULL, NULL, NULL, result, NULL);

 }

@@ -1088,110 +1050,100 @@ gdm_client_get_greeter (GdmClient           *client,

  * gdm_client_get_greeter().

  *

  * Returns: (transfer full): a #GdmGreeter

  */

 GdmGreeter *

 gdm_client_get_greeter_finish (GdmClient       *client,

                                GAsyncResult    *result,

                                GError         **error)

 {

         GdmGreeter *greeter;

         g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);

         if (client->priv->greeter != NULL)

                 return g_object_ref (client->priv->greeter);

         greeter = g_task_propagate_pointer (G_TASK (result), error);

         if (greeter == NULL)

                 return NULL;

         client->priv->greeter = greeter;

         g_object_add_weak_pointer (G_OBJECT (client->priv->greeter),

                                    (gpointer *)

                                    &client->priv->greeter);

         g_object_weak_ref (G_OBJECT (client->priv->greeter),

                            (GWeakNotify)

                            g_object_unref,

                            client->priv->connection);

-

-        g_object_weak_ref (G_OBJECT (client->priv->greeter),

-                           (GWeakNotify)

-                           g_clear_object,

-                           &client->priv->manager);

-

         return greeter;

 }

 /**

  * gdm_client_get_greeter_sync:

  * @client: a #GdmClient

  * @cancellable: a #GCancellable

  * @error: a #GError

  *

  * Gets a #GdmGreeter object that can be used

  * to do do various login screen related tasks, such

  * as selecting a users session, and starting that

  * session.

  *

  * Returns: (transfer full): #GdmGreeter or %NULL if caller is not a greeter

  */

 GdmGreeter *

 gdm_client_get_greeter_sync (GdmClient     *client,

                              GCancellable  *cancellable,

                              GError       **error)

 {

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

                 return g_object_ref (client->priv->greeter);

         }

         if (!gdm_client_open_connection_sync (client, cancellable, error)) {

                 return NULL;

         }

         client->priv->greeter = gdm_greeter_proxy_new_sync (client->priv->connection,

                                                             G_DBUS_PROXY_FLAGS_NONE,

                                                             NULL,

                                                             SESSION_DBUS_PATH,

                                                             cancellable,

                                                             error);

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

                 g_object_add_weak_pointer (G_OBJECT (client->priv->greeter),

                                            (gpointer *)

                                            &client->priv->greeter);

-                g_object_weak_ref (G_OBJECT (client->priv->greeter),

-                                   (GWeakNotify)

-                                   g_clear_object,

-                                   &client->priv->manager);

                 g_object_weak_ref (G_OBJECT (client->priv->greeter),

                                    (GWeakNotify)

                                    g_object_unref,

                                    client->priv->connection);