temp commit

libs/hbb_common/src/config.rs

@@ -11,7 +11,6 @@ use std::{
     sync::{Arc, Mutex, RwLock},
     time::SystemTime,
 };
-use std::borrow::Borrow;
 
 pub const APP_NAME: &str = "RustDesk";
 pub const RENDEZVOUS_TIMEOUT: u64 = 12_000;
@@ -674,44 +673,92 @@ impl Config {
         }
     }
 
-    pub fn copy_and_reload_config_dir<P: AsRef<Path>>(
+    pub fn sync_config_to_user<P: AsRef<Path>>(target_username: String, to_dir: P) -> bool {
-        target_username: String,
+        let config1_root_file_path = Config::file_("");
-        from: P,
+        let config1_filename = config1_root_file_path.file_name();
-    ) -> Result<bool, fs_extra::error::Error> {
-        let to = Self::path("");
-        let to_parent = to.parent().unwrap();
 
-        let mut options = fs_extra::dir::CopyOptions::new();
+        let config2_root_file_path = Config::file_("2");
-        options.overwrite = true;
+        let config2_filename = config2_root_file_path.file_name();
-        options.copy_inside = true;
 
-        let mut f = from.as_ref();
+        let config1_to_file_path = to_dir
+            .as_ref()
+            .join(PathBuf::from(&config1_filename.unwrap()));
+        let config2_to_file_path = to_dir
+            .as_ref()
+            .join(PathBuf::from(&config2_filename.unwrap()));
 
-        return match fs_extra::dir::copy(f, to_parent, &options) {
+        log::info!(
-            Ok(count) => {
+            "config1_root_path:{}",
-                if count > 0 {
+            &config1_root_file_path.as_path().to_str().unwrap()
-                    log::info!("{}",target_username);
+        );
-                    log::info!("{}",f.to_str().unwrap().to_string());
+        log::info!(
-                    log::info!("{}",to.to_str().unwrap().to_string());
+            "config2_root_path:{}",
+            &config2_root_file_path.as_path().to_str().unwrap()
+        );
+        log::info!(
+            "config1_to_path:{}",
+            &config1_to_file_path.as_path().to_str().unwrap()
+        );
+        log::info!(
+            "config2_to_path:{}",
+            &config2_to_file_path.as_path().to_str().unwrap()
+        );
 
-                    std::process::Command::new("chown")
+        match std::fs::copy(&config1_root_file_path, &config1_to_file_path) {
-                        .arg("-R")
+            Err(e) => log::error!(
-                        .arg(target_username)
+                "copy config {} to user failed: {}",
-                        .arg(to.to_str().unwrap().to_string())
+                config1_filename.unwrap().to_str().unwrap(),
-                        .spawn();
+                e
+            ),
+            _ => {}
+        }
 
+        match std::fs::copy(&config2_root_file_path, &config2_to_file_path) {
+            Err(e) => log::error!(
+                "copy config {} to user failed: {}",
+                config2_filename.unwrap().to_str().unwrap(),
+                e
+            ),
+            _ => {}
+        }
+
+        let success = std::process::Command::new("chown")
+            .arg(&target_username.to_string())
+            .arg(&config1_to_file_path.to_str().unwrap().to_string())
+            .arg(&config2_to_file_path.to_str().unwrap().to_string())
+            .spawn()
+            .is_ok();
+
+        if success {
             CONFIG.write().unwrap().reload();
             CONFIG2.write().unwrap().reload();
         }
 
-                Ok(count > 0)
+        return success;
+    }
+
+    pub fn sync_config_to_root<P: AsRef<Path>>(from_file_path: P) -> bool {
+        if let Some(filename) = from_file_path.as_ref().file_name() {
+            let to = Config::path(filename);
+            return match std::fs::copy(from_file_path, &to) {
+                Ok(count) => {
+                    if count > 0 {
+                        return std::process::Command::new("chown")
+                            .arg("root")
+                            .arg(&to.to_str().unwrap().to_string())
+                            .spawn()
+                            .is_ok();
+                    }
+                    false
                 }
                 Err(e) => {
-                log::error!("config copy failed: {}", e);
+                    log::error!("sync_config_to_root failed: {}", e);
-                Err(e)
+                    false
                 }
             };
         }
+        false
+    }
 }
 
 const PEERS: &str = "peers";

src/ipc.rs

@@ -1,10 +1,20 @@
-use hbb_common::{allow_err, bail, bytes, bytes_codec::BytesCodec, config::{self, Config}, futures::StreamExt as _, futures_util::sink::SinkExt, log, timeout, tokio, tokio::io::{AsyncRead, AsyncWrite}, tokio_util::codec::Framed, ResultType};
+use hbb_common::log::info;
+use hbb_common::{
+    allow_err, bail, bytes,
+    bytes_codec::BytesCodec,
+    config::{self, Config},
+    futures::StreamExt as _,
+    futures_util::sink::SinkExt,
+    log, timeout, tokio,
+    tokio::io::{AsyncRead, AsyncWrite},
+    tokio_util::codec::Framed,
+    ResultType,
+};
 use parity_tokio_ipc::{
     Connection as Conn, ConnectionClient as ConnClient, Endpoint, Incoming, SecurityAttributes,
 };
 use serde_derive::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::path::PathBuf;
 #[cfg(not(windows))]
 use std::{fs::File, io::prelude::*};
 
@@ -83,17 +93,22 @@ pub enum Data {
     Socks(Option<config::Socks5Server>),
     FS(FS),
     Test,
-    ConfigCopyReq {
+    SyncConfigToRootReq {
-        target_username: String,
+        from: String,
-        dir_path: String,
     },
-    ConfigCopyResp(Option<bool>),
+    SyncConfigToRootResp(bool),
+    SyncConfigToUserReq {
+        username: String,
+        to: String,
+    },
+    SyncConfigToUserResp(bool),
 }
 
 #[tokio::main(flavor = "current_thread")]
 pub async fn start(postfix: &str) -> ResultType<()> {
     let mut incoming = new_listener(postfix).await?;
     loop {
+        log::info!("begin loop");
         if let Some(result) = incoming.next().await {
             match result {
                 Ok(stream) => {
@@ -101,13 +116,16 @@ pub async fn start(postfix: &str) -> ResultType<()> {
                     let postfix = postfix.to_owned();
                     tokio::spawn(async move {
                         loop {
+                            log::info!("begin loop");
                             match stream.next().await {
                                 Err(err) => {
                                     log::trace!("ipc{} connection closed: {}", postfix, err);
                                     break;
                                 }
                                 Ok(Some(data)) => {
+                                    log::info!("begin handle");
                                     handle(data, &mut stream).await;
+                                    log::info!("end handle");
                                 }
                                 _ => {}
                             }
@@ -248,22 +266,27 @@ async fn handle(data: Data, stream: &mut Connection) {
             let t = Config::get_nat_type();
             allow_err!(stream.send(&Data::NatType(Some(t))).await);
         }
-        Data::ConfigCopyReq { target_username, dir_path } => {
+        Data::SyncConfigToRootReq { from } => {
-            let from = PathBuf::from(dir_path);
+            info!("begin SyncConfigToRootReq, {}", from);
-            if !from.exists() {
+            allow_err!(
-                allow_err!(stream.send(&Data::ConfigCopyResp(None)).await);
+                stream
-                return;
+                    .send(&Data::SyncConfigToRootResp(Config::sync_config_to_root(
-            }
+                        from
-
+                    )))
-            match Config::copy_and_reload_config_dir(target_username, from) {
+                    .await
-                Ok(result) => {
+            );
-                    allow_err!(stream.send(&Data::ConfigCopyResp(Some(result))).await);
+            info!("begin SyncConfigToRootReq end");
-                }
-                Err(e) => {
-                    log::error!("copy_and_reload_config_dir failed: {:?}",e);
-                    allow_err!(stream.send(&Data::ConfigCopyResp(Some(false))).await);
-                }
         }
+        Data::SyncConfigToUserReq { username, to } => {
+            info!("begin SyncConfigToUserReq,{},{}", username, to);
+            allow_err!(
+                stream
+                    .send(&Data::SyncConfigToUserResp(Config::sync_config_to_user(
+                        username, to
+                    )))
+                    .await
+            );
+            info!("begin SyncConfigToUserReq end");
         }
         _ => {}
     }
@@ -325,7 +348,7 @@ pub struct ConnectionTmpl<T> {
 pub type Connection = ConnectionTmpl<Conn>;
 
 impl<T> ConnectionTmpl<T>
-    where
+where
     T: AsyncRead + AsyncWrite + std::marker::Unpin,
 {
     pub fn new(conn: T) -> Self {

src/platform/macos.rs

@@ -335,6 +335,7 @@ pub fn is_installed() -> bool {
 }
 
 pub fn start_daemon(){
+    log::info!("{}",crate::username());
     if let Err(err) = crate::ipc::start("_daemon") {
         log::error!("Failed to start ipc_daemon: {}", err);
         std::process::exit(-1);

src/server.rs

@@ -14,7 +14,7 @@ use hbb_common::{
     timeout, tokio, ResultType, Stream,
 };
 use service::{GenericService, Service, ServiceTmpl, Subscriber};
-use std::sync::mpsc::RecvError;
+use std::path::PathBuf;
 use std::time::Duration;
 use std::{
     collections::HashMap,
@@ -22,7 +22,6 @@ use std::{
     sync::{Arc, Mutex, RwLock, Weak},
 };
 
-use hbb_common::log::info;
 #[cfg(target_os = "macos")]
 use notify::{watcher, RecursiveMode, Watcher};
 use parity_tokio_ipc::ConnectionClient;
@@ -275,7 +274,9 @@ pub async fn start_server(is_server: bool, _tray: bool) {
         log::info!("XAUTHORITY={:?}", std::env::var("XAUTHORITY"));
     }
 
-    sync_and_watch_config_dir().await;
+    tokio::spawn(async { sync_and_watch_config_dir().await });
+
+    log::info!("enter server");
 
     if is_server {
         std::thread::spawn(move || {
@@ -327,19 +328,22 @@ pub async fn start_server(is_server: bool, _tray: bool) {
     }
 }
 
-async fn sync_and_watch_config_dir() -> ResultType<()> {
+async fn sync_and_watch_config_dir() {
-    let mut conn = crate::ipc::connect(1000, "_daemon").await?;
+    if crate::username() == "root"{
+        return;
+    }
 
-    sync_config_dir(&mut conn, "/var/root/Library/Preferences/com.carriez.RustDesk/".to_string()).await?;
+    match crate::ipc::connect(1000, "_daemon").await {
+        Ok(mut conn) => {
+            sync_config_to_user(&mut conn).await;
 
-    tokio::spawn(async move {
             log::info!(
                 "watching config dir: {}",
                 Config::path("").to_str().unwrap().to_string()
             );
 
             let (tx, rx) = std::sync::mpsc::channel();
-        let mut watcher = watcher(tx, Duration::from_secs(1)).unwrap();
+            let mut watcher = watcher(tx, Duration::from_secs(2)).unwrap();
             watcher
                 .watch(Config::path("").as_path(), RecursiveMode::Recursive)
                 .unwrap();
@@ -353,7 +357,8 @@ async fn sync_and_watch_config_dir() -> ResultType<()> {
                                 "config file changed, call ipc_daemon to sync: {}",
                                 path.to_str().unwrap().to_string()
                             );
-                        sync_config_dir(&mut conn, Config::path("").to_str().unwrap().to_string()).await;
+                            sync_config_to_root(&mut conn, path).await;
+                            log::info!("sync end");
                         }
                         x => {
                             log::info!("another {:?}", x)
@@ -362,33 +367,55 @@ async fn sync_and_watch_config_dir() -> ResultType<()> {
                     Err(e) => println!("watch error: {:?}", e),
                 }
             }
-    });
+        }
-
+        Err(e) => {
-    Ok(())
+            log::info!("connect ipc_daemon failed, skip config sync");
+            return;
+        }
+    }
 }
 
-async fn sync_config_dir(conn: &mut ConnectionTmpl<ConnectionClient>, path: String) -> ResultType<()> {
+async fn sync_config_to_user(conn: &mut ConnectionTmpl<ConnectionClient>) -> ResultType<()> {
     allow_err!(
-        conn.send(&Data::ConfigCopyReq {
+        conn.send(&Data::SyncConfigToUserReq {
-            target_username: crate::username(),
+            username: crate::username(),
-            dir_path: path
+            to: Config::path("").to_str().unwrap().to_string(),
         })
         .await
     );
-    if let Ok(Some(data)) = conn.next_timeout(1000).await {
+
+    if let Some(data) = conn.next_timeout(2000).await? {
         match data {
-            Data::ConfigCopyResp(result) => match result {
+            Data::SyncConfigToUserResp(success) => {
-                Some(success) => {
+                log::info!("copy and reload config dir success: {:?}", success);
-                    if success {
-                        log::info!("copy and reload config dir success");
-                    } else {
-                        log::info!("copy config dir failed. may be first running");
             }
-                }
-                None => {}
-            },
             x => {
-                log::info!("receive another {:?}",x)
+                log::info!("receive another {:?}", x)
+            }
+        };
+    };
+
+    Ok(())
+}
+
+async fn sync_config_to_root(
+    conn: &mut ConnectionTmpl<ConnectionClient>,
+    from: PathBuf,
+) -> ResultType<()> {
+    allow_err!(
+        conn.send(&Data::SyncConfigToRootReq {
+            from: from.to_str().unwrap().to_string()
+        })
+        .await
+    );
+
+    if let Some(data) = conn.next_timeout(2000).await? {
+        match data {
+            Data::SyncConfigToRootResp(success) => {
+                log::info!("copy config to root dir success: {:?}", success);
+            }
+            x => {
+                log::info!("receive another {:?}", x)
             }
         };
     };