From d3b60b5211d804e23c663d053c5b511dede22a28 Mon Sep 17 00:00:00 2001

From: Iain Lane <iainl@gnome.org>

Date: Thu, 31 Jan 2019 10:52:35 +0000

Subject: [PATCH 2/4] manager,session: Add some debugging around starting

 reauthentication

There's a bug right now dealing with timed login and reauthentication,

but it's not clear what's going on by looking at the logs.

This commit sprinkles some more logging throughout the code, to make

the bug easier to track.

---

 daemon/gdm-manager.c | 46 ++++++++++++++++++++++++++++++++++++++------

 daemon/gdm-session.c | 25 ++++++++++++++++++++----

 2 files changed, 61 insertions(+), 10 deletions(-)

diff --git a/daemon/gdm-manager.c b/daemon/gdm-manager.c

index b2d0578f5..0cc06a978 100644

--- a/daemon/gdm-manager.c

+++ b/daemon/gdm-manager.c

@@ -340,77 +340,94 @@ session_unlock (GdmManager *manager,

                                              "org.freedesktop.login1.Manager",

                                              "UnlockSession",

                                              g_variant_new ("(s)", ssid),

                                              NULL, /* expected reply */

                                              G_DBUS_CALL_FLAGS_NONE,

                                              -1,

                                              NULL,

                                              &error);

         if (reply == NULL) {

                 g_debug ("GdmManager: logind 'UnlockSession' %s raised:\n %s\n\n",

                          g_dbus_error_get_remote_error (error), error->message);

                 g_error_free (error);

                 return FALSE;

         }

         g_variant_unref (reply);

         return TRUE;

 }

 static GdmSession *

 find_session_for_user_on_seat (GdmManager *manager,

                                const char *username,

                                const char *seat_id,

                                GdmSession *dont_count_session)

 {

         GList *node;

         for (node = manager->priv->user_sessions; node != NULL; node = node->next) {

                 GdmSession *candidate_session = node->data;

-                const char *candidate_username, *candidate_seat_id;

+                const char *candidate_username, *candidate_seat_id, *candidate_session_id;

-                if (candidate_session == dont_count_session)

+                candidate_session_id = gdm_session_get_session_id (candidate_session);

+

+                if (candidate_session == dont_count_session) {

+                        g_debug ("GdmSession: Ignoring session %s as requested",

+                                 candidate_session_id);

                         continue;

+                }

-                if (!gdm_session_is_running (candidate_session))

+                if (!gdm_session_is_running (candidate_session)) {

+                        g_debug ("GdmSession: Ignoring session %s as it isn't running",

+                                 candidate_session_id);

                         continue;

+                }

                 candidate_username = gdm_session_get_username (candidate_session);

                 candidate_seat_id = gdm_session_get_display_seat_id (candidate_session);

+                g_debug ("GdmManager: Considering session %s on seat %s belonging to user %s",

+                         candidate_session_id,

+                         candidate_seat_id,

+                         candidate_username);

+

                 if (g_strcmp0 (candidate_username, username) == 0 &&

                     g_strcmp0 (candidate_seat_id, seat_id) == 0) {

+                        g_debug ("GdmManager: yes, found session %s", candidate_session_id);

                         return candidate_session;

                 }

+

+                g_debug ("GdmManager: no, will not use session %s", candidate_session_id);

         }

+        g_debug ("GdmManager: no matching sessions found");

         return NULL;

 }

 static gboolean

 is_remote_session (GdmManager  *self,

                    const char  *session_id,

                    GError     **error)

 {

         char *seat;

         int ret;

         gboolean is_remote;

         /* FIXME: The next release of logind is going to have explicit api for

          * checking remoteness.

          */

         seat = NULL;

         ret = sd_session_get_seat (session_id, &seat;;

         if (ret < 0 && ret != -ENOENT) {

                 g_debug ("GdmManager: Error while retrieving seat for session %s: %s",

                          session_id, strerror (-ret));

         }

         if (seat != NULL) {

                 is_remote = FALSE;

                 free (seat);

         } else {

                 is_remote = TRUE;

         }

@@ -840,62 +857,66 @@ gdm_manager_handle_open_session (GdmDBusManager        *manager,

         if (display == NULL) {

                 g_dbus_method_invocation_return_error_literal (invocation,

                                                                G_DBUS_ERROR,

                                                                G_DBUS_ERROR_ACCESS_DENIED,

                                                                _("No session available"));

                 return TRUE;

         }

 #ifdef HAVE_LIBXDMCP

         if (GDM_IS_XDMCP_CHOOSER_DISPLAY (display)) {

                 GdmLaunchEnvironment *launch_environment;

                 g_object_get (display, "launch-environment", &launch_environment, NULL);

                 if (launch_environment != NULL) {

                         session = gdm_launch_environment_get_session (launch_environment);

                 }

                 if (session == NULL) {

                         g_dbus_method_invocation_return_error_literal (invocation,

                                                                        G_DBUS_ERROR,

                                                                        G_DBUS_ERROR_ACCESS_DENIED,

                                                                        _("Chooser session unavailable"));

                         return TRUE;

                 }

         }

 #endif

         if (session == NULL) {

                 session = get_user_session_for_display (display);

+                g_debug ("GdmSession: Considering session %s for username %s",

+                         gdm_session_get_session_id (session),

+                         gdm_session_get_username (session));

                 if (gdm_session_is_running (session)) {

+                        g_debug ("GdmSession: the session is running, and therefore can't be used");

                         g_dbus_method_invocation_return_error_literal (invocation,

                                                                        G_DBUS_ERROR,

                                                                        G_DBUS_ERROR_ACCESS_DENIED,

                                                                        _("Can only be called before user is logged in"));

                         return TRUE;

                 }

         }

         allowed_user = gdm_session_get_allowed_user (session);

         if (uid != allowed_user) {

                 g_dbus_method_invocation_return_error_literal (invocation,

                                                                G_DBUS_ERROR,

                                                                G_DBUS_ERROR_ACCESS_DENIED,

                                                                _("Caller not GDM"));

                 return TRUE;

         }

         address = gdm_session_get_server_address (session);

         if (address == NULL) {

                 g_dbus_method_invocation_return_error_literal (invocation,

                                                                G_DBUS_ERROR,

                                                                G_DBUS_ERROR_ACCESS_DENIED,

                                                                _("Unable to open private communication channel"));

                 return TRUE;

         }

         gdm_dbus_manager_complete_open_session (GDM_DBUS_MANAGER (manager),

                                                 invocation,

@@ -1017,60 +1038,64 @@ open_temporary_reauthentication_channel (GdmManager            *self,

                                          char                  *seat_id,

                                          char                  *session_id,

                                          GPid                   pid,

                                          uid_t                  uid,

                                          gboolean               is_remote)

 {

         GdmSession *session;

         char **environment;

         const char *display, *auth_file;

         const char *address;

         /* Note we're just using a minimal environment here rather than the

          * session's environment because the caller is unprivileged and the

          * associated worker will be privileged */

         environment = g_get_environ ();

         display = "";

         auth_file = "/dev/null";

         session = gdm_session_new (GDM_SESSION_VERIFICATION_MODE_REAUTHENTICATE,

                                    uid,

                                    display,

                                    NULL,

                                    NULL,

                                    seat_id,

                                    auth_file,

                                    is_remote == FALSE,

                                    (const char * const *)

                                    environment);

         g_strfreev (environment);

+        g_debug ("GdmSession: Created session for temporary reauthentication channel for user %d (seat %s)",

+                 (int) uid,

+                 seat_id);

+

         g_object_set_data_full (G_OBJECT (session),

                                 "caller-session-id",

                                 g_strdup (session_id),

                                 (GDestroyNotify)

                                 g_free);

         g_object_set_data (G_OBJECT (session),

                            "caller-pid",

                            GUINT_TO_POINTER (pid));

         g_hash_table_insert (self->priv->transient_sessions,

                              GINT_TO_POINTER (pid),

                              session);

         g_signal_connect (session,

                           "client-connected",

                           G_CALLBACK (on_reauthentication_client_connected),

                           self);

         g_signal_connect (session,

                           "client-disconnected",

                           G_CALLBACK (on_reauthentication_client_disconnected),

                           self);

         g_signal_connect (session,

                           "client-rejected",

                           G_CALLBACK (on_reauthentication_client_rejected),

                           self);

         g_signal_connect (session,

                           "cancelled",

                           G_CALLBACK (on_reauthentication_cancelled),

                           self);

         g_signal_connect (session,

                           "conversation-started",

@@ -1096,65 +1121,67 @@ gdm_manager_handle_open_reauthentication_channel (GdmDBusManager        *manager

                                                   const char            *username)

 {

         GdmManager       *self = GDM_MANAGER (manager);

         const char       *sender;

         GdmDisplay       *display = NULL;

         GdmSession       *session;

         GDBusConnection  *connection;

         char             *seat_id = NULL;

         char             *session_id = NULL;

         GPid              pid = 0;

         uid_t             uid = (uid_t) -1;

         gboolean          is_login_screen = FALSE;

         gboolean          is_remote = FALSE;

         g_debug ("GdmManager: trying to open reauthentication channel for user %s", username);

         sender = g_dbus_method_invocation_get_sender (invocation);

         connection = g_dbus_method_invocation_get_connection (invocation);

         get_display_and_details_for_bus_sender (self, connection, sender, &display, &seat_id, &session_id, NULL, &pid, &uid, &is_login_screen, &is_remote);

         if (session_id == NULL || pid == 0 || uid == (uid_t) -1) {

                 g_dbus_method_invocation_return_error_literal (invocation,

                                                                G_DBUS_ERROR,

                                                                G_DBUS_ERROR_ACCESS_DENIED,

                                                                _("No session available"));

                 return TRUE;

         }

         if (is_login_screen) {

+                g_debug ("GdmManager: looking for login screen session for user %s on seat %s", username, seat_id);

                 session = find_session_for_user_on_seat (self,

                                                          username,

                                                          seat_id,

                                                          NULL);

         } else {

+                g_debug ("GdmManager: looking for user session on display");

                 session = get_user_session_for_display (display);

         }

         if (session != NULL && gdm_session_is_running (session)) {

                 gdm_session_start_reauthentication (session, pid, uid);

                 g_hash_table_insert (self->priv->open_reauthentication_requests,

                                      GINT_TO_POINTER (pid),

                                      invocation);

         } else if (is_login_screen) {

                 g_dbus_method_invocation_return_error_literal (invocation,

                                                                G_DBUS_ERROR,

                                                                G_DBUS_ERROR_ACCESS_DENIED,

                                                                "Login screen only allowed to open reauthentication channels for running sessions");

                 return TRUE;

         } else {

                 char *address;

                 address = open_temporary_reauthentication_channel (self,

                                                                    seat_id,

                                                                    session_id,

                                                                    pid,

                                                                    uid,

                                                                    is_remote);

                 gdm_dbus_manager_complete_open_reauthentication_channel (GDM_DBUS_MANAGER (manager),

                                                                          invocation,

                                                                          address);

                 g_free (address);

         }

         return TRUE;

 }

@@ -2087,107 +2114,107 @@ on_session_client_ready_for_session_to_start (GdmSession      *session,

         if (client_is_ready) {

                 g_debug ("GdmManager: Will start session when ready");

         } else {

                 g_debug ("GdmManager: Will start session when ready and told");

         }

         waiting_to_start_user_session = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (session),

                                                                        "waiting-to-start"));

         g_object_set_data (G_OBJECT (session),

                            "start-when-ready",

                            GINT_TO_POINTER (client_is_ready));

         if (client_is_ready && waiting_to_start_user_session) {

                 start_user_session_if_ready (manager, session, service_name);

         }

 }

 static void

 on_session_client_connected (GdmSession      *session,

                              GCredentials    *credentials,

                              GPid             pid_of_client,

                              GdmManager      *manager)

 {

         GdmDisplay *display;

         char    *username;

         int      delay;

         gboolean enabled;

         gboolean allow_timed_login = FALSE;

-        g_debug ("GdmManager: client connected");

+        g_debug ("GdmManager: client with pid %d connected", (int) pid_of_client);

         display = get_display_for_user_session (session);

         if (display == NULL) {

                 return;

         }

         if (!display_is_on_seat0 (display)) {

                 return;

         }

 #ifdef WITH_PLYMOUTH

         if (manager->priv->plymouth_is_running) {

                 plymouth_quit_with_transition ();

                 manager->priv->plymouth_is_running = FALSE;

         }

 #endif

         g_object_get (G_OBJECT (display), "allow-timed-login", &allow_timed_login, NULL);

         if (!allow_timed_login) {

                 return;

         }

         enabled = get_timed_login_details (manager, &username, &delay);

         if (! enabled) {

                 return;

         }

         gdm_session_set_timed_login_details (session, username, delay);

         g_debug ("GdmManager: Starting automatic login conversation (for timed login)");

         gdm_session_start_conversation (session, "gdm-autologin");

         g_free (username);

 }

 static void

 on_session_client_disconnected (GdmSession   *session,

                                 GCredentials *credentials,

                                 GPid          pid_of_client,

                                 GdmManager   *manager)

 {

-        g_debug ("GdmManager: client disconnected");

+        g_debug ("GdmManager: client with pid %d disconnected", (int) pid_of_client);

 }

 typedef struct

 {

         GdmManager *manager;

         GdmSession *session;

         guint idle_id;

 } ResetSessionOperation;

 static void

 destroy_reset_session_operation (ResetSessionOperation *operation)

 {

         g_object_set_data (G_OBJECT (operation->session),

                            "reset-session-operation",

                            NULL);

         g_object_unref (operation->session);

         g_slice_free (ResetSessionOperation, operation);

 }

 static gboolean

 on_reset_session (ResetSessionOperation *operation)

 {

         gdm_session_reset (operation->session);

         destroy_reset_session_operation (operation);

         return G_SOURCE_REMOVE;

 }

 static void

@@ -2200,63 +2227,64 @@ queue_session_reset (GdmManager *manager,

         if (operation != NULL) {

                 return;

         }

         operation = g_slice_new0 (ResetSessionOperation);

         operation->manager = manager;

         operation->session = g_object_ref (session);

         operation->idle_id = g_idle_add ((GSourceFunc) on_reset_session, operation);

         g_object_set_data (G_OBJECT (session), "reset-session-operation", operation);

 }

 static void

 on_session_cancelled (GdmSession  *session,

                       GdmManager  *manager)

 {

         g_debug ("GdmManager: Session was cancelled");

         queue_session_reset (manager, session);

 }

 static void

 on_session_conversation_started (GdmSession *session,

                                  const char *service_name,

                                  GdmManager *manager)

 {

         GdmDisplay *display;

         gboolean    enabled;

         char       *username;

-        g_debug ("GdmManager: session conversation started for service %s", service_name);

+        g_debug ("GdmManager: session conversation started for service %s on session", service_name);

         if (g_strcmp0 (service_name, "gdm-autologin") != 0) {

+                g_debug ("GdmManager: ignoring session conversation since its not automatic login conversation");

                 return;

         }

         display = get_display_for_user_session (session);

         if (display == NULL) {

                 g_debug ("GdmManager: conversation has no associated display");

                 return;

         }

         if (!display_is_on_seat0 (display)) {

                 return;

         }

         enabled = get_automatic_login_details (manager, &username);

         if (! enabled) {

                 return;

         }

         g_debug ("GdmManager: begin auto login for user '%s'", username);

         /* service_name will be "gdm-autologin"

          */

         gdm_session_setup_for_user (session, service_name, username);

         g_free (username);

 }

 static void

@@ -2312,60 +2340,66 @@ create_user_session_for_display (GdmManager *manager,

         char       *display_auth_file = NULL;

         char       *display_seat_id = NULL;

         char       *display_id = NULL;

 #if defined(ENABLE_WAYLAND_SUPPORT) && defined(ENABLE_USER_DISPLAY_SERVER)

         char       *display_session_type = NULL;

         gboolean    greeter_is_wayland;

 #endif

         g_object_get (G_OBJECT (display),

                       "id", &display_id,

                       "x11-display-name", &display_name,

                       "is-local", &display_is_local,

                       "remote-hostname", &remote_hostname,

                       "x11-authority-file", &display_auth_file,

                       "seat-id", &display_seat_id,

 #if defined(ENABLE_WAYLAND_SUPPORT) && defined(ENABLE_USER_DISPLAY_SERVER)

                       "session-type", &display_session_type,

 #endif

                       NULL);

         display_device = get_display_device (manager, display);

         session = gdm_session_new (GDM_SESSION_VERIFICATION_MODE_LOGIN,

                                    allowed_user,

                                    display_name,

                                    remote_hostname,

                                    display_device,

                                    display_seat_id,

                                    display_auth_file,

                                    display_is_local,

                                    NULL);

+

+        g_debug ("GdmSession: Created user session for user %d on display %s (seat %s)",

+                 (int) allowed_user,

+                 display_id,

+                 display_seat_id);

+

         g_free (display_name);

         g_free (remote_hostname);

         g_free (display_auth_file);

         g_free (display_seat_id);

         g_signal_connect (session,

                           "reauthentication-started",

                           G_CALLBACK (on_session_reauthentication_started),

                           manager);

         g_signal_connect (session,

                           "reauthenticated",

                           G_CALLBACK (on_session_reauthenticated),

                           manager);

         g_signal_connect (session,

                           "client-ready-for-session-to-start",

                           G_CALLBACK (on_session_client_ready_for_session_to_start),

                           manager);

         g_signal_connect (session,

                           "client-connected",

                           G_CALLBACK (on_session_client_connected),

                           manager);

         g_signal_connect (session,

                           "client-disconnected",

                           G_CALLBACK (on_session_client_disconnected),

                           manager);

         g_signal_connect (session,

                           "cancelled",

                           G_CALLBACK (on_session_cancelled),

                           manager);

         g_signal_connect (session,

diff --git a/daemon/gdm-session.c b/daemon/gdm-session.c

index 0f821e390..f23a83c5e 100644

--- a/daemon/gdm-session.c

+++ b/daemon/gdm-session.c

@@ -624,61 +624,64 @@ get_fallback_session_name (GdmSession *self)

 static const char *

 get_default_session_name (GdmSession *self)

 {

         if (self->priv->saved_session != NULL) {

                 return self->priv->saved_session;

         }

         return get_fallback_session_name (self);

 }

 static void

 gdm_session_defaults_changed (GdmSession *self)

 {

         update_session_type (self);

         if (self->priv->greeter_interface != NULL) {

                 gdm_dbus_greeter_emit_default_language_name_changed (self->priv->greeter_interface,

                                                                      get_default_language_name (self));

                 gdm_dbus_greeter_emit_default_session_name_changed (self->priv->greeter_interface,

                                                                     get_default_session_name (self));

         }

 }

 void

 gdm_session_select_user (GdmSession *self,

                          const char *text)

 {

-        g_debug ("GdmSession: Setting user: '%s'", text);

+        g_debug ("GdmSession: selecting user '%s' for session '%s' (%p)",

+                 text,

+                 gdm_session_get_session_id (self),

+                 self);

         g_free (self->priv->selected_user);

         self->priv->selected_user = g_strdup (text);

         g_free (self->priv->saved_session);

         self->priv->saved_session = NULL;

         g_free (self->priv->saved_session_type);

         self->priv->saved_session_type = NULL;

         g_free (self->priv->saved_language);

         self->priv->saved_language = NULL;

 }

 static void

 cancel_pending_query (GdmSessionConversation *conversation)

 {

         if (conversation->pending_invocation == NULL) {

                 return;

         }

         g_debug ("GdmSession: Cancelling pending query");

         g_dbus_method_invocation_return_dbus_error (conversation->pending_invocation,

                                                     GDM_SESSION_DBUS_ERROR_CANCEL,

                                                     "Operation cancelled");

         conversation->pending_invocation = NULL;

 }

 static void

@@ -1416,117 +1419,121 @@ gdm_session_handle_client_cancel (GdmDBusUserVerifier    *user_verifier_interfac

         gdm_dbus_user_verifier_complete_cancel (user_verifier_interface,

                                                 invocation);

         gdm_session_cancel (self);

         return TRUE;

 }

 static gboolean

 gdm_session_handle_client_select_session (GdmDBusGreeter         *greeter_interface,

                                           GDBusMethodInvocation  *invocation,

                                           const char             *session,

                                           GdmSession             *self)

 {

         if (self->priv->greeter_interface != NULL) {

                 gdm_dbus_greeter_complete_select_session (greeter_interface,

                                                           invocation);

         }

         gdm_session_select_session (self, session);

         return TRUE;

 }

 static gboolean

 gdm_session_handle_client_select_user (GdmDBusGreeter        *greeter_interface,

                                        GDBusMethodInvocation *invocation,

                                        const char            *username,

                                        GdmSession            *self)

 {

         if (self->priv->greeter_interface != NULL) {

                 gdm_dbus_greeter_complete_select_user (greeter_interface,

                                                        invocation);

         }

+        g_debug ("GdmSession: client selected user '%s' on session (%p)", username, self);

         gdm_session_select_user (self, username);

         return TRUE;

 }

 static gboolean

 gdm_session_handle_client_start_session_when_ready (GdmDBusGreeter        *greeter_interface,

                                                     GDBusMethodInvocation *invocation,

                                                     const char            *service_name,

                                                     gboolean               client_is_ready,

                                                     GdmSession            *self)

 {

         if (self->priv->greeter_interface != NULL) {

                 gdm_dbus_greeter_complete_start_session_when_ready (greeter_interface,

                                                                     invocation);

         }

         g_signal_emit (G_OBJECT (self),

                        signals [CLIENT_READY_FOR_SESSION_TO_START],

                        0,

                        service_name,

                        client_is_ready);

         return TRUE;

 }

 static gboolean

 gdm_session_handle_get_timed_login_details (GdmDBusGreeter        *greeter_interface,

                                             GDBusMethodInvocation *invocation,

                                             GdmSession            *self)

 {

         if (self->priv->greeter_interface != NULL) {

                 gdm_dbus_greeter_complete_get_timed_login_details (greeter_interface,

                                                                    invocation,

                                                                    self->priv->timed_login_username != NULL,

                                                                    self->priv->timed_login_username != NULL? self->priv->timed_login_username : "",

                                                                    self->priv->timed_login_delay);

                 if (self->priv->timed_login_username != NULL) {

                         gdm_dbus_greeter_emit_timed_login_requested (self->priv->greeter_interface,

                                                                      self->priv->timed_login_username,

                                                                      self->priv->timed_login_delay);

                 }

         }

         return TRUE;

 }

 static gboolean

 gdm_session_handle_client_begin_auto_login (GdmDBusGreeter        *greeter_interface,

                                             GDBusMethodInvocation *invocation,

                                             const char            *username,

                                             GdmSession            *self)

 {

         if (self->priv->greeter_interface != NULL) {

                 gdm_dbus_greeter_complete_begin_auto_login (greeter_interface,

                                                             invocation);

         }