weyne/rustdesk
1
0
Fork 0
mirror of https://github.com/weyne85/rustdesk.git synced 2025-10-29 17:00:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

refact linux desktop env

Browse Source 
Signed-off-by: fufesou <shuanglongchen@yeah.net>
This commit is contained in:
fufesou
2023-03-28 22:20:15 +08:00
parent 5e79481860
commit 30375a9853
5 changed files with 250 additions and 449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/platform/linux.rs
View File

@@ -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());
}

672
src/platform/linux_desktop.rs → src/platform/linux_desktop_manager.rs
View File

@@ -17,188 +17,161 @@ use users::{get_user_by_name, os::unix::UserExt, User};
lazy_static::lazy_static! {
static ref DESKTOP_RUNNING: Arc<AtomicBool> = Arc::new(AtomicBool::new(false));
static ref DESKTOP_ENV: Arc<Mutex<Desktop>> = Arc::new(Mutex::new(Desktop::new()));
static ref CHILD_FLAGS: Arc<Mutex<Option<ChildFlags>>> = 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<Mutex<Option<DesktopManager>>> = Arc::new(Mutex::new(None));
}
#[derive(Debug)]
struct ChildFlags {
struct DesktopManager {
x11_username: String,
child_username: String,
child_exit: Arc<AtomicBool>,
is_child_running: Arc<AtomicBool>,
}
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<Desktop> {
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<String>,
is_child_running: Arc<AtomicBool>,
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<String> {
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<String>,
is_child_running: Arc<AtomicBool>,
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<String> {
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<String> 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,
}
}
}

2
src/platform/mod.rs
View File

@@ -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};

4
src/rendezvous_mediator.rs
View File

@@ -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<()> {

17
src/server/connection.rs
View File

@@ -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()