From 18024a6265233312e57ec0aa346a4e44edc91c02 Mon Sep 17 00:00:00 2001 From: Antoine POPINEAU Date: Sun, 19 May 2024 10:09:28 +0200 Subject: [PATCH] Fixed inconsistent display of session name on remember global session (#139). --- src/greeter.rs | 44 ++++++++++++++++++++++++++------------------ src/info.rs | 48 ++++++++++++++++++++++++++---------------------- src/ipc.rs | 10 +++++----- src/keyboard.rs | 15 +++++++-------- 4 files changed, 64 insertions(+), 53 deletions(-) diff --git a/src/greeter.rs b/src/greeter.rs index 5a367e5..0c8e01a 100644 --- a/src/greeter.rs +++ b/src/greeter.rs @@ -22,9 +22,7 @@ use zeroize::Zeroize; use crate::{ event::Event, - info::{ - get_issue, get_last_session, get_last_session_path, get_last_user_name, get_last_user_session, get_last_user_session_path, get_last_user_username, get_min_max_uids, get_sessions, get_users, - }, + info::{get_issue, get_last_command, get_last_session_path, get_last_user_command, get_last_user_name, get_last_user_session, get_last_user_username, get_min_max_uids, get_sessions, get_users}, power::PowerOption, ui::{ common::{masked::MaskedString, menu::Menu, style::Theme}, @@ -96,7 +94,7 @@ pub enum GreetAlign { #[default] Center, Left, - Right + Right, } #[derive(SmartDefault)] @@ -225,15 +223,18 @@ impl Greeter { // If, on top of that, we should remember their last session. if greeter.remember_user_session { - if let Ok(ref session_path) = get_last_user_session_path(greeter.username.get()) { - // Set the selected menu option and the session source. - greeter.sessions.selected = greeter.sessions.options.iter().position(|Session { path, .. }| path.as_deref() == Some(session_path)).unwrap_or(0); - greeter.session_source = SessionSource::Session(greeter.sessions.selected); + // See if we have the last free-form command from the user. + if let Ok(command) = get_last_user_command(greeter.username.get()) { + greeter.session_source = SessionSource::Command(command); } - // See if we have the last free-form command from the user. - if let Ok(command) = get_last_user_session(greeter.username.get()) { - greeter.session_source = SessionSource::Command(command); + // If a session was saved, use it and its name. + if let Ok(ref session_path) = get_last_user_session(greeter.username.get()) { + // Set the selected menu option and the session source. + if let Some(index) = greeter.sessions.options.iter().position(|Session { path, .. }| path.as_deref() == Some(session_path)) { + greeter.sessions.selected = index; + greeter.session_source = SessionSource::Session(greeter.sessions.selected); + } } } } @@ -241,13 +242,15 @@ impl Greeter { // Same thing, but not user specific. if greeter.remember_session { - if let Ok(ref session_path) = get_last_session_path() { - greeter.sessions.selected = greeter.sessions.options.iter().position(|Session { path, .. }| path.as_deref() == Some(session_path)).unwrap_or(0); - greeter.session_source = SessionSource::Session(greeter.sessions.selected); + if let Ok(command) = get_last_command() { + greeter.session_source = SessionSource::Command(command.trim().to_string()); } - if let Ok(command) = get_last_session() { - greeter.session_source = SessionSource::Command(command.trim().to_string()); + if let Ok(ref session_path) = get_last_session_path() { + if let Some(index) = greeter.sessions.options.iter().position(|Session { path, .. }| path.as_deref() == Some(session_path)) { + greeter.sessions.selected = index; + greeter.session_source = SessionSource::Session(greeter.sessions.selected); + } } } @@ -362,7 +365,7 @@ impl Greeter { match value.as_str() { "left" => GreetAlign::Left, "right" => GreetAlign::Right, - _ => GreetAlign::Center + _ => GreetAlign::Center, } } else { GreetAlign::default() @@ -413,7 +416,12 @@ impl Greeter { opts.optopt("", "window-padding", "padding inside the terminal area (default: 0)", "PADDING"); opts.optopt("", "container-padding", "padding inside the main prompt container (default: 1)", "PADDING"); opts.optopt("", "prompt-padding", "padding between prompt rows (default: 1)", "PADDING"); - opts.optopt("", "greet-align", "alignment of the greeting text in the main prompt container (default: 'center')", "[left|center|right]"); + opts.optopt( + "", + "greet-align", + "alignment of the greeting text in the main prompt container (default: 'center')", + "[left|center|right]", + ); opts.optopt("", "power-shutdown", "command to run to shut down the system", "'CMD [ARGS]...'"); opts.optopt("", "power-reboot", "command to run to reboot the system", "'CMD [ARGS]...'"); diff --git a/src/info.rs b/src/info.rs index 7ecda9e..12b75d0 100644 --- a/src/info.rs +++ b/src/info.rs @@ -23,8 +23,8 @@ use crate::{ const LAST_USER_USERNAME: &str = "/var/cache/tuigreet/lastuser"; const LAST_USER_NAME: &str = "/var/cache/tuigreet/lastuser-name"; -const LAST_SESSION: &str = "/var/cache/tuigreet/lastsession"; -const LAST_SESSION_PATH: &str = "/var/cache/tuigreet/lastsession-path"; +const LAST_COMMAND: &str = "/var/cache/tuigreet/lastsession"; +const LAST_SESSION: &str = "/var/cache/tuigreet/lastsession-path"; const DEFAULT_MIN_UID: u16 = 1000; const DEFAULT_MAX_UID: u16 = 60000; @@ -114,55 +114,59 @@ pub fn write_last_username(username: &MaskedString) { } pub fn get_last_session_path() -> Result { - Ok(PathBuf::from(fs::read_to_string(LAST_SESSION_PATH)?.trim())) + Ok(PathBuf::from(fs::read_to_string(LAST_SESSION)?.trim())) } -pub fn get_last_session() -> Result { - Ok(fs::read_to_string(LAST_SESSION)?.trim().to_string()) +pub fn get_last_command() -> Result { + Ok(fs::read_to_string(LAST_COMMAND)?.trim().to_string()) } pub fn write_last_session_path

(session: &P) where P: AsRef, { - let _ = fs::write(LAST_SESSION_PATH, session.as_ref().to_string_lossy().as_bytes()); + let _ = fs::write(LAST_SESSION, session.as_ref().to_string_lossy().as_bytes()); } -pub fn write_last_session(session: &str) { - let _ = fs::write(LAST_SESSION, session); +pub fn write_last_command(session: &str) { + let _ = fs::write(LAST_COMMAND, session); } -pub fn get_last_user_session_path(username: &str) -> Result { - Ok(PathBuf::from(fs::read_to_string(format!("{LAST_SESSION_PATH}-{username}"))?.trim())) +pub fn get_last_user_session(username: &str) -> Result { + Ok(PathBuf::from(fs::read_to_string(format!("{LAST_SESSION}-{username}"))?.trim())) } -pub fn get_last_user_session(username: &str) -> Result { - Ok(fs::read_to_string(format!("{LAST_SESSION}-{username}"))?.trim().to_string()) +pub fn get_last_user_command(username: &str) -> Result { + Ok(fs::read_to_string(format!("{LAST_COMMAND}-{username}"))?.trim().to_string()) } -pub fn write_last_user_session_path

(username: &str, session: P) +pub fn write_last_user_session

(username: &str, session: P) where P: AsRef, { - let _ = fs::write(format!("{LAST_SESSION_PATH}-{username}"), session.as_ref().to_string_lossy().as_bytes()); + let _ = fs::write(format!("{LAST_SESSION}-{username}"), session.as_ref().to_string_lossy().as_bytes()); } -pub fn delete_last_session_path() { - let _ = fs::remove_file(LAST_SESSION_PATH); +pub fn delete_last_session() { + let _ = fs::remove_file(LAST_SESSION); } -pub fn write_last_user_session(username: &str, session: &str) { - let _ = fs::write(format!("{LAST_SESSION}-{username}"), session); -} - -pub fn delete_last_user_session_path(username: &str) { - let _ = fs::remove_file(format!("{LAST_SESSION_PATH}-{username}")); +pub fn write_last_user_command(username: &str, session: &str) { + let _ = fs::write(format!("{LAST_COMMAND}-{username}"), session); } pub fn delete_last_user_session(username: &str) { let _ = fs::remove_file(format!("{LAST_SESSION}-{username}")); } +pub fn delete_last_command() { + let _ = fs::remove_file(LAST_COMMAND); +} + +pub fn delete_last_user_command(username: &str) { + let _ = fs::remove_file(format!("{LAST_COMMAND}-{username}")); +} + pub fn get_users(min_uid: u16, max_uid: u16) -> Vec { let users = unsafe { uzers::all_users() }; diff --git a/src/ipc.rs b/src/ipc.rs index 2741de9..f0ae708 100644 --- a/src/ipc.rs +++ b/src/ipc.rs @@ -8,7 +8,7 @@ use tokio::sync::{ use crate::{ event::Event, - info::{delete_last_user_session, delete_last_user_session_path, write_last_user_session, write_last_user_session_path, write_last_username}, + info::{delete_last_user_command, delete_last_user_session, write_last_user_command, write_last_user_session, write_last_username}, macros::SafeDebug, ui::sessions::{Session, SessionSource, SessionType}, AuthStatus, Greeter, Mode, @@ -128,16 +128,16 @@ impl Ipc { SessionSource::Command(ref command) => { tracing::info!("caching last user command: {command}"); - write_last_user_session(&greeter.username.value, command); - delete_last_user_session_path(&greeter.username.value); + write_last_user_command(&greeter.username.value, command); + delete_last_user_session(&greeter.username.value); } SessionSource::Session(index) => { if let Some(Session { path: Some(session_path), .. }) = greeter.sessions.options.get(index) { tracing::info!("caching last user session: {session_path:?}"); - write_last_user_session_path(&greeter.username.value, session_path); - delete_last_user_session(&greeter.username.value); + write_last_user_session(&greeter.username.value, session_path); + delete_last_user_command(&greeter.username.value); } } diff --git a/src/keyboard.rs b/src/keyboard.rs index bde94c3..e7b530a 100644 --- a/src/keyboard.rs +++ b/src/keyboard.rs @@ -5,7 +5,7 @@ use greetd_ipc::Request; use tokio::sync::RwLock; use crate::{ - info::{delete_last_session_path, get_last_user_session, get_last_user_session_path, write_last_session, write_last_session_path}, + info::{delete_last_command, delete_last_session, get_last_user_command, get_last_user_session, write_last_command, write_last_session_path}, ipc::Ipc, power::power, ui::{ @@ -225,8 +225,8 @@ pub async fn handle(greeter: Arc>, input: KeyEvent, ipc: Ipc) -> greeter.session_source = SessionSource::Command(greeter.buffer.clone()); if greeter.remember_session { - write_last_session(&greeter.buffer); - delete_last_session_path(); + write_last_command(&greeter.buffer); + delete_last_session(); } greeter.buffer = greeter.previous_buffer.take().unwrap_or_default(); @@ -248,13 +248,12 @@ pub async fn handle(greeter: Arc>, input: KeyEvent, ipc: Ipc) -> Mode::Sessions => { let session = greeter.sessions.options.get(greeter.sessions.selected).cloned(); - if let Some(Session { path, command, .. }) = session { + if let Some(Session { path, .. }) = session { if greeter.remember_session { if let Some(ref path) = path { write_last_session_path(path); + delete_last_command(); } - - write_last_session(&command); } greeter.session_source = SessionSource::Session(greeter.sessions.selected); @@ -365,7 +364,7 @@ async fn validate_username(greeter: &mut Greeter, ipc: &Ipc) { greeter.buffer = String::new(); if greeter.remember_user_session { - if let Ok(last_session) = get_last_user_session_path(&greeter.username.value) { + if let Ok(last_session) = get_last_user_session(&greeter.username.value) { if let Some(last_session) = Session::from_path(greeter, last_session).cloned() { tracing::info!("remembered user session is {}", last_session.name); @@ -374,7 +373,7 @@ async fn validate_username(greeter: &mut Greeter, ipc: &Ipc) { } } - if let Ok(command) = get_last_user_session(&greeter.username.value) { + if let Ok(command) = get_last_user_command(&greeter.username.value) { tracing::info!("remembered user command is {}", command); greeter.session_source = SessionSource::Command(command);