From ccd2cbd760aa22802df38074144190a0194c3644 Mon Sep 17 00:00:00 2001 From: fufesou Date: Sun, 18 Jun 2023 20:23:54 +0800 Subject: [PATCH] try fix clipboard, flutter version Signed-off-by: fufesou --- libs/clipboard/src/cliprdr.h | 3 - libs/clipboard/src/cliprdr.rs | 6 -- libs/clipboard/src/context_send.rs | 54 ++++++++++------- libs/clipboard/src/lib.rs | 64 ++++++-------------- libs/clipboard/src/windows/wf_cliprdr.c | 22 +------ libs/hbb_common/src/config.rs | 13 +++++ src/client.rs | 1 + src/client/io_loop.rs | 20 +++++-- src/core_main.rs | 2 + src/ipc.rs | 3 +- src/server/connection.rs | 21 +++---- src/ui_cm_interface.rs | 77 +++++++++---------------- src/ui_interface.rs | 15 +++++ src/ui_session_interface.rs | 1 + 14 files changed, 136 insertions(+), 166 deletions(-) diff --git a/libs/clipboard/src/cliprdr.h b/libs/clipboard/src/cliprdr.h index 717309579..2fa16e201 100644 --- a/libs/clipboard/src/cliprdr.h +++ b/libs/clipboard/src/cliprdr.h @@ -191,8 +191,6 @@ extern "C" typedef UINT (*pcCliprdrServerFileContentsResponse)( CliprdrClientContext *context, const CLIPRDR_FILE_CONTENTS_RESPONSE *fileContentsResponse); - typedef BOOL (*pcCheckEnabled)(UINT32 connID); - // TODO: hide more members of clipboard context struct _cliprdr_client_context { @@ -200,7 +198,6 @@ extern "C" BOOL enableFiles; BOOL enableOthers; - pcCheckEnabled CheckEnabled; pcCliprdrServerCapabilities ServerCapabilities; pcCliprdrClientCapabilities ClientCapabilities; pcCliprdrMonitorReady MonitorReady; diff --git a/libs/clipboard/src/cliprdr.rs b/libs/clipboard/src/cliprdr.rs index 08d4021e8..2bc626536 100644 --- a/libs/clipboard/src/cliprdr.rs +++ b/libs/clipboard/src/cliprdr.rs @@ -444,9 +444,6 @@ pub type pcCliprdrServerFileContentsResponse = ::std::option::Option< fileContentsResponse: *const CLIPRDR_FILE_CONTENTS_RESPONSE, ) -> UINT, >; -pub type pcCheckEnabled = ::std::option::Option< - unsafe extern "C" fn(connID: UINT32) -> BOOL, ->; // TODO: hide more members of clipboard context #[repr(C)] @@ -455,7 +452,6 @@ pub struct _cliprdr_client_context { pub custom: *mut ::std::os::raw::c_void, pub enableFiles: BOOL, pub enableOthers: BOOL, - pub CheckEnabled: pcCheckEnabled, pub ServerCapabilities: pcCliprdrServerCapabilities, pub ClientCapabilities: pcCliprdrClientCapabilities, pub MonitorReady: pcCliprdrMonitorReady, @@ -504,7 +500,6 @@ impl CliprdrClientContext { pub fn create( enable_files: bool, enable_others: bool, - check_enabled: pcCheckEnabled, client_format_list: pcCliprdrClientFormatList, client_format_list_response: pcCliprdrClientFormatListResponse, client_format_data_request: pcCliprdrClientFormatDataRequest, @@ -516,7 +511,6 @@ impl CliprdrClientContext { custom: 0 as *mut _, enableFiles: if enable_files { TRUE } else { FALSE }, enableOthers: if enable_others { TRUE } else { FALSE }, - CheckEnabled: check_enabled, ServerCapabilities: None, ClientCapabilities: None, MonitorReady: None, diff --git a/libs/clipboard/src/context_send.rs b/libs/clipboard/src/context_send.rs index b19270a37..896def40e 100644 --- a/libs/clipboard/src/context_send.rs +++ b/libs/clipboard/src/context_send.rs @@ -1,28 +1,36 @@ use crate::cliprdr::*; use hbb_common::log; -use std::sync::Mutex; +use std::sync::{Arc, Mutex}; lazy_static::lazy_static! { - static ref CONTEXT_SEND: ContextSend = ContextSend{addr: Mutex::new(0)}; + static ref CONTEXT_SEND: Arc> = Arc::new(Mutex::new(ContextSend::new())); } pub struct ContextSend { - addr: Mutex, + server_enabled: bool, + addr: u64, } impl ContextSend { - pub fn is_enabled() -> bool { - *CONTEXT_SEND.addr.lock().unwrap() != 0 + fn new() -> Self { + Self { + server_enabled: false, + addr: 0, + } } - pub fn enable(enabled: bool) { - let mut lock = CONTEXT_SEND.addr.lock().unwrap(); + pub fn is_server_enabled() -> bool { + CONTEXT_SEND.lock().unwrap().server_enabled + } + + pub fn enable(enabled: bool, is_server_side: bool, is_server_process: bool) { + let mut lock = CONTEXT_SEND.lock().unwrap(); if enabled { - if *lock == 0 { - match crate::create_cliprdr_context(true, false, crate::ProcessSide::ClientSide) { + if lock.addr == 0 { + match crate::create_cliprdr_context(true, false) { Ok(context) => { log::info!("clipboard context for file transfer created."); - *lock = Box::into_raw(context) as _; + lock.addr = Box::into_raw(context) as _; } Err(err) => { log::error!( @@ -32,25 +40,29 @@ impl ContextSend { } } } + if is_server_side { + lock.server_enabled = true; + } } else { - if *lock != 0 { - unsafe { - let _ = Box::from_raw(*lock as *mut CliprdrClientContext); + if lock.addr != 0 { + if is_server_process { + unsafe { + let _ = Box::from_raw(lock.addr as *mut CliprdrClientContext); + } + log::info!("clipboard context for file transfer destroyed."); + lock.addr = 0; } - log::info!("clipboard context for file transfer destroyed."); - *lock = 0; + lock.server_enabled = false; } } } pub fn proc) -> u32>(f: F) -> u32 { - let mut lock = CONTEXT_SEND.addr.lock().unwrap(); - if *lock != 0 { + let lock = CONTEXT_SEND.lock().unwrap(); + if lock.addr != 0 { unsafe { - let mut context = Box::from_raw(*lock as *mut CliprdrClientContext); - let res = f(&mut context); - *lock = Box::into_raw(context) as _; - res + let mut context = Box::from_raw(lock.addr as *mut CliprdrClientContext); + f(&mut context) } } else { 0 diff --git a/libs/clipboard/src/lib.rs b/libs/clipboard/src/lib.rs index fb2255796..dc1d4ca74 100644 --- a/libs/clipboard/src/lib.rs +++ b/libs/clipboard/src/lib.rs @@ -10,7 +10,6 @@ use hbb_common::{ use serde_derive::{Deserialize, Serialize}; use std::{ boxed::Box, - collections::HashMap, ffi::{CStr, CString}, sync::{Arc, Mutex, RwLock}, }; @@ -53,11 +52,6 @@ pub enum ClipboardFile { }, } -#[derive(Default)] -struct ConnEnabled { - conn_enabled: HashMap, -} - struct MsgChannel { session_uuid: SessionID, conn_id: i32, @@ -65,17 +59,20 @@ struct MsgChannel { receiver: Arc>>, } -#[derive(PartialEq)] -pub enum ProcessSide { - UnknownSide, - ClientSide, - ServerSide, -} - lazy_static::lazy_static! { static ref VEC_MSG_CHANNEL: RwLock> = Default::default(); - static ref CLIP_CONN_ENABLED: Mutex = Mutex::new(ConnEnabled::default()); - static ref PROCESS_SIDE: RwLock = RwLock::new(ProcessSide::UnknownSide); + static ref CLIENT_CONN_ID_COUNTER: Mutex = Mutex::new(0); +} + +impl ClipboardFile { + pub fn is_stopping_allowed(&self) -> bool { + match self { + ClipboardFile::MonitorReady + | ClipboardFile::FormatList { .. } + | ClipboardFile::FormatDataRequest { .. } => true, + _ => false, + } + } } pub fn get_client_conn_id(session_uuid: &SessionID) -> Option { @@ -87,6 +84,12 @@ pub fn get_client_conn_id(session_uuid: &SessionID) -> Option { .map(|x| x.conn_id) } +fn get_conn_id() -> i32 { + let mut lock = CLIENT_CONN_ID_COUNTER.lock().unwrap(); + *lock += 1; + *lock +} + pub fn get_rx_cliprdr_client( session_uuid: &SessionID, ) -> (i32, Arc>>) { @@ -100,7 +103,7 @@ pub fn get_rx_cliprdr_client( let (sender, receiver) = unbounded_channel(); let receiver = Arc::new(TokioMutex::new(receiver)); let receiver2 = receiver.clone(); - let conn_id = lock.len() as i32 + 1; + let conn_id = get_conn_id(); let msg_channel = MsgChannel { session_uuid: session_uuid.to_owned(), conn_id, @@ -146,13 +149,6 @@ fn send_data(conn_id: i32, data: ClipboardFile) { } } -pub fn set_conn_enabled(conn_id: i32, enabled: bool) { - let mut lock = CLIP_CONN_ENABLED.lock().unwrap(); - if conn_id != 0 { - let _ = lock.conn_enabled.insert(conn_id, enabled); - } -} - pub fn empty_clipboard(context: &mut Box, conn_id: i32) -> bool { unsafe { TRUE == cliprdr::empty_cliprdr(&mut (**context), conn_id as u32) } } @@ -430,14 +426,10 @@ pub fn server_file_contents_response( pub fn create_cliprdr_context( enable_files: bool, enable_others: bool, - process_side: ProcessSide, ) -> ResultType> { - *PROCESS_SIDE.write().unwrap() = process_side; - Ok(CliprdrClientContext::create( enable_files, enable_others, - Some(check_enabled), Some(client_format_list), Some(client_format_list_response), Some(client_format_data_request), @@ -447,24 +439,6 @@ pub fn create_cliprdr_context( )?) } -extern "C" fn check_enabled(conn_id: UINT32) -> BOOL { - if *PROCESS_SIDE.read().unwrap() == ProcessSide::ClientSide { - return TRUE; - } - - let lock = CLIP_CONN_ENABLED.lock().unwrap(); - let mut connd_enabled = false; - if conn_id != 0 { - if let Some(true) = lock.conn_enabled.get(&(conn_id as i32)) { - connd_enabled = true; - } - } else { - connd_enabled = true; - } - - return if connd_enabled { TRUE } else { FALSE }; -} - extern "C" fn client_format_list( _context: *mut CliprdrClientContext, clip_format_list: *const CLIPRDR_FORMAT_LIST, diff --git a/libs/clipboard/src/windows/wf_cliprdr.c b/libs/clipboard/src/windows/wf_cliprdr.c index a66150c40..c17390cb4 100644 --- a/libs/clipboard/src/windows/wf_cliprdr.c +++ b/libs/clipboard/src/windows/wf_cliprdr.c @@ -681,10 +681,6 @@ static HRESULT STDMETHODCALLTYPE CliprdrDataObject_GetData(IDataObject *This, FO } clipboard = (wfClipboard *)instance->m_pData; - if (!clipboard->context->CheckEnabled(instance->m_connID)) - { - return E_INVALIDARG; - } if (!clipboard) return E_INVALIDARG; @@ -1470,14 +1466,7 @@ static UINT cliprdr_send_data_request(UINT32 connID, wfClipboard *clipboard, UIN DWORD waitRes = WaitForSingleObject(clipboard->response_data_event, 50); if (waitRes == WAIT_TIMEOUT) { - if (clipboard->context->CheckEnabled(connID)) - { - continue; - } - else - { - break; - } + continue; } if (waitRes != WAIT_OBJECT_0) @@ -1542,14 +1531,7 @@ UINT cliprdr_send_request_filecontents(wfClipboard *clipboard, UINT32 connID, co DWORD waitRes = WaitForSingleObject(clipboard->req_fevent, 50); if (waitRes == WAIT_TIMEOUT) { - if (clipboard->context->CheckEnabled(connID)) - { - continue; - } - else - { - break; - } + continue; } if (waitRes != WAIT_OBJECT_0) diff --git a/libs/hbb_common/src/config.rs b/libs/hbb_common/src/config.rs index 53f49ab1d..866671d31 100644 --- a/libs/hbb_common/src/config.rs +++ b/libs/hbb_common/src/config.rs @@ -2,6 +2,7 @@ use std::{ collections::HashMap, fs, net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr}, + ops::{Deref, DerefMut}, path::{Path, PathBuf}, sync::{Arc, Mutex, RwLock}, time::{Duration, Instant, SystemTime}, @@ -132,6 +133,18 @@ macro_rules! serde_field_bool { UserDefaultConfig::read().get($field_name) == "Y" } } + impl Deref for $struct_name { + type Target = bool; + + fn deref(&self) -> &Self::Target { + &self.v + } + } + impl DerefMut for $struct_name { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.v + } + } }; } diff --git a/src/client.rs b/src/client.rs index 8fda02d9d..df719a063 100644 --- a/src/client.rs +++ b/src/client.rs @@ -2336,6 +2336,7 @@ pub enum Data { CancelJob(i32), RemovePortForward(i32), AddPortForward((i32, String, i32)), + #[cfg(not(feature = "flutter"))] ToggleClipboardFile, NewRDP, SetConfirmOverrideFile((i32, i32, bool, bool, bool)), diff --git a/src/client/io_loop.rs b/src/client/io_loop.rs index 084968883..53e910f1a 100644 --- a/src/client/io_loop.rs +++ b/src/client/io_loop.rs @@ -6,7 +6,7 @@ use std::sync::{ }; #[cfg(windows)] -use clipboard::{cliprdr::CliprdrClientContext, ContextSend}; +use clipboard::{cliprdr::CliprdrClientContext, ClipboardFile, ContextSend}; use crossbeam_queue::ArrayQueue; use hbb_common::config::{PeerConfig, TransferSerde}; use hbb_common::fs::{ @@ -58,7 +58,7 @@ pub struct Remote { last_update_jobs_status: (Instant, HashMap), first_frame: bool, #[cfg(windows)] - client_conn_id: i32, // used for clipboard + client_conn_id: i32, // used for file clipboard data_count: Arc, frame_count: Arc, video_format: CodecFormat, @@ -207,7 +207,15 @@ impl Remote { #[cfg(windows)] match _msg { Some(clip) => { - allow_err!(peer.send(&crate::clipboard_file::clip_2_msg(clip)).await); + let mut send_msg = true; + if clip.is_stopping_allowed() { + if !(*self.handler.server_file_transfer_enabled.read().unwrap() && self.handler.lc.read().unwrap().enable_file_transfer.v) { + send_msg = false; + } + } + if send_msg { + allow_err!(peer.send(&crate::clipboard_file::clip_2_msg(clip)).await); + } } None => { // unreachable!() @@ -389,6 +397,7 @@ impl Remote { .handle_login_from_ui(os_username, os_password, password, remember, peer) .await; } + #[cfg(not(feature = "flutter"))] Data::ToggleClipboardFile => { self.check_clipboard_file_context(); } @@ -938,6 +947,7 @@ impl Remote { } Some(login_response::Union::PeerInfo(pi)) => { self.handler.handle_peer_info(pi); + #[cfg(not(feature = "flutter"))] self.check_clipboard_file_context(); if !(self.handler.is_file_transfer() || self.handler.is_port_forward()) { #[cfg(feature = "flutter")] @@ -1188,7 +1198,6 @@ impl Remote { if !p.enabled && self.handler.is_file_transfer() { return true; } - self.check_clipboard_file_context(); self.handler.set_permission("file", p.enabled); } Ok(Permission::Restart) => { @@ -1525,12 +1534,13 @@ impl Remote { true } + #[cfg(not(feature = "flutter"))] fn check_clipboard_file_context(&self) { #[cfg(windows)] { let enabled = *self.handler.server_file_transfer_enabled.read().unwrap() && self.handler.lc.read().unwrap().enable_file_transfer.v; - ContextSend::enable(enabled); + ContextSend::enable(enabled, false, false); } } diff --git a/src/core_main.rs b/src/core_main.rs index aa9069bbf..59c72fa66 100644 --- a/src/core_main.rs +++ b/src/core_main.rs @@ -122,6 +122,8 @@ pub fn core_main() -> Option> { #[cfg(not(any(target_os = "android", target_os = "ios")))] init_plugins(&args); if args.is_empty() { + #[cfg(windows)] + clipboard::ContextSend::enable(true, false, false); std::thread::spawn(move || crate::start_server(false)); } else { #[cfg(windows)] diff --git a/src/ipc.rs b/src/ipc.rs index 5b89ba482..c275f88dd 100644 --- a/src/ipc.rs +++ b/src/ipc.rs @@ -202,7 +202,6 @@ pub enum Data { SyncConfig(Option>), #[cfg(not(any(target_os = "android", target_os = "ios")))] ClipboardFile(ClipboardFile), - ClipboardFileEnabled(bool), PrivacyModeState((i32, PrivacyModeState)), TestRendezvousServer, #[cfg(not(any(target_os = "android", target_os = "ios")))] @@ -242,7 +241,7 @@ pub async fn start(postfix: &str) -> ResultType<()> { loop { match stream.next().await { Err(err) => { - log::trace!("ipc{} connection closed: {}", postfix, err); + log::trace!("ipc '{}' connection closed: {}", postfix, err); break; } Ok(Some(data)) => { diff --git a/src/server/connection.rs b/src/server/connection.rs index 3a82a6594..960360d6a 100644 --- a/src/server/connection.rs +++ b/src/server/connection.rs @@ -282,6 +282,7 @@ impl Connection { keyboard: Connection::permission("enable-keyboard"), clipboard: Connection::permission("enable-clipboard"), audio: Connection::permission("enable-audio"), + // to-do: make sure is the option correct here file: Connection::permission("enable-file-transfer"), restart: Connection::permission("enable-remote-restart"), recording: Connection::permission("enable-record-session"), @@ -424,7 +425,6 @@ impl Connection { } else if &name == "file" { conn.file = enabled; conn.send_permission(Permission::File, enabled).await; - conn.send_to_cm(ipc::Data::ClipboardFileEnabled(conn.file_transfer_enabled())); } else if &name == "restart" { conn.restart = enabled; conn.send_permission(Permission::Restart, enabled).await; @@ -437,9 +437,9 @@ impl Connection { allow_err!(conn.stream.send_raw(bytes).await); } #[cfg(windows)] - ipc::Data::ClipboardFile(_clip) => { - if conn.file_transfer_enabled() { - allow_err!(conn.stream.send(&clip_2_msg(_clip)).await); + ipc::Data::ClipboardFile(clip) => { + if !clip.is_stopping_allowed() || conn.file_transfer_enabled() { + allow_err!(conn.stream.send(&clip_2_msg(clip)).await); } } ipc::Data::PrivacyModeState((_, state)) => { @@ -1136,7 +1136,7 @@ impl Connection { clipboard: self.clipboard, audio: self.audio, file: self.file, - file_transfer_enabled: self.file_transfer_enabled(), + file_transfer_enabled: self.file, restart: self.restart, recording: self.recording, from_switch: self.from_switch, @@ -1636,11 +1636,9 @@ impl Connection { } } Some(message::Union::Cliprdr(_clip)) => { - if self.file_transfer_enabled() { - #[cfg(windows)] - if let Some(clip) = msg_2_clip(_clip) { - self.send_to_cm(ipc::Data::ClipboardFile(clip)) - } + #[cfg(windows)] + if let Some(clip) = msg_2_clip(_clip) { + self.send_to_cm(ipc::Data::ClipboardFile(clip)) } } Some(message::Union::FileAction(fa)) => { @@ -2073,9 +2071,6 @@ impl Connection { if let Ok(q) = o.enable_file_transfer.enum_value() { if q != BoolOption::NotSet { self.enable_file_transfer = q == BoolOption::Yes; - self.send_to_cm(ipc::Data::ClipboardFileEnabled( - self.file_transfer_enabled(), - )); } } if let Ok(q) = o.disable_clipboard.enum_value() { diff --git a/src/ui_cm_interface.rs b/src/ui_cm_interface.rs index d34b7a299..b4b5636b1 100644 --- a/src/ui_cm_interface.rs +++ b/src/ui_cm_interface.rs @@ -11,14 +11,12 @@ use std::{ }, }; -#[cfg(windows)] -use clipboard::{cliprdr::CliprdrClientContext, empty_clipboard, set_conn_enabled, ContextSend}; -use serde_derive::Serialize; - #[cfg(not(any(target_os = "android", target_os = "ios")))] use crate::ipc::Connection; #[cfg(not(any(target_os = "ios")))] use crate::ipc::{self, Data}; +#[cfg(windows)] +use clipboard::{cliprdr::CliprdrClientContext, empty_clipboard, ContextSend}; #[cfg(not(any(target_os = "android", target_os = "ios")))] use hbb_common::tokio::sync::mpsc::unbounded_channel; #[cfg(windows)] @@ -37,6 +35,7 @@ use hbb_common::{ task::spawn_blocking, }, }; +use serde_derive::Serialize; #[derive(Serialize, Clone)] pub struct Client { @@ -131,8 +130,7 @@ impl ConnectionManager { restart: bool, recording: bool, from_switch: bool, - #[cfg(not(any(target_os = "ios")))] - tx: mpsc::UnboundedSender, + #[cfg(not(any(target_os = "ios")))] tx: mpsc::UnboundedSender, ) { let client = Client { id, @@ -303,42 +301,12 @@ pub fn switch_back(id: i32) { #[cfg(not(any(target_os = "android", target_os = "ios")))] impl IpcTaskRunner { - #[cfg(windows)] - async fn enable_cliprdr_file_context(&mut self, conn_id: i32, enabled: bool) { - if conn_id == 0 { - return; - } - - let pre_enabled = ContextSend::is_enabled(); - ContextSend::enable(enabled); - if !pre_enabled && ContextSend::is_enabled() { - allow_err!( - self.stream - .send(&Data::ClipboardFile(clipboard::ClipboardFile::MonitorReady)) - .await - ); - } - set_conn_enabled(conn_id, enabled); - if !enabled { - ContextSend::proc(|context: &mut Box| -> u32 { - empty_clipboard(context, conn_id); - 0 - }); - } - } - async fn run(&mut self) { use hbb_common::config::LocalConfig; // for tmp use, without real conn id let mut write_jobs: Vec = Vec::new(); - #[cfg(windows)] - if self.conn_id > 0 { - self.enable_cliprdr_file_context(self.conn_id, self.file_transfer_enabled) - .await; - } - #[cfg(windows)] let rx_clip1; let mut rx_clip; @@ -382,15 +350,11 @@ impl IpcTaskRunner { break; } Data::Close => { - #[cfg(windows)] - self.enable_cliprdr_file_context(self.conn_id, false).await; log::info!("cm ipc connection closed from connection request"); break; } Data::Disconnected => { self.close = false; - #[cfg(windows)] - self.enable_cliprdr_file_context(self.conn_id, false).await; log::info!("cm ipc connection disconnect"); break; } @@ -414,21 +378,18 @@ impl IpcTaskRunner { handle_fs(fs, &mut write_jobs, &self.tx).await; } } - #[cfg(windows)] + #[cfg(not(any(target_os = "android", target_os = "ios")))] Data::ClipboardFile(_clip) => { #[cfg(windows)] { - let conn_id = self.conn_id; - ContextSend::proc(|context: &mut Box| -> u32 { - clipboard::server_clip_file(context, conn_id, _clip) - }); + if !_clip.is_stopping_allowed() || self.file_transfer_enabled { + let conn_id = self.conn_id; + ContextSend::proc(|context: &mut Box| -> u32 { + clipboard::server_clip_file(context, conn_id, _clip) + }); + } } } - #[cfg(windows)] - Data::ClipboardFileEnabled(_enabled) => { - #[cfg(windows)] - self.enable_cliprdr_file_context(self.conn_id, _enabled).await; - } Data::Theme(dark) => { self.cm.change_theme(dark); } @@ -457,6 +418,11 @@ impl IpcTaskRunner { } } Some(data) = self.rx.recv() => { + if let Data::SwitchPermission{name, enabled} = &data { + if name == "file" { + self.file_transfer_enabled = *enabled; + } + } if self.stream.send(&data).await.is_err() { break; } @@ -464,7 +430,9 @@ impl IpcTaskRunner { clip_file = rx_clip.recv() => match clip_file { Some(_clip) => { #[cfg(windows)] - allow_err!(self.tx.send(Data::ClipboardFile(_clip))); + if !_clip.is_stopping_allowed() || self.file_transfer_enabled { + allow_err!(self.tx.send(Data::ClipboardFile(_clip))); + } } None => { // @@ -517,6 +485,13 @@ pub async fn start_ipc(cm: ConnectionManager) { allow_err!(crate::privacy_win_mag::start()); }); + #[cfg(target_os = "windows")] + ContextSend::enable( + Config::get_option("enable-file-transfer").is_empty(), + true, + crate::is_server(), + ); + match ipc::new_listener("_cm").await { Ok(mut incoming) => { while let Some(result) = incoming.next().await { diff --git a/src/ui_interface.rs b/src/ui_interface.rs index 38e29b056..0945e59af 100644 --- a/src/ui_interface.rs +++ b/src/ui_interface.rs @@ -857,6 +857,8 @@ async fn check_connect_status_(reconnect: bool, rx: mpsc::UnboundedReceiver { *OPTIONS.lock().unwrap() = v; *OPTION_SYNCED.lock().unwrap() = true; + + #[cfg(target_os="windows")] + { + let b = OPTIONS.lock().unwrap().get("enable-file-transfer").map(|x| x.to_string()).unwrap_or_default(); + if b != enable_file_transfer { + clipboard::ContextSend::enable( + b.is_empty(), + true, + crate::is_server(), + ); + enable_file_transfer = b; + } + } } Ok(Some(ipc::Data::Config((name, Some(value))))) => { if name == "id" { diff --git a/src/ui_session_interface.rs b/src/ui_session_interface.rs index 5fd1ef918..aec45bdcc 100644 --- a/src/ui_session_interface.rs +++ b/src/ui_session_interface.rs @@ -198,6 +198,7 @@ impl Session { pub fn toggle_option(&mut self, name: String) { let msg = self.lc.write().unwrap().toggle_option(name.clone()); + #[cfg(not(feature = "flutter"))] if name == "enable-file-transfer" { self.send(Data::ToggleClipboardFile); }