Blob Blame History Raw
From b6bb149d03c7c979ced0652f0b464dc147743c64 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
Date: Mon, 4 Jun 2018 19:13:04 +0200
Subject: [PATCH 11/15] libgdm: Return NULL on invalid client instances

---
 libgdm/gdm-client.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/libgdm/gdm-client.c b/libgdm/gdm-client.c
index 0e8bf4399..28cb72536 100644
--- a/libgdm/gdm-client.c
+++ b/libgdm/gdm-client.c
@@ -396,61 +396,61 @@ on_got_manager_for_reauthentication (GdmClient           *client,
 
         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 (manager,
                                                         username,
                                                         cancellable,
                                                         (GAsyncReadyCallback)
                                                         on_reauthentication_channel_opened,
                                                         task);
         g_object_unref (manager);
 }
 
 static GDBusConnection *
 gdm_client_get_connection_sync (GdmClient      *client,
                                 GCancellable   *cancellable,
                                 GError        **error)
 {
         g_autoptr(GdmManager) manager = NULL;
         g_autofree char *address = NULL;
         GDBusConnection *connection;
         gboolean ret;
 
-        g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+        g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);
 
         connection = gdm_client_get_open_connection (client);
 
         if (connection != NULL) {
                 return g_object_ref (connection);
         }
 
         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 (manager == NULL) {
                 return NULL;
         }
 
         ret = gdm_manager_call_open_session_sync (manager,
                                                   &address,
                                                   cancellable,
                                                   error);
 
         if (!ret) {
                 return NULL;
         }
 
         g_debug ("GdmClient: connecting to address: %s", address);
 
         connection = g_dbus_connection_new_for_address_sync (address,
@@ -526,61 +526,61 @@ on_got_manager_for_opening_connection (GdmClient           *client,
 {
         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 (manager,
                                        cancellable,
                                        (GAsyncReadyCallback)
                                        on_session_opened,
                                        task);
 
         g_object_unref (manager);
 }
 
 static GDBusConnection *
 gdm_client_get_connection_finish (GdmClient      *client,
                                   GAsyncResult   *result,
                                   GError        **error)
 {
         GDBusConnection *connection;
 
-        g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+        g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);
 
         connection = g_task_propagate_pointer (G_TASK (result), error);
         if (connection == NULL) {
                 return NULL;
         }
 
         return connection;
 }
 
 static void
 gdm_client_get_connection (GdmClient           *client,
                             GCancellable        *cancellable,
                             GAsyncReadyCallback  callback,
                             gpointer             user_data)
 {
         GTask *task;
         GDBusConnection *connection;
 
         g_return_if_fail (GDM_IS_CLIENT (client));
 
         task = g_task_new (G_OBJECT (client),
                            cancellable,
                            callback,
                            user_data);
 
         connection = gdm_client_get_open_connection (client);
         if (connection != NULL) {
             g_task_return_pointer (task,
                                    g_object_ref (connection),
                                    (GDestroyNotify) g_object_unref);
@@ -594,61 +594,61 @@ gdm_client_get_connection (GdmClient           *client,
                      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)
 {
         g_autoptr(GDBusConnection) connection = NULL;
         g_autoptr(GdmManager) manager = NULL;
         g_autofree char *address = NULL;
         GdmUserVerifier *user_verifier = NULL;
         gboolean         ret;
 
-        g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+        g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);
 
         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 (manager == NULL) {
                 return NULL;
         }
 
         ret = gdm_manager_call_open_reauthentication_channel_sync (manager,
                                                                    username,
                                                                    &address,
                                                                    cancellable,
                                                                    error);
 
         if (!ret) {
                 return NULL;
         }
 
         g_debug ("GdmClient: connecting to address: %s", address);
 
         connection = g_dbus_connection_new_for_address_sync (address,
                                                              G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
                                                              NULL,
                                                              cancellable,
                                                              error);
 
@@ -695,61 +695,61 @@ gdm_client_open_reauthentication_channel (GdmClient           *client,
 
         g_object_set_data_full (G_OBJECT (task),
                                 "username",
                                 g_strdup (username),
                                 (GDestroyNotify)
                                 g_free);
 
         get_manager (client,
                      cancellable,
                      (GAsyncReadyCallback)
                      on_got_manager_for_reauthentication,
                      task);
 }
 
 /**
  * gdm_client_open_reauthentication_channel_finish:
  * @client: a #GdmClient
  * @result: The #GAsyncResult from the callback
  * @error: a #GError
  *
  * Finishes an operation started with
  * gdm_client_open_reauthentication_channel().
  *
  * Returns: (transfer full):  a #GdmUserVerifier
  */
 GdmUserVerifier *
 gdm_client_open_reauthentication_channel_finish (GdmClient       *client,
                                                  GAsyncResult    *result,
                                                  GError         **error)
 {
-        g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+        g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);
 
         return g_task_propagate_pointer (G_TASK (result), error);
 }
 
 /**
  * gdm_client_get_user_verifier_sync:
  * @client: a #GdmClient
  * @cancellable: a #GCancellable
  * @error: a #GError
  *
  * 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)
 {
         g_autoptr(GDBusConnection) connection = NULL;
 
         if (client->priv->user_verifier != NULL) {
                 return g_object_ref (client->priv->user_verifier);
         }
 
         connection = gdm_client_get_connection_sync (client, cancellable, error);
 
         if (connection == NULL) {
                 return NULL;
@@ -863,61 +863,61 @@ gdm_client_get_user_verifier (GdmClient           *client,
                                        (GDestroyNotify) g_object_unref);
                 g_object_unref (task);
                 return;
         }
 
         gdm_client_get_connection (client,
                                     cancellable,
                                     (GAsyncReadyCallback)
                                     on_connection_for_user_verifier,
                                     task);
 }
 
 /**
  * gdm_client_get_user_verifier_finish:
  * @client: a #GdmClient
  * @result: The #GAsyncResult from the callback
  * @error: a #GError
  *
  * Finishes an operation started with
  * gdm_client_get_user_verifier().
  *
  * 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);
+        g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);
 
         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);
 
         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)
 {
@@ -1031,61 +1031,61 @@ gdm_client_get_greeter (GdmClient           *client,
                                        (GDestroyNotify) g_object_unref);
                 g_object_unref (task);
                 return;
         }
 
         gdm_client_get_connection (client,
                                     cancellable,
                                     (GAsyncReadyCallback)
                                     on_connection_for_greeter,
                                     task);
 }
 
 /**
  * gdm_client_get_greeter_finish:
  * @client: a #GdmClient
  * @result: The #GAsyncResult from the callback
  * @error: a #GError
  *
  * Finishes an operation started with
  * 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);
+        g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);
 
         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);
 
         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
  */
@@ -1205,61 +1205,61 @@ gdm_client_get_remote_greeter (GdmClient           *client,
                                        (GDestroyNotify) g_object_unref);
                 g_object_unref (task);
                 return;
         }
 
         gdm_client_get_connection (client,
                                     cancellable,
                                     (GAsyncReadyCallback)
                                     on_connection_for_remote_greeter,
                                     task);
 }
 
 /**
  * gdm_client_get_remote_greeter_finish:
  * @client: a #GdmClient
  * @result: The #GAsyncResult from the callback
  * @error: a #GError
  *
  * Finishes an operation started with
  * gdm_client_get_remote_greeter().
  *
  * Returns: (transfer full): a #GdmRemoteGreeter
  */
 GdmRemoteGreeter *
 gdm_client_get_remote_greeter_finish (GdmClient     *client,
                                       GAsyncResult  *result,
                                       GError       **error)
 {
         GdmRemoteGreeter *remote_greeter;
 
-        g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+        g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);
 
         if (client->priv->remote_greeter != NULL)
                 return g_object_ref (client->priv->remote_greeter);
 
         remote_greeter = g_task_propagate_pointer (G_TASK (result), error);
         if (remote_greeter == NULL)
                 return NULL;
 
         client->priv->remote_greeter = remote_greeter;
 
         g_object_add_weak_pointer (G_OBJECT (client->priv->remote_greeter),
                                    (gpointer *)
                                    &client->priv->remote_greeter);
 
         return remote_greeter;
 }
 
 /**
  * gdm_client_get_remote_greeter_sync:
  * @client: a #GdmClient
  * @cancellable: a #GCancellable
  * @error: a #GError
  *
  * Gets a #GdmRemoteGreeter object that can be used
  * to do do various remote login screen related tasks,
  * such as disconnecting.
  *
  * Returns: (transfer full): #GdmRemoteGreeter or %NULL if caller is not remote
  */
 GdmRemoteGreeter *
