Merge pull request #4270 from fufesou/feat/plugin_framework

Feat/plugin framework

src/plugin/callback_ext.rs

@@ -0,0 +1,45 @@
+// External support for callback.
+// 1. Support block input for some plugins.
+// -----------------------------------------------------------------------------
+
+use super::*;
+use std::{ffi::c_void, ptr::null};
+
+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 {
+                if msg.data.len() != 1 {
+                    return make_return_code_msg(
+                        errno::ERR_CALLBACK_INVALID_ARGS,
+                        "Invalid data length",
+                    );
+                }
+                let block = msg.data[0] != 0;
+                if crate::server::plugin_block_input(peer, block) == block {
+                    null()
+                } else {
+                    make_return_code_msg(errno::ERR_CALLBACK_FAILED, "")
+                }
+            } 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),
+        ),
+    }
+}

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<ConfigToUi>, // If not None, send msg to ui.
 }
 
+#[derive(Debug, Deserialize)]
+pub(super) struct MsgToExtSupport {
+    pub r#type: String,
+    pub data: Vec<u8>,
+}
+
+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,
-) {
+) -> *const c_void {
-    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,
-            };
-        };
-    }
     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) =
+            let s = early_return_value!(
-                std::str::from_utf8(unsafe { std::slice::from_raw_parts(content as _, len) })
+                std::str::from_utf8(unsafe { std::slice::from_raw_parts(content as _, len) }),
-            {
+                ERR_CALLBACK_INVALID_MSG,
-                // No need to merge the msgs. Handling the msg one by one is ok.
+                "parse msg string"
-                if let Ok(msg) = serde_json::from_str::<MsgToConfig>(s) {
+            );
-                    match &msg.r#type as _ {
+            // No need to merge the msgs. Handling the msg one by one is ok.
-                        config::CONFIG_TYPE_SHARED => {
+            let msg = early_return_value!(
-                            match config::SharedConfig::set(&msg.id, &msg.key, &msg.value) {
+                serde_json::from_str::<MsgToConfig>(s),
-                                Ok(_) => {
+                ERR_CALLBACK_INVALID_MSG,
-                                    if let Some(ui) = &msg.ui {
+                "parse msg '{}'",
-                                        // No need to set the peer id for location config.
+                s
-                                        push_option_to_ui(ui.channel, "", &msg, ui);
+            );
-                                    }
+            match &msg.r#type as _ {
-                                }
+                config::CONFIG_TYPE_SHARED => {
-                                Err(e) => {
+                    let _r = early_return_value!(
-                                    log::error!("Failed to set local config, {}", e);
+                        config::SharedConfig::set(&id, &msg.key, &msg.value),
-                                }
+                        ERR_CALLBACK_INVALID_MSG,
-                            }
+                        "set local config"
-                        }
+                    );
-                        config::CONFIG_TYPE_PEER => {
+                    if let Some(ui) = &msg.ui {
-                            match config::PeerConfig::set(&msg.id, &peer, &msg.key, &msg.value) {
+                        // No need to set the peer id for location config.
-                                Ok(_) => {
+                        push_option_to_ui(ui.channel, &id, "", &msg, ui);
-                                    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);
-                                }
-                            }
-                        }
-                        _ => {}
                     }
+                    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),
+                ),
             }
         }
-        _ => {
+        MSG_TO_EXT_SUPPORT_TARGET => {
-            log::error!("Unknown target {}", 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::<MsgToExtSupport>(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),

src/plugin/errno.rs

@@ -3,28 +3,46 @@
 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;
 
 // not loaded
 pub const ERR_PLUGIN_LOAD: i32 = 10001;
 // not initialized
-pub const ERR_PLUGIN_MSG_CB: i32 = 10101;
+pub const ERR_PLUGIN_MSG_INIT: i32 = 10101;
+pub const ERR_PLUGIN_MSG_INIT_INVALID: i32 = 10102;
+pub const ERR_PLUGIN_MSG_GET_LOCAL_PEER_ID: i32 = 10103;
 // invalid
-pub const ERR_CALL_INVALID_METHOD: i32 = 10201;
+pub const ERR_CALL_UNIMPLEMENTED: i32 = 10201;
-pub const ERR_CALL_NOT_SUPPORTED_METHOD: i32 = 10202;
+pub const ERR_CALL_INVALID_METHOD: i32 = 10202;
+pub const ERR_CALL_NOT_SUPPORTED_METHOD: i32 = 10203;
+pub const ERR_CALL_INVALID_PEER: i32 = 10204;
 // failed on calling
 pub const ERR_CALL_INVALID_ARGS: i32 = 10301;
 pub const ERR_PEER_ID_MISMATCH: i32 = 10302;
+pub const ERR_CALL_CONFIG_VALUE: i32 = 10303;
 // no handlers on calling
 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_CALLBACK_FAILED: i32 = 21001;
-pub const ERR_PEER_ON_FAILED: i32 = 30012;
+
-pub const ERR_PEER_OFF_FAILED: i32 = 30012;
+// ======================================================
+// Errors from the plugins, should be handled by the plugins.
+
+pub const ERR_PLUGIN_HANDLE_BASE: i32 = 30000;
+
+pub const EER_CALL_FAILED: i32 = 30021;
+pub const ERR_PEER_ON_FAILED: i32 = 40012;
+pub const ERR_PEER_OFF_FAILED: i32 = 40012;

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);

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)?;

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<Mutex<HashMap<String, std_mpsc::Sender<MessageInput>>>> = Default::default();
+    static ref PLUGIN_BLOCK_INPUT_TX_RX: (Arc<Mutex<std_mpsc::Sender<bool>>>, Arc<Mutex<std_mpsc::Receiver<bool>>>) = {
+        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;