From 71d64a2def4d5157c70be194bddaa140876df8c5 Mon Sep 17 00:00:00 2001 From: fufesou Date: Wed, 3 May 2023 22:37:43 +0800 Subject: [PATCH] plugin_framework, add block input support Signed-off-by: fufesou --- src/plugin/callback_ext.rs | 49 ++++++++++++ src/plugin/callback_msg.rs | 153 +++++++++++++++++++++++++------------ src/plugin/errno.rs | 25 ++++-- src/plugin/mod.rs | 17 +++++ src/plugin/plugins.rs | 21 +++-- src/server/connection.rs | 73 ++++++++++++++++++ 6 files changed, 277 insertions(+), 61 deletions(-) create mode 100644 src/plugin/callback_ext.rs diff --git a/src/plugin/callback_ext.rs b/src/plugin/callback_ext.rs new file mode 100644 index 000000000..0e4425a9c --- /dev/null +++ b/src/plugin/callback_ext.rs @@ -0,0 +1,49 @@ +// External support for callback. +// 1. Support block input for some plugins. +// ----------------------------------------------------------------------------- + +use super::*; +use std::{ffi::c_void, ptr::null, str::FromStr}; + +const EXT_SUPPORT_BLOCK_INPUT: &str = "block-input"; + +pub(super) fn ext_support_callback( + id: &str, + peer: &str, + msg: &super::callback_msg::MsgToExtSupport, +) -> *const c_void { + match &msg.r#type as _ { + EXT_SUPPORT_BLOCK_INPUT => { + // let supported_plugins = []; + // let supported = supported_plugins.contains(&id); + let supported = true; + if supported { + match bool::from_str(&msg.data) { + Ok(block) => { + if crate::server::plugin_block_input(peer, block) == block { + null() + } else { + make_return_code_msg( + errno::ERR_CALLBACK_FAILED, + "Failed to block input", + ) + } + } + Err(err) => make_return_code_msg( + errno::ERR_CALLBACK_INVALID_ARGS, + &format!("Failed to parse data: {}", err), + ), + } + } else { + make_return_code_msg( + errno::ERR_CALLBACK_PLUGIN_ID, + &format!("This operation is not supported for plugin '{}', please contact the RustDesk team for support.", id), + ) + } + } + _ => make_return_code_msg( + errno::ERR_CALLBACK_TARGET_TYPE, + &format!("Unknown target type '{}'", &msg.r#type), + ), + } +} diff --git a/src/plugin/callback_msg.rs b/src/plugin/callback_msg.rs index d33d00962..7ed4cf589 100644 --- a/src/plugin/callback_msg.rs +++ b/src/plugin/callback_msg.rs @@ -6,12 +6,14 @@ use serde_json; use std::{ collections::HashMap, ffi::{c_char, c_void}, + ptr::null, sync::Arc, }; const MSG_TO_PEER_TARGET: &str = "peer"; const MSG_TO_UI_TARGET: &str = "ui"; const MSG_TO_CONFIG_TARGET: &str = "config"; +const MSG_TO_EXT_SUPPORT_TARGET: &str = "ext-support"; #[allow(dead_code)] const MSG_TO_UI_FLUTTER_CHANNEL_MAIN: u16 = 0x01 << 0; @@ -44,7 +46,6 @@ struct ConfigToUi { #[derive(Debug, Deserialize)] struct MsgToConfig { - id: String, r#type: String, key: String, value: String, @@ -52,6 +53,39 @@ struct MsgToConfig { ui: Option, // If not None, send msg to ui. } +#[derive(Debug, Deserialize)] +pub(super) struct MsgToExtSupport { + pub r#type: String, + pub data: String, +} + +macro_rules! cb_msg_field { + ($field: ident) => { + let $field = match cstr_to_string($field) { + Err(e) => { + log::error!("Failed to convert {} to string, {}", stringify!($field), e); + return make_return_code_msg( + errno::ERR_CALLBACK_INVALID_ARGS, + &format!("Failed to convert {} to string, {}", stringify!($field), e), + ); + } + Ok(v) => v, + }; + }; +} + +macro_rules! early_return_value { + ($e:expr, $code: ident, $($arg:tt)*) => { + match $e { + Err(e) => return make_return_code_msg( + errno::$code, + &format!("Failed to {} '{:?}'", format_args!($($arg)*), e), + ), + Ok(v) => v, + } + }; +} + /// Callback to send message to peer or ui. /// peer, target, id are utf8 strings(null terminated). /// @@ -60,6 +94,10 @@ struct MsgToConfig { /// id: The id of this plugin. /// content: The content. /// len: The length of the content. +/// +/// Return null ptr if success. +/// Return the error message if failed. `i32-String` without dash, i32 is a signed little-endian number, the String is utf8 string. +/// The plugin allocate memory with `libc::malloc` and return the pointer. #[no_mangle] pub(super) extern "C" fn cb_msg( peer: *const c_char, @@ -67,18 +105,7 @@ pub(super) extern "C" fn cb_msg( id: *const c_char, content: *const c_void, len: usize, -) { - macro_rules! cb_msg_field { - ($field: ident) => { - let $field = match cstr_to_string($field) { - Err(e) => { - log::error!("Failed to convert {} to string, {}", stringify!($field), e); - return; - } - Ok(v) => v, - }; - }; - } +) -> *const c_void { cb_msg_field!(peer); cb_msg_field!(target); cb_msg_field!(id); @@ -95,6 +122,12 @@ pub(super) extern "C" fn cb_msg( ..Default::default() }; session.send_plugin_request(request); + null() + } else { + make_return_code_msg( + errno::ERR_CALLBACK_PEER_NOT_FOUND, + &format!("Failed to find session for peer '{}'", peer), + ) } } MSG_TO_UI_TARGET => { @@ -103,47 +136,69 @@ pub(super) extern "C" fn cb_msg( let content = std::string::String::from_utf8(content_slice[2..].to_vec()) .unwrap_or("".to_string()); push_event_to_ui(channel, &peer, &content); + null() } MSG_TO_CONFIG_TARGET => { - if let Ok(s) = - std::str::from_utf8(unsafe { std::slice::from_raw_parts(content as _, len) }) - { - // No need to merge the msgs. Handling the msg one by one is ok. - if let Ok(msg) = serde_json::from_str::(s) { - match &msg.r#type as _ { - config::CONFIG_TYPE_SHARED => { - match config::SharedConfig::set(&msg.id, &msg.key, &msg.value) { - Ok(_) => { - if let Some(ui) = &msg.ui { - // No need to set the peer id for location config. - push_option_to_ui(ui.channel, "", &msg, ui); - } - } - Err(e) => { - log::error!("Failed to set local config, {}", e); - } - } - } - config::CONFIG_TYPE_PEER => { - match config::PeerConfig::set(&msg.id, &peer, &msg.key, &msg.value) { - Ok(_) => { - if let Some(ui) = &msg.ui { - push_option_to_ui(ui.channel, &peer, &msg, ui); - } - } - Err(e) => { - log::error!("Failed to set peer config, {}", e); - } - } - } - _ => {} + let s = early_return_value!( + std::str::from_utf8(unsafe { std::slice::from_raw_parts(content as _, len) }), + ERR_CALLBACK_INVALID_MSG, + "parse msg string" + ); + // No need to merge the msgs. Handling the msg one by one is ok. + let msg = early_return_value!( + serde_json::from_str::(s), + ERR_CALLBACK_INVALID_MSG, + "parse msg '{}'", + s + ); + match &msg.r#type as _ { + config::CONFIG_TYPE_SHARED => { + let _r = early_return_value!( + config::SharedConfig::set(&id, &msg.key, &msg.value), + ERR_CALLBACK_INVALID_MSG, + "set local config" + ); + if let Some(ui) = &msg.ui { + // No need to set the peer id for location config. + push_option_to_ui(ui.channel, &id, "", &msg, ui); } + null() } + config::CONFIG_TYPE_PEER => { + let _r = early_return_value!( + config::PeerConfig::set(&id, &peer, &msg.key, &msg.value), + ERR_CALLBACK_INVALID_MSG, + "set peer config" + ); + if let Some(ui) = &msg.ui { + push_option_to_ui(ui.channel, &id, &peer, &msg, ui); + } + null() + } + _ => make_return_code_msg( + errno::ERR_CALLBACK_TARGET_TYPE, + &format!("Unknown target type '{}'", &msg.r#type), + ), } } - _ => { - log::error!("Unknown target {}", target); + MSG_TO_EXT_SUPPORT_TARGET => { + let s = early_return_value!( + std::str::from_utf8(unsafe { std::slice::from_raw_parts(content as _, len) }), + ERR_CALLBACK_INVALID_MSG, + "parse msg string" + ); + let msg = early_return_value!( + serde_json::from_str::(s), + ERR_CALLBACK_INVALID_MSG, + "parse msg '{}'", + s + ); + super::callback_ext::ext_support_callback(&id, &peer, &msg) } + _ => make_return_code_msg( + errno::ERR_CALLBACK_TARGET, + &format!("Unknown target '{}'", target), + ), } } @@ -174,9 +229,9 @@ fn push_event_to_ui(channel: u16, peer: &str, content: &str) { } } -fn push_option_to_ui(channel: u16, peer: &str, msg: &MsgToConfig, ui: &ConfigToUi) { +fn push_option_to_ui(channel: u16, id: &str, peer: &str, msg: &MsgToConfig, ui: &ConfigToUi) { let v = [ - ("id", &msg.id as &str), + ("id", id), ("location", &ui.location), ("key", &msg.key), ("value", &msg.value), diff --git a/src/plugin/errno.rs b/src/plugin/errno.rs index f62a3daac..eda53f2f2 100644 --- a/src/plugin/errno.rs +++ b/src/plugin/errno.rs @@ -3,7 +3,7 @@ pub const ERR_SUCCESS: i32 = 0; // ====================================================== -// errors that will be handled by RustDesk +// Errors from the plugins, must be handled by RustDesk pub const ERR_RUSTDESK_HANDLE_BASE: i32 = 10000; @@ -21,10 +21,23 @@ pub const ERR_PEER_ID_MISMATCH: i32 = 10302; pub const ERR_NOT_HANDLED: i32 = 10401; // ====================================================== -// errors that should be handled by the plugin +// Errors from RustDesk callbacks. -pub const ERR_PLUGIN_HANDLE_BASE: i32 = 20000; +pub const ERR_CALLBACK_HANDLE_BASE: i32 = 20000; +pub const ERR_CALLBACK_PLUGIN_ID: i32 = 20001; +pub const ERR_CALLBACK_INVALID_ARGS: i32 = 20002; +pub const ERR_CALLBACK_INVALID_MSG: i32 = 20003; +pub const ERR_CALLBACK_TARGET: i32 = 20004; +pub const ERR_CALLBACK_TARGET_TYPE: i32 = 20005; +pub const ERR_CALLBACK_PEER_NOT_FOUND: i32 = 20006; -pub const EER_CALL_FAILED: i32 = 200021; -pub const ERR_PEER_ON_FAILED: i32 = 30012; -pub const ERR_PEER_OFF_FAILED: i32 = 30012; +pub const ERR_CALLBACK_FAILED: i32 = 21001; + +// ====================================================== +// Errors from the plugins, should be handled by the plugins. + +pub const ERR_PLUGIN_HANDLE_BASE: i32 = 30000; + +pub const EER_CALL_FAILED: i32 = 300021; +pub const ERR_PEER_ON_FAILED: i32 = 40012; +pub const ERR_PEER_OFF_FAILED: i32 = 40012; diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs index ce4383ce5..e15a7f7ca 100644 --- a/src/plugin/mod.rs +++ b/src/plugin/mod.rs @@ -2,6 +2,7 @@ use hbb_common::{libc, ResultType}; use std::ffi::{c_char, c_void, CStr}; mod callback_msg; +mod callback_ext; mod config; pub mod desc; mod errno; @@ -50,6 +51,22 @@ fn str_to_cstr_ret(s: &str) -> *const c_char { } } +#[inline] +pub fn make_return_code_msg(code: i32, msg: &str) -> *const c_void { + let mut out = code.to_le_bytes().to_vec(); + out.extend(msg.as_bytes()); + out.push(0); + unsafe { + let r = libc::malloc(out.len()) as *mut c_char; + libc::memcpy( + r as *mut libc::c_void, + out.as_ptr() as *const libc::c_void, + out.len(), + ); + r as *const c_void + } +} + #[inline] fn get_code_msg_from_ret(ret: *const c_void) -> (i32, String) { assert!(ret.is_null() == false); diff --git a/src/plugin/plugins.rs b/src/plugin/plugins.rs index 4441d314d..5c9a04e0a 100644 --- a/src/plugin/plugins.rs +++ b/src/plugin/plugins.rs @@ -14,7 +14,7 @@ use std::{ collections::HashMap, ffi::{c_char, c_void}, path::PathBuf, - sync::{Arc, RwLock}, os::raw::c_uint, + sync::{Arc, RwLock}, }; const METHOD_HANDLE_UI: &[u8; 10] = b"handle_ui\0"; @@ -64,13 +64,17 @@ type PluginFuncDesc = extern "C" fn() -> *const c_char; /// id: The id of this plugin. /// content: The content. /// len: The length of the content. +/// +/// Return null ptr if success. +/// Return the error message if failed. `i32-String` without dash, i32 is a signed little-endian number, the String is utf8 string. +/// The plugin allocate memory with `libc::malloc` and return the pointer. type CallbackMsg = extern "C" fn( peer: *const c_char, target: *const c_char, id: *const c_char, content: *const c_void, len: usize, -); +) -> *const c_void; /// Callback to get the config. /// peer, key are utf8 strings(null terminated). /// @@ -93,12 +97,17 @@ type CallbackGetId = extern "C" fn() -> *const c_char; type CallbackLog = extern "C" fn(level: *const c_char, msg: *const c_char); /// Callback to the librustdesk core. -/// +/// /// method: the method name of this callback. /// json: the json data for the parameters. The argument *must* be non-null. /// raw: the binary data for this call, nullable. /// raw_len: the length of this binary data, only valid when we pass raw data to `raw`. -type CallbackNative = extern "C" fn(method: *const c_char, json: *const c_char, raw: *const c_void, raw_len: usize) -> super::native::NativeReturnValue; +type CallbackNative = extern "C" fn( + method: *const c_char, + json: *const c_char, + raw: *const c_void, + raw_len: usize, +) -> super::native::NativeReturnValue; /// The main function of the plugin on the client(self) side. /// /// method: The method. "handle_ui" or "handle_peer" @@ -148,7 +157,7 @@ struct Callbacks { get_conf: CallbackGetConf, get_id: CallbackGetId, log: CallbackLog, - native: CallbackNative + native: CallbackNative, } /// The plugin initialize data. @@ -343,7 +352,7 @@ fn load_plugin_path(path: &str) -> ResultType<()> { get_conf: config::cb_get_conf, get_id: config::cb_get_local_peer_id, log: super::plog::plugin_log, - native: super::native::cb_native_data + native: super::native::cb_native_data, }, }; plugin.init(&init_data, path)?; diff --git a/src/server/connection.rs b/src/server/connection.rs index b2651f0d3..5cc1a4678 100644 --- a/src/server/connection.rs +++ b/src/server/connection.rs @@ -65,6 +65,43 @@ lazy_static::lazy_static! { pub static CLICK_TIME: AtomicI64 = AtomicI64::new(0); pub static MOUSE_MOVE_TIME: AtomicI64 = AtomicI64::new(0); +#[cfg(all(feature = "flutter", feature = "plugin_framework"))] +#[cfg(not(any(target_os = "android", target_os = "ios")))] +lazy_static::lazy_static! { + static ref PLUGIN_BLOCK_INPUT_TXS: Arc>>> = Default::default(); + static ref PLUGIN_BLOCK_INPUT_TX_RX: (Arc>>, Arc>>) = { + let (tx, rx) = std_mpsc::channel(); + (Arc::new(Mutex::new(tx)), Arc::new(Mutex::new(rx))) + }; +} + +// Block input is required for some special cases, such as privacy mode. +#[cfg(all(feature = "flutter", feature = "plugin_framework"))] +#[cfg(not(any(target_os = "android", target_os = "ios")))] +pub fn plugin_block_input(peer: &str, block: bool) -> bool { + if let Some(tx) = PLUGIN_BLOCK_INPUT_TXS.lock().unwrap().get(peer) { + let _ = tx.send(if block { + MessageInput::BlockOnPlugin(peer.to_string()) + } else { + MessageInput::BlockOffPlugin(peer.to_string()) + }); + match PLUGIN_BLOCK_INPUT_TX_RX + .1 + .lock() + .unwrap() + .recv_timeout(std::time::Duration::from_millis(3_000)) + { + Ok(b) => b == block, + Err(..) => { + log::error!("plugin_block_input timeout"); + false + } + } + } else { + false + } +} + #[derive(Clone, Default)] pub struct ConnInner { id: i32, @@ -79,6 +116,12 @@ enum MessageInput { Key((KeyEvent, bool)), BlockOn, BlockOff, + #[cfg(all(feature = "flutter", feature = "plugin_framework"))] + #[cfg(not(any(target_os = "android", target_os = "ios")))] + BlockOnPlugin(String), + #[cfg(all(feature = "flutter", feature = "plugin_framework"))] + #[cfg(not(any(target_os = "android", target_os = "ios")))] + BlockOffPlugin(String), } #[derive(Clone, Debug)] @@ -646,6 +689,30 @@ impl Connection { ); } } + #[cfg(all(feature = "flutter", feature = "plugin_framework"))] + #[cfg(not(any(target_os = "android", target_os = "ios")))] + MessageInput::BlockOnPlugin(peer) => { + if crate::platform::block_input(true) { + block_input_mode = true; + } + let _r = PLUGIN_BLOCK_INPUT_TX_RX + .0 + .lock() + .unwrap() + .send(block_input_mode); + } + #[cfg(all(feature = "flutter", feature = "plugin_framework"))] + #[cfg(not(any(target_os = "android", target_os = "ios")))] + MessageInput::BlockOffPlugin(peer) => { + if crate::platform::block_input(false) { + block_input_mode = false; + } + let _r = PLUGIN_BLOCK_INPUT_TX_RX + .0 + .lock() + .unwrap() + .send(block_input_mode); + } }, Err(err) => { #[cfg(not(any(target_os = "android", target_os = "ios")))] @@ -944,6 +1011,12 @@ impl Connection { } } self.authorized = true; + #[cfg(all(feature = "flutter", feature = "plugin_framework"))] + #[cfg(not(any(target_os = "android", target_os = "ios")))] + PLUGIN_BLOCK_INPUT_TXS + .lock() + .unwrap() + .insert(self.lr.my_id.clone(), self.tx_input.clone()); pi.username = username; pi.sas_enabled = sas_enabled;