refactor: reload file hierarchies

rename libs/src/platform/{linux => unix}

Signed-off-by: ClSlaid <cailue@bupt.edu.cn>

libs/clipboard/src/platform/unix/local_file.rs

@@ -0,0 +1,362 @@
+use std::{
+    collections::HashSet,
+    fs::File,
+    io::{BufReader, Read, Seek},
+    os::unix::prelude::PermissionsExt,
+    path::PathBuf,
+    sync::atomic::{AtomicU64, Ordering},
+    time::SystemTime,
+};
+
+use hbb_common::{
+    bytes::{BufMut, BytesMut},
+    log,
+};
+use utf16string::WString;
+
+use crate::{
+    platform::{fuse::BLOCK_SIZE, LDAP_EPOCH_DELTA},
+    CliprdrError,
+};
+
+/// has valid file attributes
+const FLAGS_FD_ATTRIBUTES: u32 = 0x04;
+/// has valid file size
+const FLAGS_FD_SIZE: u32 = 0x40;
+/// has valid last write time
+const FLAGS_FD_LAST_WRITE: u32 = 0x20;
+/// show progress
+const FLAGS_FD_PROGRESSUI: u32 = 0x4000;
+/// transferred from unix, contains file mode
+/// P.S. this flag is not used in windows
+const FLAGS_FD_UNIX_MODE: u32 = 0x08;
+
+#[derive(Debug)]
+pub(super) struct LocalFile {
+    pub path: PathBuf,
+
+    pub handle: Option<BufReader<File>>,
+    pub offset: AtomicU64,
+
+    pub name: String,
+    pub size: u64,
+    pub last_write_time: SystemTime,
+    pub is_dir: bool,
+    pub perm: u32,
+    pub read_only: bool,
+    pub hidden: bool,
+    pub system: bool,
+    pub archive: bool,
+    pub normal: bool,
+}
+
+impl LocalFile {
+    pub fn try_open(path: &PathBuf) -> Result<Self, CliprdrError> {
+        let mt = std::fs::metadata(path).map_err(|e| CliprdrError::FileError {
+            path: path.clone(),
+            err: e,
+        })?;
+        let size = mt.len() as u64;
+        let is_dir = mt.is_dir();
+        let read_only = mt.permissions().readonly();
+        let system = false;
+        let hidden = path.to_string_lossy().starts_with('.');
+        let archive = false;
+        let normal = !(is_dir || read_only || system || hidden || archive);
+        let last_write_time = mt.modified().unwrap_or(SystemTime::UNIX_EPOCH);
+
+        let perm = mt.permissions().mode();
+
+        let name = path
+            .display()
+            .to_string()
+            .trim_start_matches('/')
+            .replace('/', "\\");
+
+        // NOTE: open files lazily
+        let handle = None;
+        let offset = AtomicU64::new(0);
+
+        Ok(Self {
+            name,
+            path: path.clone(),
+            handle,
+            offset,
+            size,
+            last_write_time,
+            is_dir,
+            read_only,
+            system,
+            hidden,
+            perm,
+            archive,
+            normal,
+        })
+    }
+    pub fn as_bin(&self) -> Vec<u8> {
+        let mut buf = BytesMut::with_capacity(592);
+
+        let read_only_flag = if self.read_only { 0x1 } else { 0 };
+        let hidden_flag = if self.hidden { 0x2 } else { 0 };
+        let system_flag = if self.system { 0x4 } else { 0 };
+        let directory_flag = if self.is_dir { 0x10 } else { 0 };
+        let archive_flag = if self.archive { 0x20 } else { 0 };
+        let normal_flag = if self.normal { 0x80 } else { 0 };
+
+        let file_attributes: u32 = read_only_flag
+            | hidden_flag
+            | system_flag
+            | directory_flag
+            | archive_flag
+            | normal_flag;
+
+        let win32_time = self
+            .last_write_time
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos() as u64
+            / 100
+            + LDAP_EPOCH_DELTA;
+
+        let size_high = (self.size >> 32) as u32;
+        let size_low = (self.size & (u32::MAX as u64)) as u32;
+
+        let path = self.path.to_string_lossy().to_string();
+
+        let wstr: WString<utf16string::LE> = WString::from(&path);
+        let name = wstr.as_bytes();
+
+        log::trace!(
+            "put file to list: name_len {}, name {}",
+            name.len(),
+            &self.name
+        );
+
+        let flags = FLAGS_FD_SIZE
+            | FLAGS_FD_LAST_WRITE
+            | FLAGS_FD_ATTRIBUTES
+            | FLAGS_FD_PROGRESSUI
+            | FLAGS_FD_UNIX_MODE;
+
+        // flags, 4 bytes
+        buf.put_u32_le(flags);
+        // 32 bytes reserved
+        buf.put(&[0u8; 32][..]);
+        // file attributes, 4 bytes
+        buf.put_u32_le(file_attributes);
+
+        // NOTE: this is not used in windows
+        // in the specification, this is 16 bytes reserved
+        // lets use the last 4 bytes to store the file mode
+        //
+        // 12 bytes reserved
+        buf.put(&[0u8; 12][..]);
+        // file permissions, 4 bytes
+        buf.put_u32_le(self.perm);
+
+        // last write time, 8 bytes
+        buf.put_u64_le(win32_time);
+        // file size (high)
+        buf.put_u32_le(size_high);
+        // file size (low)
+        buf.put_u32_le(size_low);
+        // put name and padding to 520 bytes
+        let name_len = name.len();
+        buf.put(name);
+        buf.put(&vec![0u8; 520 - name_len][..]);
+
+        buf.to_vec()
+    }
+
+    #[inline]
+    pub fn load_handle(&mut self) -> Result<(), CliprdrError> {
+        if !self.is_dir && self.handle.is_none() {
+            let handle = std::fs::File::open(&self.path).map_err(|e| CliprdrError::FileError {
+                path: self.path.clone(),
+                err: e,
+            })?;
+            let reader = BufReader::with_capacity(BLOCK_SIZE as usize, handle);
+            self.handle = Some(reader);
+        };
+        Ok(())
+    }
+
+    pub fn read_exact_at(&mut self, buf: &mut [u8], offset: u64) -> Result<(), CliprdrError> {
+        self.load_handle()?;
+
+        let handle = self.handle.as_mut().unwrap();
+
+        if offset != self.offset.load(Ordering::Relaxed) {
+            handle
+                .seek(std::io::SeekFrom::Start(offset))
+                .map_err(|e| CliprdrError::FileError {
+                    path: self.path.clone(),
+                    err: e,
+                })?;
+        }
+        handle
+            .read_exact(buf)
+            .map_err(|e| CliprdrError::FileError {
+                path: self.path.clone(),
+                err: e,
+            })?;
+        let new_offset = offset + (buf.len() as u64);
+        self.offset.store(new_offset, Ordering::Relaxed);
+
+        // gc file handle
+        if new_offset >= self.size {
+            self.offset.store(0, Ordering::Relaxed);
+            self.handle = None;
+        }
+
+        Ok(())
+    }
+}
+
+pub(super) fn construct_file_list(paths: &[PathBuf]) -> Result<Vec<LocalFile>, CliprdrError> {
+    fn constr_file_lst(
+        path: &PathBuf,
+        file_list: &mut Vec<LocalFile>,
+        visited: &mut HashSet<PathBuf>,
+    ) -> Result<(), CliprdrError> {
+        // prevent fs loop
+        if visited.contains(path) {
+            return Ok(());
+        }
+        visited.insert(path.clone());
+
+        let local_file = LocalFile::try_open(path)?;
+        file_list.push(local_file);
+
+        let mt = std::fs::metadata(path).map_err(|e| CliprdrError::FileError {
+            path: path.clone(),
+            err: e,
+        })?;
+
+        if mt.is_dir() {
+            let dir = std::fs::read_dir(path).unwrap();
+            for entry in dir {
+                let entry = entry.unwrap();
+                let path = entry.path();
+                constr_file_lst(&path, file_list, visited)?;
+            }
+        }
+        Ok(())
+    }
+
+    let mut file_list = Vec::new();
+    let mut visited = HashSet::new();
+
+    for path in paths {
+        constr_file_lst(path, &mut file_list, &mut visited)?;
+    }
+    Ok(file_list)
+}
+
+#[cfg(test)]
+mod file_list_test {
+    use std::path::PathBuf;
+
+    use hbb_common::bytes::{BufMut, BytesMut};
+
+    use crate::{platform::fuse::FileDescription, CliprdrError};
+
+    use super::LocalFile;
+
+    #[inline]
+    fn generate_tree(prefix: &str) -> Vec<LocalFile> {
+        // generate a tree of local files, no handles
+        // - /
+        // |- a.txt
+        // |- b
+        //    |- c.txt
+        #[inline]
+        fn generate_file(path: &str, name: &str, is_dir: bool) -> LocalFile {
+            LocalFile {
+                path: PathBuf::from(path),
+                handle: None,
+                name: name.to_string(),
+                size: 0,
+                last_write_time: std::time::SystemTime::UNIX_EPOCH,
+                read_only: false,
+                is_dir,
+                perm: 0o754,
+                hidden: false,
+                system: false,
+                archive: false,
+                normal: false,
+            }
+        }
+
+        let p = prefix;
+
+        let (r_path, a_path, b_path, c_path) = if !prefix.is_empty() {
+            (
+                p.to_string(),
+                format!("{}/a.txt", p),
+                format!("{}/b", p),
+                format!("{}/b/c.txt", p),
+            )
+        } else {
+            (
+                ".".to_string(),
+                "a.txt".to_string(),
+                "b".to_string(),
+                "b/c.txt".to_string(),
+            )
+        };
+
+        let root = generate_file(&r_path, ".", true);
+        let a = generate_file(&a_path, "a.txt", false);
+        let b = generate_file(&b_path, "b", true);
+        let c = generate_file(&c_path, "c.txt", false);
+
+        vec![root, a, b, c]
+    }
+
+    fn as_bin_parse_test(prefix: &str) -> Result<(), CliprdrError> {
+        let tree = generate_tree(prefix);
+        let mut pdu = BytesMut::with_capacity(4 + 592 * tree.len());
+        pdu.put_u32_le(tree.len() as u32);
+        for file in tree {
+            pdu.put(file.as_bin().as_slice());
+        }
+
+        let parsed = FileDescription::parse_file_descriptors(pdu.to_vec(), 0)?;
+        assert_eq!(parsed.len(), 4);
+
+        if !prefix.is_empty() {
+            assert_eq!(parsed[0].name.to_str().unwrap(), format!("{}", prefix));
+            assert_eq!(
+                parsed[1].name.to_str().unwrap(),
+                format!("{}/a.txt", prefix)
+            );
+            assert_eq!(parsed[2].name.to_str().unwrap(), format!("{}/b", prefix));
+            assert_eq!(
+                parsed[3].name.to_str().unwrap(),
+                format!("{}/b/c.txt", prefix)
+            );
+        } else {
+            assert_eq!(parsed[0].name.to_str().unwrap(), ".");
+            assert_eq!(parsed[1].name.to_str().unwrap(), "a.txt");
+            assert_eq!(parsed[2].name.to_str().unwrap(), "b");
+            assert_eq!(parsed[3].name.to_str().unwrap(), "b/c.txt");
+        }
+
+        assert!(parsed[0].perm & 0o777 == 0o754);
+        assert!(parsed[1].perm & 0o777 == 0o754);
+        assert!(parsed[2].perm & 0o777 == 0o754);
+        assert!(parsed[3].perm & 0o777 == 0o754);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_file_descriptors() -> Result<(), CliprdrError> {
+        as_bin_parse_test("")?;
+        as_bin_parse_test("/")?;
+        as_bin_parse_test("test")?;
+        as_bin_parse_test("/test")?;
+        Ok(())
+    }
+}

libs/clipboard/src/platform/unix/mod.rs

@@ -0,0 +1,585 @@
+use std::{
+    path::PathBuf,
+    sync::{mpsc::Sender, Arc},
+    time::Duration,
+};
+
+use dashmap::DashMap;
+use fuser::MountOption;
+use hbb_common::{
+    bytes::{BufMut, BytesMut},
+    log,
+};
+use lazy_static::lazy_static;
+use parking_lot::Mutex;
+
+use crate::{
+    platform::{fuse::FileDescription, unix::local_file::construct_file_list},
+    send_data, ClipboardFile, CliprdrError, CliprdrServiceContext,
+};
+
+use self::local_file::LocalFile;
+use self::url::{encode_path_to_uri, parse_plain_uri_list};
+
+use super::fuse::FuseServer;
+
+#[cfg(not(feature = "wayland"))]
+pub mod x11;
+
+pub mod local_file;
+pub mod url;
+
+// not actual format id, just a placeholder
+const FILEDESCRIPTOR_FORMAT_ID: i32 = 49334;
+const FILEDESCRIPTORW_FORMAT_NAME: &str = "FileGroupDescriptorW";
+// not actual format id, just a placeholder
+const FILECONTENTS_FORMAT_ID: i32 = 49267;
+const FILECONTENTS_FORMAT_NAME: &str = "FileContents";
+
+lazy_static! {
+    static ref REMOTE_FORMAT_MAP: DashMap<i32, String> = DashMap::from_iter(
+        [
+            (
+                FILEDESCRIPTOR_FORMAT_ID,
+                FILEDESCRIPTORW_FORMAT_NAME.to_string()
+            ),
+            (FILECONTENTS_FORMAT_ID, FILECONTENTS_FORMAT_NAME.to_string())
+        ]
+        .iter()
+        .cloned()
+    );
+}
+
+fn get_local_format(remote_id: i32) -> Option<String> {
+    REMOTE_FORMAT_MAP.get(&remote_id).map(|s| s.clone())
+}
+
+fn add_remote_format(local_name: &str, remote_id: i32) {
+    REMOTE_FORMAT_MAP.insert(remote_id, local_name.to_string());
+}
+
+trait SysClipboard: Send + Sync {
+    fn start(&self);
+    fn stop(&self);
+
+    fn set_file_list(&self, paths: &[PathBuf]) -> Result<(), CliprdrError>;
+    fn get_file_list(&self) -> Vec<PathBuf>;
+}
+
+fn get_sys_clipboard(ignore_path: &PathBuf) -> Result<Box<dyn SysClipboard>, CliprdrError> {
+    #[cfg(feature = "wayland")]
+    {
+        unimplemented!()
+    }
+    #[cfg(not(feature = "wayland"))]
+    {
+        pub use x11::*;
+        let x11_clip = X11Clipboard::new(ignore_path)?;
+        Ok(Box::new(x11_clip) as Box<_>)
+    }
+}
+
+#[derive(Debug)]
+enum FileContentsRequest {
+    Size {
+        stream_id: i32,
+        file_idx: usize,
+    },
+
+    Range {
+        stream_id: i32,
+        file_idx: usize,
+        offset: u64,
+        length: u64,
+    },
+}
+
+pub struct ClipboardContext {
+    pub fuse_mount_point: PathBuf,
+    /// stores fuse background session handle
+    fuse_handle: Mutex<Option<fuser::BackgroundSession>>,
+
+    /// a sender of clipboard file contents pdu to fuse server
+    fuse_tx: Sender<ClipboardFile>,
+    fuse_server: Arc<Mutex<FuseServer>>,
+
+    clipboard: Arc<dyn SysClipboard>,
+    local_files: Mutex<Vec<LocalFile>>,
+}
+
+impl ClipboardContext {
+    pub fn new(timeout: Duration, mount_path: PathBuf) -> Result<Self, CliprdrError> {
+        // assert mount path exists
+        let fuse_mount_point = mount_path.canonicalize().map_err(|e| {
+            log::error!("failed to canonicalize mount path: {:?}", e);
+            CliprdrError::CliprdrInit
+        })?;
+
+        let (fuse_server, fuse_tx) = FuseServer::new(timeout);
+
+        let fuse_server = Arc::new(Mutex::new(fuse_server));
+
+        let clipboard = get_sys_clipboard(&fuse_mount_point)?;
+        let clipboard = Arc::from(clipboard) as Arc<_>;
+        let local_files = Mutex::new(vec![]);
+
+        Ok(Self {
+            fuse_mount_point,
+            fuse_server,
+            fuse_tx,
+            fuse_handle: Mutex::new(None),
+            clipboard,
+            local_files,
+        })
+    }
+
+    pub fn run(&self) -> Result<(), CliprdrError> {
+        if !self.is_stopped() {
+            return Ok(());
+        }
+
+        let mut fuse_handle = self.fuse_handle.lock();
+
+        let mount_path = &self.fuse_mount_point;
+
+        let mnt_opts = [
+            MountOption::FSName("rustdesk-cliprdr-fs".to_string()),
+            MountOption::NoAtime,
+            MountOption::RO,
+        ];
+        log::info!(
+            "mounting clipboard FUSE to {}",
+            self.fuse_mount_point.display()
+        );
+
+        let new_handle = fuser::spawn_mount2(
+            FuseServer::client(self.fuse_server.clone()),
+            mount_path,
+            &mnt_opts,
+        )
+        .map_err(|e| {
+            log::error!("failed to mount cliprdr fuse: {:?}", e);
+            CliprdrError::CliprdrInit
+        })?;
+        *fuse_handle = Some(new_handle);
+
+        let clipboard = self.clipboard.clone();
+
+        std::thread::spawn(move || {
+            log::debug!("start listening clipboard");
+            clipboard.start();
+        });
+
+        Ok(())
+    }
+
+    /// set clipboard data from file list
+    pub fn set_clipboard(&self, paths: &[PathBuf]) -> Result<(), CliprdrError> {
+        let prefix = self.fuse_mount_point.clone();
+        let paths: Vec<PathBuf> = paths.iter().cloned().map(|p| prefix.join(p)).collect();
+        log::debug!("setting clipboard with paths: {:?}", paths);
+        self.clipboard.set_file_list(&paths)?;
+        log::debug!("clipboard set, paths: {:?}", paths);
+        Ok(())
+    }
+
+    fn serve_file_contents(
+        &self,
+        conn_id: i32,
+        request: FileContentsRequest,
+    ) -> Result<(), CliprdrError> {
+        let mut file_list = self.local_files.lock();
+
+        let (file_idx, file_contents_resp) = match request {
+            FileContentsRequest::Size {
+                stream_id,
+                file_idx,
+            } => {
+                log::debug!("file contents (size) requested from conn: {}", conn_id);
+                let Some(file) = file_list.get(file_idx) else {
+                    log::error!(
+                        "invalid file index {} requested from conn: {}",
+                        file_idx,
+                        conn_id
+                    );
+                    resp_file_contents_fail(conn_id, stream_id);
+
+                    return Err(CliprdrError::InvalidRequest {
+                        description: format!(
+                            "invalid file index {} requested from conn: {}",
+                            file_idx, conn_id
+                        ),
+                    });
+                };
+
+                log::debug!(
+                    "conn {} requested file-{}: {}",
+                    conn_id,
+                    file_idx,
+                    file.name
+                );
+
+                let size = file.size;
+                (
+                    file_idx,
+                    ClipboardFile::FileContentsResponse {
+                        msg_flags: 0x1,
+                        stream_id,
+                        requested_data: size.to_le_bytes().to_vec(),
+                    },
+                )
+            }
+            FileContentsRequest::Range {
+                stream_id,
+                file_idx,
+                offset,
+                length,
+            } => {
+                log::debug!(
+                    "file contents (range from {} length {}) request from conn: {}",
+                    offset,
+                    length,
+                    conn_id
+                );
+                let Some(file) = file_list.get_mut(file_idx) else {
+                    log::error!(
+                        "invalid file index {} requested from conn: {}",
+                        file_idx,
+                        conn_id
+                    );
+                    resp_file_contents_fail(conn_id, stream_id);
+                    return Err(CliprdrError::InvalidRequest {
+                        description: format!(
+                            "invalid file index {} requested from conn: {}",
+                            file_idx, conn_id
+                        ),
+                    });
+                };
+                log::debug!(
+                    "conn {} requested file-{}: {}",
+                    conn_id,
+                    file_idx,
+                    file.name
+                );
+
+                if offset > file.size {
+                    log::error!("invalid reading offset requested from conn: {}", conn_id);
+                    resp_file_contents_fail(conn_id, stream_id);
+
+                    return Err(CliprdrError::InvalidRequest {
+                        description: format!(
+                            "invalid reading offset requested from conn: {}",
+                            conn_id
+                        ),
+                    });
+                }
+                let read_size = if offset + length > file.size {
+                    file.size - offset
+                } else {
+                    length
+                };
+
+                let mut buf = vec![0u8; read_size as usize];
+
+                file.read_exact_at(&mut buf, offset)?;
+
+                (
+                    file_idx,
+                    ClipboardFile::FileContentsResponse {
+                        msg_flags: 0x1,
+                        stream_id,
+                        requested_data: buf,
+                    },
+                )
+            }
+        };
+
+        send_data(conn_id, file_contents_resp);
+        log::debug!("file contents sent to conn: {}", conn_id);
+        // hot reload next file
+        for next_file in file_list.iter_mut().skip(file_idx + 1) {
+            if !next_file.is_dir {
+                next_file.load_handle()?;
+                break;
+            }
+        }
+        Ok(())
+    }
+}
+
+fn resp_file_contents_fail(conn_id: i32, stream_id: i32) {
+    let resp = ClipboardFile::FileContentsResponse {
+        msg_flags: 0x2,
+        stream_id,
+        requested_data: vec![],
+    };
+    send_data(conn_id, resp)
+}
+
+impl ClipboardContext {
+    pub fn is_stopped(&self) -> bool {
+        self.fuse_handle.lock().is_none()
+    }
+
+    pub fn sync_local_files(&self) -> Result<(), CliprdrError> {
+        let mut local_files = self.local_files.lock();
+        let clipboard_files = self.clipboard.get_file_list();
+        let local_file_list: Vec<PathBuf> = local_files.iter().map(|f| f.path.clone()).collect();
+        if local_file_list == clipboard_files {
+            return Ok(());
+        }
+        let new_files = construct_file_list(&clipboard_files)?;
+        *local_files = new_files;
+        Ok(())
+    }
+
+    pub fn serve(&self, conn_id: i32, msg: ClipboardFile) -> Result<(), CliprdrError> {
+        log::debug!("serve clipboard file from conn: {}", conn_id);
+        if self.is_stopped() {
+            log::debug!("cliprdr stopped, restart it");
+            self.run()?;
+        }
+        match msg {
+            ClipboardFile::NotifyCallback { .. } => {
+                unreachable!()
+            }
+            ClipboardFile::MonitorReady => {
+                log::debug!("server_monitor_ready called");
+
+                self.send_file_list(conn_id)?;
+
+                Ok(())
+            }
+
+            ClipboardFile::FormatList { format_list } => {
+                log::debug!("server_format_list called");
+                // filter out "FileGroupDescriptorW" and "FileContents"
+                let fmt_lst: Vec<(i32, String)> = format_list
+                    .into_iter()
+                    .filter(|(_, name)| {
+                        name == FILEDESCRIPTORW_FORMAT_NAME || name == FILECONTENTS_FORMAT_NAME
+                    })
+                    .collect();
+                if fmt_lst.len() != 2 {
+                    log::debug!("no supported formats");
+                    return Ok(());
+                }
+                log::debug!("supported formats: {:?}", fmt_lst);
+                let file_contents_id = fmt_lst
+                    .iter()
+                    .find(|(_, name)| name == FILECONTENTS_FORMAT_NAME)
+                    .map(|(id, _)| *id)
+                    .unwrap();
+                let file_descriptor_id = fmt_lst
+                    .iter()
+                    .find(|(_, name)| name == FILEDESCRIPTORW_FORMAT_NAME)
+                    .map(|(id, _)| *id)
+                    .unwrap();
+
+                add_remote_format(FILECONTENTS_FORMAT_NAME, file_contents_id);
+                add_remote_format(FILEDESCRIPTORW_FORMAT_NAME, file_descriptor_id);
+
+                // sync file system from peer
+                let data = ClipboardFile::FormatDataRequest {
+                    requested_format_id: file_descriptor_id,
+                };
+                send_data(conn_id, data);
+
+                Ok(())
+            }
+            ClipboardFile::FormatListResponse { msg_flags } => {
+                log::debug!("server_format_list_response called");
+                if msg_flags != 0x1 {
+                    send_format_list(conn_id)
+                } else {
+                    Ok(())
+                }
+            }
+            ClipboardFile::FormatDataRequest {
+                requested_format_id,
+            } => {
+                log::debug!("server_format_data_request called");
+                let Some(format) = get_local_format(requested_format_id) else {
+                    log::error!(
+                        "got unsupported format data request: id={} from conn={}",
+                        requested_format_id,
+                        conn_id
+                    );
+                    resp_format_data_failure(conn_id);
+                    return Ok(());
+                };
+
+                if format == FILEDESCRIPTORW_FORMAT_NAME {
+                    self.send_file_list(conn_id)?;
+                } else if format == FILECONTENTS_FORMAT_NAME {
+                    log::error!(
+                        "try to read file contents with FormatDataRequest from conn={}",
+                        conn_id
+                    );
+                    resp_format_data_failure(conn_id);
+                } else {
+                    log::error!(
+                        "got unsupported format data request: id={} from conn={}",
+                        requested_format_id,
+                        conn_id
+                    );
+                    resp_format_data_failure(conn_id);
+                }
+                Ok(())
+            }
+            ClipboardFile::FormatDataResponse {
+                msg_flags,
+                format_data,
+            } => {
+                log::debug!(
+                    "server_format_data_response called, msg_flags={}",
+                    msg_flags
+                );
+
+                if msg_flags != 0x1 {
+                    resp_format_data_failure(conn_id);
+                    return Ok(());
+                }
+
+                log::debug!("parsing file descriptors");
+                // this must be a file descriptor format data
+                let files = FileDescription::parse_file_descriptors(format_data, conn_id)?;
+
+                let paths = {
+                    let mut fuse_guard = self.fuse_server.lock();
+                    fuse_guard.load_file_list(files)?;
+
+                    fuse_guard.list_root()
+                };
+
+                log::debug!("load file list: {:?}", paths);
+                self.set_clipboard(&paths)?;
+                Ok(())
+            }
+            ClipboardFile::FileContentsResponse { .. } => {
+                log::debug!("server_file_contents_response called");
+                // we don't know its corresponding request, no resend can be performed
+                self.fuse_tx.send(msg).map_err(|e| {
+                    log::error!("failed to send file contents response to fuse: {:?}", e);
+                    CliprdrError::ClipboardInternalError
+                })?;
+                Ok(())
+            }
+            ClipboardFile::FileContentsRequest {
+                stream_id,
+                list_index,
+                dw_flags,
+                n_position_low,
+                n_position_high,
+                cb_requested,
+                ..
+            } => {
+                log::debug!("server_file_contents_request called");
+                let fcr = if dw_flags == 0x1 {
+                    FileContentsRequest::Size {
+                        stream_id,
+                        file_idx: list_index as usize,
+                    }
+                } else if dw_flags == 0x2 {
+                    let offset = (n_position_high as u64) << 32 | n_position_low as u64;
+                    let length = cb_requested as u64;
+
+                    FileContentsRequest::Range {
+                        stream_id,
+                        file_idx: list_index as usize,
+                        offset,
+                        length,
+                    }
+                } else {
+                    log::error!("got invalid FileContentsRequest from conn={}", conn_id);
+                    resp_file_contents_fail(conn_id, stream_id);
+                    return Ok(());
+                };
+
+                self.serve_file_contents(conn_id, fcr)
+            }
+        }
+    }
+
+    fn send_file_list(&self, conn_id: i32) -> Result<(), CliprdrError> {
+        self.sync_local_files()?;
+
+        let file_list = self.local_files.lock();
+        send_file_list(&*file_list, conn_id)
+    }
+}
+
+impl CliprdrServiceContext for ClipboardContext {
+    fn set_is_stopped(&mut self) -> Result<(), CliprdrError> {
+        // unmount the fuse
+        if let Some(fuse_handle) = self.fuse_handle.lock().take() {
+            fuse_handle.join();
+        }
+        self.clipboard.stop();
+        Ok(())
+    }
+
+    fn empty_clipboard(&mut self, _conn_id: i32) -> Result<bool, CliprdrError> {
+        self.clipboard.set_file_list(&[])?;
+        Ok(true)
+    }
+
+    fn server_clip_file(&mut self, conn_id: i32, msg: ClipboardFile) -> Result<(), CliprdrError> {
+        self.serve(conn_id, msg)
+    }
+}
+
+fn resp_format_data_failure(conn_id: i32) {
+    let data = ClipboardFile::FormatDataResponse {
+        msg_flags: 0x2,
+        format_data: vec![],
+    };
+    send_data(conn_id, data)
+}
+
+fn send_format_list(conn_id: i32) -> Result<(), CliprdrError> {
+    log::debug!("send format list to remote, conn={}", conn_id);
+    let fd_format_name = get_local_format(FILEDESCRIPTOR_FORMAT_ID)
+        .unwrap_or(FILEDESCRIPTORW_FORMAT_NAME.to_string());
+    let fc_format_name =
+        get_local_format(FILECONTENTS_FORMAT_ID).unwrap_or(FILECONTENTS_FORMAT_NAME.to_string());
+    let format_list = ClipboardFile::FormatList {
+        format_list: vec![
+            (FILEDESCRIPTOR_FORMAT_ID, fd_format_name),
+            (FILECONTENTS_FORMAT_ID, fc_format_name),
+        ],
+    };
+
+    send_data(conn_id, format_list);
+    log::debug!("format list to remote dispatched, conn={}", conn_id);
+    Ok(())
+}
+
+fn build_file_list_pdu(files: &[LocalFile]) -> Vec<u8> {
+    let mut data = BytesMut::with_capacity(4 + 592 * files.len());
+    data.put_u32_le(files.len() as u32);
+    for file in files.iter() {
+        data.put(file.as_bin().as_slice());
+    }
+
+    data.to_vec()
+}
+
+fn send_file_list(files: &[LocalFile], conn_id: i32) -> Result<(), CliprdrError> {
+    log::debug!(
+        "send file list to remote, conn={}, list={:?}",
+        conn_id,
+        files.iter().map(|f| f.path.display()).collect::<Vec<_>>()
+    );
+
+    let format_data = build_file_list_pdu(files);
+
+    send_data(
+        conn_id,
+        ClipboardFile::FormatDataResponse {
+            msg_flags: 1,
+            format_data,
+        },
+    );
+    Ok(())
+}

libs/clipboard/src/platform/unix/url.rs

@@ -0,0 +1,75 @@
+use std::path::{Path, PathBuf};
+
+use crate::CliprdrError;
+
+// on x11, path will be encode as
+// "/home/rustdesk/pictures/🖼️.png" -> "file:///home/rustdesk/pictures/%F0%9F%96%BC%EF%B8%8F.png"
+// url encode and decode is needed
+const ENCODE_SET: percent_encoding::AsciiSet = percent_encoding::CONTROLS.add(b' ').remove(b'/');
+
+pub(super) fn encode_path_to_uri(path: &PathBuf) -> String {
+    let encoded = percent_encoding::percent_encode(path.to_str().unwrap().as_bytes(), &ENCODE_SET)
+        .to_string();
+    format!("file://{}", encoded)
+}
+
+pub(super) fn parse_uri_to_path(encoded_uri: &str) -> Result<PathBuf, CliprdrError> {
+    let encoded_path = encoded_uri.trim_start_matches("file://");
+    let path_str = percent_encoding::percent_decode_str(encoded_path)
+        .decode_utf8()
+        .map_err(|_| CliprdrError::ConversionFailure)?;
+    let path_str = path_str.to_string();
+
+    Ok(Path::new(&path_str).to_path_buf())
+}
+
+// helper parse function
+// convert 'text/uri-list' data to a list of valid Paths
+// # Note
+// - none utf8 data will lead to error
+pub(super) fn parse_plain_uri_list(v: Vec<u8>) -> Result<Vec<PathBuf>, CliprdrError> {
+    let text = String::from_utf8(v).map_err(|_| CliprdrError::ConversionFailure)?;
+    parse_uri_list(&text)
+}
+
+// helper parse function
+// convert 'text/uri-list' data to a list of valid Paths
+// # Note
+// - none utf8 data will lead to error
+pub(super) fn parse_uri_list(text: &str) -> Result<Vec<PathBuf>, CliprdrError> {
+    let mut list = Vec::new();
+
+    for line in text.lines() {
+        if !line.starts_with("file://") {
+            continue;
+        }
+        let decoded = parse_uri_to_path(line)?;
+        list.push(decoded)
+    }
+    Ok(list)
+}
+
+#[cfg(test)]
+mod uri_test {
+    #[test]
+    fn test_conversion() {
+        let path = std::path::PathBuf::from("/home/rustdesk/pictures/🖼️.png");
+        let uri = super::encode_path_to_uri(&path);
+        assert_eq!(
+            uri,
+            "file:///home/rustdesk/pictures/%F0%9F%96%BC%EF%B8%8F.png"
+        );
+        let convert_back = super::parse_uri_to_path(&uri).unwrap();
+        assert_eq!(path, convert_back);
+    }
+
+    #[test]
+    fn parse_list() {
+        let uri_list = r#"file:///home/rustdesk/pictures/%F0%9F%96%BC%EF%B8%8F.png
+file:///home/rustdesk/pictures/%F0%9F%96%BC%EF%B8%8F.png
+"#;
+        let list = super::parse_uri_list(uri_list.into()).unwrap();
+        assert!(list.len() == 2);
+        assert_eq!(list[0], list[1]);
+    }
+}

libs/clipboard/src/platform/unix/x11.rs

@@ -0,0 +1,181 @@
+use std::{
+    collections::BTreeSet,
+    path::PathBuf,
+    sync::atomic::{AtomicBool, Ordering},
+};
+
+use hbb_common::log;
+use once_cell::sync::OnceCell;
+use parking_lot::Mutex;
+use x11_clipboard::Clipboard;
+use x11rb::protocol::xproto::Atom;
+
+use crate::{platform::unix::send_format_list, CliprdrError};
+
+use super::{encode_path_to_uri, parse_plain_uri_list, SysClipboard};
+
+static X11_CLIPBOARD: OnceCell<Clipboard> = OnceCell::new();
+
+// this is tested on an Arch Linux with X11
+const X11_CLIPBOARD_TIMEOUT: std::time::Duration = std::time::Duration::from_millis(70);
+
+fn get_clip() -> Result<&'static Clipboard, CliprdrError> {
+    X11_CLIPBOARD.get_or_try_init(|| Clipboard::new().map_err(|_| CliprdrError::CliprdrInit))
+}
+
+pub struct X11Clipboard {
+    stop: AtomicBool,
+    ignore_path: PathBuf,
+    text_uri_list: Atom,
+    gnome_copied_files: Atom,
+    nautilus_clipboard: Atom,
+
+    former_file_list: Mutex<Vec<PathBuf>>,
+}
+
+impl X11Clipboard {
+    pub fn new(ignore_path: &PathBuf) -> Result<Self, CliprdrError> {
+        let clipboard = get_clip()?;
+        let text_uri_list = clipboard
+            .setter
+            .get_atom("text/uri-list")
+            .map_err(|_| CliprdrError::CliprdrInit)?;
+        let gnome_copied_files = clipboard
+            .setter
+            .get_atom("x-special/gnome-copied-files")
+            .map_err(|_| CliprdrError::CliprdrInit)?;
+        let nautilus_clipboard = clipboard
+            .setter
+            .get_atom("x-special/nautilus-clipboard")
+            .map_err(|_| CliprdrError::CliprdrInit)?;
+        Ok(Self {
+            ignore_path: ignore_path.to_owned(),
+            stop: AtomicBool::new(false),
+            text_uri_list,
+            gnome_copied_files,
+            nautilus_clipboard,
+            former_file_list: Mutex::new(vec![]),
+        })
+    }
+
+    fn load(&self, target: Atom) -> Result<Vec<u8>, CliprdrError> {
+        let clip = get_clip()?.setter.atoms.clipboard;
+        let prop = get_clip()?.setter.atoms.property;
+        // NOTE:
+        // # why not use `load_wait`
+        // load_wait is likely to wait forever, which is not what we want
+        let res = get_clip()?.load(clip, target, prop, X11_CLIPBOARD_TIMEOUT);
+        match res {
+            Ok(res) => Ok(res),
+            Err(x11_clipboard::error::Error::UnexpectedType(_)) => Ok(vec![]),
+            Err(_) => Err(CliprdrError::ClipboardInternalError),
+        }
+    }
+
+    fn store_batch(&self, batch: Vec<(Atom, Vec<u8>)>) -> Result<(), CliprdrError> {
+        let clip = get_clip()?.setter.atoms.clipboard;
+        log::debug!("try to store clipboard content");
+        get_clip()?
+            .store_batch(clip, batch)
+            .map_err(|_| CliprdrError::ClipboardInternalError)
+    }
+
+    fn wait_file_list(&self) -> Result<Option<Vec<PathBuf>>, CliprdrError> {
+        if self.stop.load(Ordering::Relaxed) {
+            return Ok(None);
+        }
+        let v = self.load(self.text_uri_list)?;
+        let p = parse_plain_uri_list(v)?;
+        Ok(Some(p))
+    }
+}
+
+impl X11Clipboard {
+    #[inline]
+    fn is_stopped(&self) -> bool {
+        self.stop.load(Ordering::Relaxed)
+    }
+}
+
+impl SysClipboard for X11Clipboard {
+    fn set_file_list(&self, paths: &[PathBuf]) -> Result<(), CliprdrError> {
+        *self.former_file_list.lock() = paths.to_vec();
+
+        let uri_list: Vec<String> = paths.iter().map(encode_path_to_uri).collect();
+        let uri_list = uri_list.join("\n");
+        let text_uri_list_data = uri_list.as_bytes().to_vec();
+        let gnome_copied_files_data = ["copy\n".as_bytes(), uri_list.as_bytes()].concat();
+        let batch = vec![
+            (self.text_uri_list, text_uri_list_data),
+            (self.gnome_copied_files, gnome_copied_files_data.clone()),
+            (self.nautilus_clipboard, gnome_copied_files_data),
+        ];
+        self.store_batch(batch)
+            .map_err(|_| CliprdrError::ClipboardInternalError)
+    }
+
+    fn stop(&self) {
+        self.stop.store(true, Ordering::Relaxed);
+    }
+
+    fn start(&self) {
+        self.stop.store(false, Ordering::Relaxed);
+
+        loop {
+            let sth = match self.wait_file_list() {
+                Ok(sth) => sth,
+                Err(e) => {
+                    log::warn!("failed to get file list from clipboard: {}", e);
+                    std::thread::sleep(std::time::Duration::from_millis(100));
+                    continue;
+                }
+            };
+
+            if self.is_stopped() {
+                std::thread::sleep(std::time::Duration::from_millis(100));
+                continue;
+            }
+
+            let Some(paths) = sth else {
+                // just sleep
+                std::thread::sleep(std::time::Duration::from_millis(100));
+                continue;
+            };
+
+            let filtered = paths
+                .into_iter()
+                .filter(|pb| !pb.starts_with(&self.ignore_path))
+                .collect::<Vec<_>>();
+
+            if filtered.is_empty() {
+                std::thread::sleep(std::time::Duration::from_millis(100));
+                continue;
+            }
+
+            {
+                let mut former = self.former_file_list.lock();
+
+                let filtered_st: BTreeSet<_> = filtered.iter().collect();
+                let former_st = former.iter().collect::<BTreeSet<_>>();
+                if filtered_st == former_st {
+                    std::thread::sleep(std::time::Duration::from_millis(100));
+                    continue;
+                }
+
+                *former = filtered;
+            }
+
+            if let Err(e) = send_format_list(0) {
+                log::warn!("failed to send format list: {}", e);
+                break;
+            }
+
+            std::thread::sleep(std::time::Duration::from_millis(100));
+        }
+        log::debug!("stop listening file related atoms on clipboard");
+    }
+
+    fn get_file_list(&self) -> Vec<PathBuf> {
+        self.former_file_list.lock().clone()
+    }
+}