diff --git a/src/platform/linux.rs b/src/platform/linux.rs index 857372bd7..85f763ec6 100644 --- a/src/platform/linux.rs +++ b/src/platform/linux.rs @@ -1,4 +1,3 @@ -use super::linux_desktop::{get_desktop_env, Desktop}; use super::{CursorData, ResultType}; use desktop::Desktop; pub use hbb_common::platform::linux::*; @@ -297,6 +296,7 @@ fn force_stop_server() { pub fn start_os_service() { stop_rustdesk_servers(); start_uinput_service(); + start_check_desktop_env(); let running = Arc::new(AtomicBool::new(true)); let r = running.clone(); @@ -371,6 +371,8 @@ pub fn start_os_service() { } } + stop_check_desktop_env(); + if let Some(ps) = user_server.take().as_mut() { allow_err!(ps.kill()); } diff --git a/src/platform/linux_desktop.rs b/src/platform/linux_desktop_manager.rs similarity index 63% rename from src/platform/linux_desktop.rs rename to src/platform/linux_desktop_manager.rs index 0cd66512a..8b9e20640 100644 --- a/src/platform/linux_desktop.rs +++ b/src/platform/linux_desktop_manager.rs @@ -17,188 +17,161 @@ use users::{get_user_by_name, os::unix::UserExt, User}; lazy_static::lazy_static! { static ref DESKTOP_RUNNING: Arc = Arc::new(AtomicBool::new(false)); - static ref DESKTOP_ENV: Arc> = Arc::new(Mutex::new(Desktop::new())); - static ref CHILD_FLAGS: Arc>> = Arc::new(Mutex::new(None)); -} - -pub const VIRTUAL_X11_DESKTOP: &str = "xfce4"; -pub const VIRTUAL_X11_DESKTOP_START: &str = "startxfce4"; -pub const XFCE4_PANEL: &str = "xfce4-panel"; -pub const GNOME_SESSION_BINARY: &str = "gnome-session-binary"; -pub const ENV_DESKTOP_PROTOCAL: &str = "RUSTDESK_PROTOCAL"; -pub const ENV_DESKTOP_PROTOCAL_WAYLAND: &str = "wayland"; -pub const ENV_DESKTOP_PROTOCAL__X11: &str = "x11"; -pub const ENV_DESKTOP_PROTOCAL_UNKNOWN: &str = "unknown"; - -#[derive(Copy, Clone, PartialEq, Debug)] -pub enum Protocal { - Wayland, - X11, // Xorg - Unknown, -} - -#[derive(Debug, Clone)] -pub struct Desktop { - pub sid: String, - pub protocal: Protocal, - pub username: String, - pub uid: String, - pub display: String, - pub xauth: String, + static ref DESKTOP_MANAGER: Arc>> = Arc::new(Mutex::new(None)); } #[derive(Debug)] -struct ChildFlags { +struct DesktopManager { + x11_username: String, + child_username: String, child_exit: Arc, is_child_running: Arc, } -fn check_update_env() { - let mut child_flags = CHILD_FLAGS.lock().unwrap(); - let mut desktop = DESKTOP_ENV.lock().unwrap(); - - if let Some(child_flags) = &mut (*child_flags) { - if child_flags.is_child_running.load(Ordering::SeqCst) { +fn check_desktop_manager() { + let mut desktop_manager = DESKTOP_MANAGER.lock().unwrap(); + if let Some(desktop_manager) = &mut (*desktop_manager) { + if desktop_manager.is_child_running.load(Ordering::SeqCst) { return; } - child_flags.child_exit.store(true, Ordering::SeqCst); - } - - if !desktop.sid.is_empty() && is_active(&desktop.sid) { - return; - } - - let old_desktop = desktop.clone(); - desktop.refresh(); - if !desktop.is_same_env(&old_desktop) { - desktop.update_env(); - log::debug!("desktop env changed, {:?}", &desktop); + desktop_manager.child_exit.store(true, Ordering::SeqCst); } } +// --server process pub fn start_xdesktop() { std::thread::spawn(|| { - if wait_xdesktop(20) { - log::info!("Wait desktop: default"); - } else { - log::info!("Wait desktop: none"); - } - *CHILD_FLAGS.lock().unwrap() = Some(ChildFlags::new()); + *DESKTOP_MANAGER.lock().unwrap() = Some(DesktopManager::new()); let interval = time::Duration::from_millis(super::SERVICE_INTERVAL); DESKTOP_RUNNING.store(true, Ordering::SeqCst); while DESKTOP_RUNNING.load(Ordering::SeqCst) { - check_update_env(); + check_desktop_manager(); std::thread::sleep(interval); } - log::info!("xdesktop update thread exit"); + log::info!("xdesktop child thread exit"); }); } pub fn stop_xdesktop() { DESKTOP_RUNNING.store(false, Ordering::SeqCst); + *DESKTOP_MANAGER.lock().unwrap() = None; } -#[inline] -pub fn get_desktop_env() -> Desktop { - DESKTOP_ENV.lock().unwrap().clone() -} +pub fn try_start_x_session(username: &str, password: &str) -> ResultType<(String, bool)> { + let mut desktop_manager = DESKTOP_MANAGER.lock().unwrap(); + if let Some(desktop_manager) = &mut (*desktop_manager) { + if !desktop_manager.x11_username.is_empty() { + return Ok((desktop_manager.x11_username.clone(), true)); + } -pub fn try_start_x_session(username: &str, password: &str) -> ResultType { - let mut child_flags = CHILD_FLAGS.lock().unwrap(); - let mut desktop_lock = DESKTOP_ENV.lock().unwrap(); - let mut desktop = Desktop::new(); - if let Some(child_flags) = &mut (*child_flags) { - let _ = child_flags.try_start_x_session(&mut desktop, username, password)?; + let _ = desktop_manager.try_start_x_session(username, password)?; log::debug!( "try_start_x_session, username: {}, {:?}", &username, - &child_flags + &desktop_manager ); - *desktop_lock = desktop.clone(); - Ok(desktop) + Ok(( + desktop_manager.child_username.clone(), + desktop_manager.is_running(), + )) } else { bail!(crate::server::LOGIN_MSG_XDESKTOP_NOT_INITED); } } -fn wait_xdesktop(timeout_secs: u64) -> bool { - let wait_begin = Instant::now(); - while wait_begin.elapsed().as_secs() < timeout_secs { - let uid = &get_values_of_seat0(&[1])[0]; - if !uid.is_empty() { - return true; +pub fn get_username() -> String { + match &*DESKTOP_MANAGER.lock().unwrap() { + Some(manager) => { + if !manager.x11_username.is_empty() { + manager.x11_username.clone() + } else { + if manager.is_running() && !manager.child_username.is_empty() { + manager.child_username.clone() + } else { + "".to_owned() + } + } } + None => "".to_owned(), + } +} - if let Ok(output) = run_cmds(format!( - "ps -ef | grep -v 'grep' | grep -E 'gnome-session-binary|{}'", - XFCE4_PANEL - )) { - if !output.is_empty() { - log::info!("wait xdesktop: find xclient {}", &output); - return true; +impl Drop for DesktopManager { + fn drop(&mut self) { + self.stop_children(); + } +} + +impl DesktopManager { + fn fatal_exit() { + std::process::exit(0); + } + + pub fn new() -> Self { + let mut x11_username = "".to_owned(); + let seat0_values = get_values_of_seat0(&[0, 1, 2]); + if !seat0_values[0].is_empty() { + if "x11" == get_display_server_of_session(&seat0_values[1]) { + x11_username = seat0_values[2].clone(); } } - std::thread::sleep(Duration::from_millis(super::SERVICE_INTERVAL)); - } - - false -} - -impl Desktop { - pub fn new() -> Self { - let xauth = get_env_var("XAUTHORITY"); - Self { - sid: "".to_owned(), - protocal: Protocal::Unknown, - username: "".to_owned(), - uid: "".to_owned(), - display: "".to_owned(), - xauth: if xauth.is_empty() { - "/tmp/.Xauthority".to_owned() - } else { - xauth - }, + x11_username, + child_username: "".to_owned(), + child_exit: Arc::new(AtomicBool::new(true)), + is_child_running: Arc::new(AtomicBool::new(false)), } } - fn update_env(&self) { - if self.is_x11() { - std::env::set_var("DISPLAY", &self.display); - std::env::set_var("XAUTHORITY", &self.xauth); - std::env::set_var(ENV_DESKTOP_PROTOCAL, &self.protocal.to_string()); + #[inline] + fn get_xauth() -> String { + let xauth = get_env_var("XAUTHORITY"); + if xauth.is_empty() { + "/tmp/.Xauthority".to_owned() } else { - std::env::set_var("DISPLAY", ""); - std::env::set_var("XAUTHORITY", ""); - std::env::set_var(ENV_DESKTOP_PROTOCAL, &self.protocal.to_string()); + xauth } } - pub fn is_same_env(&self, other: &Self) -> bool { - self.sid == other.sid - && self.protocal == other.protocal - && self.uid == other.uid - && self.display == other.display - && self.xauth == other.xauth + #[inline] + fn is_running(&self) -> bool { + self.is_child_running.load(Ordering::SeqCst) } - #[inline] - pub fn is_x11(&self) -> bool { - self.protocal == Protocal::X11 - } + fn try_start_x_session(&mut self, username: &str, password: &str) -> ResultType<()> { + match get_user_by_name(username) { + Some(userinfo) => { + let mut client = pam::Client::with_password(pam_get_service_name())?; + client + .conversation_mut() + .set_credentials(username, password); + match client.authenticate() { + Ok(_) => { + if self.is_running() { + return Ok(()); + } - #[inline] - pub fn is_wayland(&self) -> bool { - self.protocal == Protocal::Wayland - } - - #[inline] - pub fn is_ready(&self) -> bool { - match self.protocal { - Protocal::X11 | Protocal::Wayland => true, - _ => false, + match self.start_x_session(&userinfo, username, password) { + Ok(_) => { + log::info!("Succeeded to start x11"); + self.child_username = username.to_string(); + Ok(()) + } + Err(e) => { + bail!("failed to start x session, {}", e); + } + } + } + Err(e) => { + bail!("failed to check user pass for {}, {}", username, e); + } + } + } + None => { + bail!("failed to get userinfo of {}", username); + } } } @@ -220,83 +193,131 @@ impl Desktop { || Path::new(&format!("/tmp/.X{}-lock", display)).exists() } - fn get_display(&mut self) { - self.display = get_env_tries("DISPLAY", &self.uid, GNOME_SESSION_BINARY, 10); - if self.display.is_empty() { - self.display = get_env_tries("DISPLAY", &self.uid, XFCE4_PANEL, 10); - } - if self.display.is_empty() { - self.display = Self::get_display_by_user(&self.username); - } - if self.display.is_empty() { - self.display = ":0".to_owned(); - } - self.display = self - .display - .replace(&whoami::hostname(), "") - .replace("localhost", ""); - } + fn start_x_session( + &mut self, + userinfo: &User, + username: &str, + password: &str, + ) -> ResultType<()> { + self.stop_children(); - fn get_xauth(&mut self) { - self.xauth = get_env_tries("XAUTHORITY", &self.uid, GNOME_SESSION_BINARY, 10); - if self.xauth.is_empty() { - get_env_tries("XAUTHORITY", &self.uid, XFCE4_PANEL, 10); - } + let display_num = Self::get_avail_display()?; + // "xServer_ip:display_num.screen_num" - let gdm = format!("/run/user/{}/gdm/Xauthority", self.uid); - if self.xauth.is_empty() { - self.xauth = if std::path::Path::new(&gdm).exists() { - gdm - } else { - let username = &self.username; - if username == "root" { - format!("/{}/.Xauthority", username) + let uid = userinfo.uid(); + let gid = userinfo.primary_group_id(); + let envs = HashMap::from([ + ("SHELL", userinfo.shell().to_string_lossy().to_string()), + ("PATH", "/sbin:/bin:/usr/bin:/usr/local/bin".to_owned()), + ("USER", username.to_string()), + ("UID", userinfo.uid().to_string()), + ("HOME", userinfo.home_dir().to_string_lossy().to_string()), + ( + "XDG_RUNTIME_DIR", + format!("/run/user/{}", userinfo.uid().to_string()), + ), + // ("DISPLAY", self.display.clone()), + // ("XAUTHORITY", self.xauth.clone()), + // (ENV_DESKTOP_PROTOCAL, XProtocal::X11.to_string()), + ]); + self.child_exit.store(false, Ordering::SeqCst); + let is_child_running = self.is_child_running.clone(); + + let (tx_res, rx_res) = sync_channel(1); + let password = password.to_string(); + let username = username.to_string(); + // start x11 + std::thread::spawn(move || { + match Self::start_x_session_thread( + tx_res.clone(), + is_child_running, + uid, + gid, + display_num, + username, + password, + envs, + ) { + Ok(_) => {} + Err(e) => { + log::error!("Failed to start x session thread"); + allow_err!(tx_res.send(format!("Failed to start x session thread, {}", e))); + } + } + }); + + // wait x11 + match rx_res.recv_timeout(Duration::from_millis(10_000)) { + Ok(res) => { + if res == "" { + Ok(()) } else { - let tmp = format!("/home/{}/.Xauthority", username); - if std::path::Path::new(&tmp).exists() { - tmp - } else { - format!("/var/lib/{}/.Xauthority", username) - } + bail!(res) } - }; + } + Err(e) => { + bail!("Failed to recv x11 result {}", e) + } } } - fn get_display_by_user(user: &str) -> String { - // log::debug!("w {}", &user); - if let Ok(output) = std::process::Command::new("w").arg(&user).output() { - for line in String::from_utf8_lossy(&output.stdout).lines() { - let mut iter = line.split_whitespace(); - let b = iter.nth(2); - if let Some(b) = b { - if b.starts_with(":") { - return b.to_owned(); + #[inline] + fn display_from_num(num: u32) -> String { + format!(":{num}") + } + + fn start_x_session_thread( + tx_res: SyncSender, + is_child_running: Arc, + uid: u32, + gid: u32, + display_num: u32, + username: String, + password: String, + envs: HashMap<&str, String>, + ) -> ResultType<()> { + let mut client = pam::Client::with_password(pam_get_service_name())?; + client + .conversation_mut() + .set_credentials(&username, &password); + client.authenticate()?; + + client.set_item(pam::PamItemType::TTY, &Self::display_from_num(display_num))?; + client.open_session()?; + + // fixme: FreeBSD kernel needs to login here. + // see: https://github.com/neutrinolabs/xrdp/blob/a64573b596b5fb07ca3a51590c5308d621f7214e/sesman/session.c#L556 + + let (child_xorg, child_wm) = Self::start_x11(uid, gid, username, display_num, &envs)?; + is_child_running.store(true, Ordering::SeqCst); + + log::info!("Start xorg and wm done, notify and wait xtop x11"); + allow_err!(tx_res.send("".to_owned())); + + Self::wait_stop_x11(child_xorg, child_wm); + log::info!("Wait x11 stop done"); + Ok(()) + } + + fn wait_xorg_exit(child_xorg: &mut Child) -> ResultType { + if let Ok(_) = child_xorg.kill() { + for _ in 0..3 { + match child_xorg.try_wait() { + Ok(Some(status)) => return Ok(format!("Xorg exit with {}", status)), + Ok(None) => {} + Err(e) => { + // fatal error + log::error!("Failed to wait xorg process, {}", e); + bail!("Failed to wait xorg process, {}", e) } } + std::thread::sleep(std::time::Duration::from_millis(1_000)); } + log::error!("Failed to wait xorg process, not exit"); + bail!("Failed to wait xorg process, not exit") + } else { + Ok("Xorg is already exited".to_owned()) } - // above not work for gdm user - //log::debug!("ls -l /tmp/.X11-unix/"); - let mut last = "".to_owned(); - if let Ok(output) = std::process::Command::new("ls") - .args(vec!["-l", "/tmp/.X11-unix/"]) - .output() - { - for line in String::from_utf8_lossy(&output.stdout).lines() { - let mut iter = line.split_whitespace(); - let user_field = iter.nth(2); - if let Some(x) = iter.last() { - if x.starts_with("X") { - last = x.replace("X", ":").to_owned(); - if user_field == Some(&user) { - return last; - } - } - } - } - } - last } fn add_xauth_cookie( @@ -343,233 +364,28 @@ impl Desktop { } } - fn refresh(&mut self) { - *self = Self::new(); - - let seat0_values = get_values_of_seat0(&[0, 1, 2]); - if seat0_values[0].is_empty() { - return; - } - - self.sid = seat0_values[0].clone(); - self.uid = seat0_values[1].clone(); - self.username = seat0_values[2].clone(); - self.protocal = get_display_server_of_session(&self.sid).into(); - self.get_display(); - self.get_xauth(); - } -} - -impl Drop for ChildFlags { - fn drop(&mut self) { - self.stop_children(); - } -} - -impl ChildFlags { - fn fatal_exit() { - std::process::exit(0); - } - - pub fn new() -> Self { - Self { - child_exit: Arc::new(AtomicBool::new(true)), - is_child_running: Arc::new(AtomicBool::new(false)), - } - } - - fn try_start_x_session( - &mut self, - desktop: &mut Desktop, - username: &str, - password: &str, - ) -> ResultType<()> { - match get_user_by_name(username) { - Some(userinfo) => { - let mut client = pam::Client::with_password(pam_get_service_name())?; - client - .conversation_mut() - .set_credentials(username, password); - match client.authenticate() { - Ok(_) => { - if desktop.is_x11() && desktop.username == username { - return Ok(()); - } - - // to-do: sid is empty if xorg is managed by this process - desktop.sid = "".to_owned(); - desktop.username = username.to_string(); - desktop.uid = userinfo.uid().to_string(); - desktop.protocal = Protocal::Unknown; - match self.start_x_session(desktop, &userinfo, password) { - Ok(_) => { - log::info!("Succeeded to start x11, update env {:?}", &desktop); - desktop.update_env(); - Ok(()) - } - Err(e) => { - *desktop = Desktop::new(); - desktop.update_env(); - bail!("failed to start x session, {}", e); - } - } - } - Err(e) => { - bail!("failed to check user pass for {}, {}", username, e); - } - } - } - None => { - bail!("failed to get userinfo of {}", username); - } - } - } - - fn start_x_session( - &mut self, - desktop: &mut Desktop, - userinfo: &User, - password: &str, - ) -> ResultType<()> { - self.stop_children(); - - let display_num = Desktop::get_avail_display()?; - // "xServer_ip:display_num.screen_num" - desktop.display = format!(":{}", display_num); - - let uid = userinfo.uid(); - let gid = userinfo.primary_group_id(); - let envs = HashMap::from([ - ("SHELL", userinfo.shell().to_string_lossy().to_string()), - ("PATH", "/sbin:/bin:/usr/bin:/usr/local/bin".to_owned()), - ("USER", desktop.username.clone()), - ("UID", userinfo.uid().to_string()), - ("HOME", userinfo.home_dir().to_string_lossy().to_string()), - ( - "XDG_RUNTIME_DIR", - format!("/run/user/{}", userinfo.uid().to_string()), - ), - // ("DISPLAY", self.display.clone()), - // ("XAUTHORITY", self.xauth.clone()), - // (ENV_DESKTOP_PROTOCAL, XProtocal::X11.to_string()), - ]); - let desktop_clone = desktop.clone(); - self.child_exit.store(false, Ordering::SeqCst); - let is_child_running = self.is_child_running.clone(); - - let (tx_res, rx_res) = sync_channel(1); - let password = password.to_string(); - // start x11 - std::thread::spawn(move || { - match Self::start_x_session_thread( - tx_res.clone(), - is_child_running, - desktop_clone, - uid, - gid, - display_num, - password, - envs, - ) { - Ok(_) => {} - Err(e) => { - log::error!("Failed to start x session thread"); - allow_err!(tx_res.send(format!("Failed to start x session thread, {}", e))); - } - } - }); - - // wait x11 - match rx_res.recv_timeout(Duration::from_millis(10_000)) { - Ok(res) => { - if res == "" { - desktop.protocal = Protocal::X11; - Ok(()) - } else { - bail!(res) - } - } - Err(e) => { - bail!("Failed to recv x11 result {}", e) - } - } - } - - fn start_x_session_thread( - tx_res: SyncSender, - is_child_running: Arc, - desktop: Desktop, - uid: u32, - gid: u32, - display_num: u32, - password: String, - envs: HashMap<&str, String>, - ) -> ResultType<()> { - let mut client = pam::Client::with_password(pam_get_service_name())?; - client - .conversation_mut() - .set_credentials(&desktop.username, &password); - client.authenticate()?; - - client.set_item(pam::PamItemType::TTY, &desktop.display)?; - client.open_session()?; - - // fixme: FreeBSD kernel needs to login here. - // see: https://github.com/neutrinolabs/xrdp/blob/a64573b596b5fb07ca3a51590c5308d621f7214e/sesman/session.c#L556 - - let (child_xorg, child_wm) = Self::start_x11(&desktop, uid, gid, display_num, &envs)?; - is_child_running.store(true, Ordering::SeqCst); - - log::info!("Start xorg and wm done, notify and wait xtop x11"); - allow_err!(tx_res.send("".to_owned())); - - Self::wait_stop_x11(child_xorg, child_wm); - log::info!("Wait x11 stop done"); - Ok(()) - } - - fn wait_xorg_exit(child_xorg: &mut Child) -> ResultType { - if let Ok(_) = child_xorg.kill() { - for _ in 0..3 { - match child_xorg.try_wait() { - Ok(Some(status)) => return Ok(format!("Xorg exit with {}", status)), - Ok(None) => {} - Err(e) => { - // fatal error - log::error!("Failed to wait xorg process, {}", e); - bail!("Failed to wait xorg process, {}", e) - } - } - std::thread::sleep(std::time::Duration::from_millis(1_000)); - } - log::error!("Failed to wait xorg process, not exit"); - bail!("Failed to wait xorg process, not exit") - } else { - Ok("Xorg is already exited".to_owned()) - } - } - fn start_x11( - desktop: &Desktop, uid: u32, gid: u32, + username: String, display_num: u32, envs: &HashMap<&str, String>, ) -> ResultType<(Child, Child)> { - log::debug!("envs of user {}: {:?}", &desktop.username, &envs); + log::debug!("envs of user {}: {:?}", &username, &envs); - Desktop::add_xauth_cookie(&desktop.xauth, &desktop.display, uid, gid, &envs)?; + let xauth = Self::get_xauth(); + let display = Self::display_from_num(display_num); + + Self::add_xauth_cookie(&xauth, &display, uid, gid, &envs)?; // Start Xorg - let mut child_xorg = - Self::start_x_server(&desktop.xauth, &desktop.display, uid, gid, &envs)?; + let mut child_xorg = Self::start_x_server(&xauth, &display, uid, gid, &envs)?; log::info!("xorg started, wait 10 secs to ensuer x server is running"); let max_wait_secs = 10; // wait x server running - if let Err(e) = Desktop::wait_x_server_running(child_xorg.id(), display_num, max_wait_secs) - { + if let Err(e) = Self::wait_x_server_running(child_xorg.id(), display_num, max_wait_secs) { match Self::wait_xorg_exit(&mut child_xorg) { Ok(msg) => log::info!("{}", msg), Err(e) => { @@ -582,12 +398,12 @@ impl ChildFlags { log::info!( "xorg is running, start x window manager with DISPLAY: {}, XAUTHORITY: {}", - &desktop.display, - &desktop.xauth + &display, + &xauth ); - std::env::set_var("DISPLAY", &desktop.display); - std::env::set_var("XAUTHORITY", &desktop.xauth); + std::env::set_var("DISPLAY", &display); + std::env::set_var("XAUTHORITY", &xauth); // start window manager (startwm.sh) let child_wm = match Self::start_x_window_manager(uid, gid, &envs) { Ok(c) => c, @@ -707,10 +523,10 @@ impl ChildFlags { } fn try_wait_stop_x11(child_xorg: &mut Child, child_wm: &mut Child) -> bool { - let mut child_flags = CHILD_FLAGS.lock().unwrap(); + let mut desktop_manager = DESKTOP_MANAGER.lock().unwrap(); let mut exited = true; - if let Some(child_flags) = &mut (*child_flags) { - if child_flags.child_exit.load(Ordering::SeqCst) { + if let Some(desktop_manager) = &mut (*desktop_manager) { + if desktop_manager.child_exit.load(Ordering::SeqCst) { exited = true; } else { exited = Self::try_wait_x11_child_exit(child_xorg, child_wm); @@ -718,8 +534,10 @@ impl ChildFlags { if exited { println!("=============================MYDEBUG begin to wait x11 children exit"); Self::wait_x11_children_exit(child_xorg, child_wm); - child_flags.is_child_running.store(false, Ordering::SeqCst); - child_flags.child_exit.store(true, Ordering::SeqCst); + desktop_manager + .is_child_running + .store(false, Ordering::SeqCst); + desktop_manager.child_exit.store(true, Ordering::SeqCst); } } exited @@ -843,23 +661,3 @@ fn pam_get_service_name() -> &'static str { "gdm" } } - -impl ToString for Protocal { - fn to_string(&self) -> String { - match self { - Protocal::X11 => ENV_DESKTOP_PROTOCAL__X11.to_owned(), - Protocal::Wayland => ENV_DESKTOP_PROTOCAL_WAYLAND.to_owned(), - Protocal::Unknown => ENV_DESKTOP_PROTOCAL_UNKNOWN.to_owned(), - } - } -} - -impl From for Protocal { - fn from(value: String) -> Self { - match &value as &str { - ENV_DESKTOP_PROTOCAL__X11 => Protocal::X11, - ENV_DESKTOP_PROTOCAL_WAYLAND => Protocal::Wayland, - _ => Protocal::Unknown, - } - } -} diff --git a/src/platform/mod.rs b/src/platform/mod.rs index 16bcc775a..7c9b2f0b0 100644 --- a/src/platform/mod.rs +++ b/src/platform/mod.rs @@ -18,7 +18,7 @@ pub mod delegate; pub mod linux; #[cfg(target_os = "linux")] -pub mod linux_desktop; +pub mod linux_desktop_manager; #[cfg(not(any(target_os = "android", target_os = "ios")))] use hbb_common::{message_proto::CursorData, ResultType}; diff --git a/src/rendezvous_mediator.rs b/src/rendezvous_mediator.rs index 5a68a4a03..3fef9747b 100644 --- a/src/rendezvous_mediator.rs +++ b/src/rendezvous_mediator.rs @@ -73,7 +73,7 @@ impl RendezvousMediator { }); } #[cfg(target_os = "linux")] - crate::platform::linux_desktop::start_xdesktop(); + crate::platform::linux_desktop_manager::start_xdesktop(); SHOULD_EXIT.store(false, Ordering::SeqCst); while !SHOULD_EXIT.load(Ordering::SeqCst) { Config::reset_online(); @@ -100,7 +100,7 @@ impl RendezvousMediator { sleep(1.).await; } #[cfg(target_os = "linux")] - crate::platform::linux_desktop::stop_xdesktop(); + crate::platform::linux_desktop_manager::stop_xdesktop(); } pub async fn start(server: ServerPtr, host: String) -> ResultType<()> { diff --git a/src/server/connection.rs b/src/server/connection.rs index a5c63a80e..2d9e60f04 100644 --- a/src/server/connection.rs +++ b/src/server/connection.rs @@ -1074,18 +1074,19 @@ impl Connection { fn try_start_desktop(_username: &str, _passsword: &str) -> String { #[cfg(target_os = "linux")] if _username.is_empty() { - let desktop = crate::platform::linux_desktop::get_desktop_env(); - if desktop.is_ready() { - "" - } else { + let username = crate::platform::linux_desktop_manager::get_username(); + if username.is_empty() { LOGIN_MSG_XSESSION_NOT_READY + } else { + "" } .to_owned() } else { - match crate::platform::linux_desktop::try_start_x_session(_username, _passsword) { - Ok(desktop) => { - if desktop.is_ready() { - if _username != desktop.username { + match crate::platform::linux_desktop_manager::try_start_x_session(_username, _passsword) + { + Ok((username, x11_ready)) => { + if x11_ready { + if _username != username { LOGIN_MSG_XSESSION_ANOTHER_USER_READTY.to_owned() } else { "".to_owned()