From d3b60b5211d804e23c663d053c5b511dede22a28 Mon Sep 17 00:00:00 2001 From: Iain Lane 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); } - g_debug ("GdmSession: begin auto login for user '%s'", username); + g_debug ("GdmSession: client requesting automatic login for user '%s' on session '%s' (%p)", + username, + gdm_session_get_session_id (self), + self); gdm_session_setup_for_user (self, "gdm-autologin", username); return TRUE; } static void export_user_verifier_interface (GdmSession *self, GDBusConnection *connection) { GdmDBusUserVerifier *user_verifier_interface; user_verifier_interface = GDM_DBUS_USER_VERIFIER (gdm_dbus_user_verifier_skeleton_new ()); g_object_set_data (G_OBJECT (connection), "gdm-session", self); g_signal_connect (user_verifier_interface, "handle-enable-extensions", G_CALLBACK (gdm_session_handle_client_enable_extensions), connection); g_signal_connect (user_verifier_interface, "handle-begin-verification", G_CALLBACK (gdm_session_handle_client_begin_verification), self); g_signal_connect (user_verifier_interface, "handle-begin-verification-for-user", G_CALLBACK (gdm_session_handle_client_begin_verification_for_user), self); g_signal_connect (user_verifier_interface, "handle-answer-query", G_CALLBACK (gdm_session_handle_client_answer_query), @@ -1775,61 +1782,63 @@ allow_user_function (GDBusAuthObserver *observer, { uid_t client_uid; GPid pid_of_client; client_uid = g_credentials_get_unix_user (credentials, NULL); if (client_uid == self->priv->allowed_user) { return TRUE; } g_debug ("GdmSession: User not allowed"); pid_of_client = g_credentials_get_unix_pid (credentials, NULL); g_signal_emit (G_OBJECT (self), signals [CLIENT_REJECTED], 0, credentials, (guint) pid_of_client); return FALSE; } static void setup_outside_server (GdmSession *self) { GDBusAuthObserver *observer; GDBusServer *server; GError *error = NULL; - g_debug ("GdmSession: Creating D-Bus server for greeters and such"); + g_debug ("GdmSession: Creating D-Bus server for greeters and such for session %s (%p)", + gdm_session_get_session_id (self), + self); observer = g_dbus_auth_observer_new (); g_signal_connect_object (observer, "authorize-authenticated-peer", G_CALLBACK (allow_user_function), self, 0); server = gdm_dbus_setup_private_server (observer, &error); g_object_unref (observer); if (server == NULL) { g_warning ("Cannot create greeter D-Bus server for the session: %s", error->message); return; } g_signal_connect_object (server, "new-connection", G_CALLBACK (handle_connection_from_outside), self, 0); self->priv->outside_server = server; g_dbus_server_start (server); g_debug ("GdmSession: D-Bus server for greeters listening on %s", g_dbus_server_get_client_address (self->priv->outside_server)); } @@ -2160,61 +2169,61 @@ stop_conversation_now (GdmSessionConversation *conversation) void gdm_session_set_ignore_wayland (GdmSession *self, gboolean ignore_wayland) { self->priv->ignore_wayland = ignore_wayland; } #endif gboolean gdm_session_start_conversation (GdmSession *self, const char *service_name) { GdmSessionConversation *conversation; g_return_val_if_fail (GDM_IS_SESSION (self), FALSE); conversation = g_hash_table_lookup (self->priv->conversations, service_name); if (conversation != NULL) { if (!conversation->is_stopping) { g_warning ("GdmSession: conversation %s started more than once", service_name); return FALSE; } g_debug ("GdmSession: stopping old conversation %s", service_name); gdm_session_worker_job_stop_now (conversation->job); g_object_unref (conversation->job); conversation->job = NULL; } - g_debug ("GdmSession: starting conversation %s", service_name); + g_debug ("GdmSession: starting conversation %s for session (%p)", service_name, self); conversation = start_conversation (self, service_name); g_hash_table_insert (self->priv->conversations, g_strdup (service_name), conversation); return TRUE; } void gdm_session_stop_conversation (GdmSession *self, const char *service_name) { GdmSessionConversation *conversation; g_return_if_fail (GDM_IS_SESSION (self)); g_debug ("GdmSession: stopping conversation %s", service_name); conversation = find_conversation_by_name (self, service_name); if (conversation != NULL) { stop_conversation (conversation); } } static void on_initialization_complete_cb (GdmDBusWorker *proxy, GAsyncResult *res, gpointer user_data) { @@ -2319,60 +2328,64 @@ initialize (GdmSession *self, } g_free (extensions); } void gdm_session_setup (GdmSession *self, const char *service_name) { g_return_if_fail (GDM_IS_SESSION (self)); update_session_type (self); initialize (self, service_name, NULL, NULL); gdm_session_defaults_changed (self); } void gdm_session_setup_for_user (GdmSession *self, const char *service_name, const char *username) { g_return_if_fail (GDM_IS_SESSION (self)); g_return_if_fail (username != NULL); update_session_type (self); + g_debug ("GdmSession: Set up service %s for username %s on session (%p)", + service_name, + username, + self); gdm_session_select_user (self, username); self->priv->is_program_session = FALSE; initialize (self, service_name, self->priv->selected_user, NULL); gdm_session_defaults_changed (self); } void gdm_session_setup_for_program (GdmSession *self, const char *service_name, const char *username, const char *log_file) { g_return_if_fail (GDM_IS_SESSION (self)); self->priv->is_program_session = TRUE; initialize (self, service_name, username, log_file); } void gdm_session_authenticate (GdmSession *self, const char *service_name) { GdmSessionConversation *conversation; g_return_if_fail (GDM_IS_SESSION (self)); conversation = find_conversation_by_name (self, service_name); if (conversation != NULL) { @@ -2968,60 +2981,64 @@ gdm_session_set_timed_login_details (GdmSession *self, gboolean gdm_session_is_running (GdmSession *self) { return self->priv->session_pid > 0; } gboolean gdm_session_client_is_connected (GdmSession *self) { g_return_val_if_fail (GDM_IS_SESSION (self), FALSE); return self->priv->outside_connections != NULL; } uid_t gdm_session_get_allowed_user (GdmSession *self) { return self->priv->allowed_user; } void gdm_session_start_reauthentication (GdmSession *session, GPid pid_of_caller, uid_t uid_of_caller) { GdmSessionConversation *conversation = session->priv->session_conversation; g_return_if_fail (conversation != NULL); + g_debug ("GdmSession: starting reauthentication for session %s for client with pid %d", + conversation->session_id, + (int) uid_of_caller); + conversation->reauth_pid_of_caller = pid_of_caller; gdm_dbus_worker_call_start_reauthentication (conversation->worker_proxy, (int) pid_of_caller, (int) uid_of_caller, conversation->worker_cancellable, (GAsyncReadyCallback) on_reauthentication_started_cb, conversation); } const char * gdm_session_get_server_address (GdmSession *self) { g_return_val_if_fail (GDM_IS_SESSION (self), NULL); return g_dbus_server_get_client_address (self->priv->outside_server); } const char * gdm_session_get_username (GdmSession *self) { g_return_val_if_fail (GDM_IS_SESSION (self), NULL); return self->priv->selected_user; } const char * gdm_session_get_display_device (GdmSession *self) { g_return_val_if_fail (GDM_IS_SESSION (self), NULL); -- 2.21.0