@@ -1376,61 +1376,61 @@ gdm_client_get_chooser (GdmClient           *client,
                                        (GDestroyNotify) g_object_unref);
                 g_object_unref (task);
                 return;
         }
 
         gdm_client_get_connection (client,
                                     cancellable,
                                     (GAsyncReadyCallback)
                                     on_connection_for_chooser,
                                     task);
 }
 
 /**
  * gdm_client_get_chooser_finish:
  * @client: a #GdmClient
  * @result: The #GAsyncResult from the callback
  * @error: a #GError
  *
  * Finishes an operation started with
  * gdm_client_get_chooser().
  *
  * Returns: (transfer full): a #GdmChooser
  */
 GdmChooser *
 gdm_client_get_chooser_finish (GdmClient       *client,
                                GAsyncResult    *result,
                                GError         **error)
 {
         GdmChooser *chooser;
 
-        g_return_val_if_fail (GDM_IS_CLIENT (client), FALSE);
+        g_return_val_if_fail (GDM_IS_CLIENT (client), NULL);
 
         if (client->priv->chooser != NULL)
                 return g_object_ref (client->priv->chooser);
 
         chooser = g_task_propagate_pointer (G_TASK (result), error);
         if (chooser == NULL)
                 return NULL;
 
         client->priv->chooser = chooser;
 
         g_object_add_weak_pointer (G_OBJECT (client->priv->chooser),
                                    (gpointer *)
                                    &client->priv->chooser);
 
         return chooser;
 }
 
 /**
  * gdm_client_get_chooser_sync:
  * @client: a #GdmClient
  * @cancellable: a #GCancellable
  * @error: a #GError
  *
  * Gets a #GdmChooser object that can be used
  * to do do various XDMCP chooser related tasks, such
  * as selecting a host or disconnecting.
  *
  * Returns: (transfer full): #GdmChooser or %NULL if caller is not a chooser
  */
 GdmChooser *
-- 
2.25.1