handle peer event

Signed-off-by: fufesou <shuanglongchen@yeah.net>

src/plugin/callback_msg.rs

@@ -1,6 +1,6 @@
 use super::cstr_to_string;
 use crate::flutter::{self, APP_TYPE_CM, APP_TYPE_MAIN, SESSIONS};
-use hbb_common::{lazy_static, log, message_proto::Plugin};
+use hbb_common::{lazy_static, log, message_proto::PluginRequest};
 use serde_json;
 use std::{collections::HashMap, ffi::c_char, sync::Arc};
 
@@ -66,7 +66,7 @@ pub fn callback_msg(
                 let content_slice =
                     unsafe { std::slice::from_raw_parts(content as *const u8, len) };
                 let content_vec = Vec::from(content_slice);
-                let plugin = Plugin {
+                let plugin = PluginRequest {
                     id,
                     content: bytes::Bytes::from(content_vec),
                     ..Default::default()

src/plugin/errno.rs

@@ -0,0 +1,26 @@
+pub const ERR_SUCCESS: i32 = 0;
+
+// ======================================================
+// errors that will 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;
+// invalid
+pub const ERR_CALL_INVALID_METHOD: i32 = 10201;
+pub const ERR_CALL_NOT_SUPPORTED_METHOD: i32 = 10202;
+// failed on calling
+pub const ERR_CALL_INVALID_ARGS: i32 = 10301;
+pub const ERR_PEER_ID_MISMATCH: i32 = 10302;
+
+// ======================================================
+// errors that must be handled by plugin
+
+pub const ERR_PLUGIN_HANDLE_BASE: i32 = 20000;
+
+pub const EER_CALL_FAILED: i32 = 200021;
+pub const ERR_PEER_ON_FAILED: i32 = 30012;
+pub const ERR_PEER_OFF_FAILED: i32 = 30012;

src/plugin/mod.rs

@@ -5,8 +5,11 @@ mod callback_msg;
 mod config;
 pub mod desc;
 mod plugins;
+mod errno;
 
-pub use plugins::load_plugins;
+pub use plugins::{
+    handle_client_event, handle_ui_event, load_plugin, load_plugins, reload_plugin, unload_plugin,
+};
 
 #[inline]
 fn cstr_to_string(cstr: *const c_char) -> ResultType<String> {
@@ -14,3 +17,15 @@ fn cstr_to_string(cstr: *const c_char) -> ResultType<String> {
         CStr::from_ptr(cstr).to_bytes().to_vec()
     })?)
 }
+
+#[inline]
+fn get_code_msg_from_ret(ret: *const c_void) -> (i32, String) {
+    assert!(ret.is_null() == false);
+    let code_bytes = unsafe { std::slice::from_raw_parts(ret as *const u8, 4) };
+    let code = i32::from_le_bytes([code_bytes[0], code_bytes[1], code_bytes[2], code_bytes[3]]);
+    let msg = unsafe { CStr::from_ptr((ret as *const u8).add(4) as _) }
+        .to_str()
+        .unwrap_or("")
+        .to_string();
+    Ok((code, msg))
+}

src/plugin/plugins.rs

@@ -5,23 +5,41 @@ use std::{
     sync::{Arc, RwLock},
 };
 
-use super::{callback_msg, desc::Desc};
+use super::{callback_msg, desc::Desc, errno::*, get_code_msg_from_ret};
 use crate::flutter;
-use hbb_common::{bail, dlopen::symbor::Library, lazy_static, libc, log, ResultType};
+use hbb_common::{
+    bail,
+    dlopen::symbor::Library,
+    lazy_static, libc, log,
+    message_proto::{Message, Misc, PluginResponse},
+    ResultType,
+};
+
+const METHOD_HANDLE_UI: &[u8; 10] = b"handle_ui\0";
+const METHOD_HANDLE_PEER: &[u8; 12] = b"handle_peer\0";
 
 lazy_static::lazy_static! {
     pub static ref PLUGINS: Arc<RwLock<HashMap<String, Plugin>>> = Default::default();
 }
 
 /// Initialize the plugins.
-/// Return 0 if success.
-pub type PluginFuncInit = fn() -> i32;
+///
+/// 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.
+pub type PluginFuncInit = fn() -> *const c_void;
 /// Reset the plugin.
-/// Return 0 if success.
-pub type PluginFuncReset = fn() -> i32;
+///
+/// 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.
+pub type PluginFuncReset = fn() -> *const c_void;
 /// Clear the plugin.
-/// Return 0 if success.
-pub type PluginFuncClear = fn() -> i32;
+///
+/// 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.
+pub type PluginFuncClear = fn() -> *const c_void;
 /// Get the description of the plugin.
 /// Return the description. The plugin allocate memory with `libc::malloc` and return the pointer.
 pub type PluginFuncDesc = fn() -> *const c_char;
@@ -37,22 +55,19 @@ type PluginFuncCallbackMsg = fn(
     peer: *const c_char,
     target: *const c_char,
     id: *const c_char,
-    content: *const c_char,
+    content: *const c_void,
     len: usize,
 );
 pub type PluginFuncSetCallbackMsg = fn(PluginFuncCallbackMsg);
 /// The main function of the plugin.
 /// method: The method. "handle_ui" or "handle_peer"
 /// args: The arguments.
-/// out:  The output. The plugin allocate memory with `libc::malloc` and set the pointer to `out`.
-/// out_len: The length of the output.
-/// Return 0 if success.
-pub type PluginFuncCall = fn(
-    method: *const c_char,
-    args: *const c_char,
-    out: *mut *mut c_char,
-    out_len: *mut usize,
-) -> i32;
+///
+/// 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.
+pub type PluginFuncCall =
+    fn(method: *const c_char, args: *const c_void, len: usize) -> *const c_void;
 
 macro_rules! make_plugin {
     ($($field:ident : $tp:ty),+) => {
@@ -140,7 +155,7 @@ pub fn reload_plugin(id: &str) -> ResultType<()> {
     load_plugin(&path)
 }
 
-fn load_plugin(path: &str) -> ResultType<()> {
+pub fn load_plugin(path: &str) -> ResultType<()> {
     let mut plugin = Plugin::new(path)?;
     let desc = (plugin.fn_desc)();
     let desc_res = Desc::from_cstr(desc);
@@ -149,6 +164,7 @@ fn load_plugin(path: &str) -> ResultType<()> {
     }
     let desc = desc_res?;
     let id = desc.id().to_string();
+    // to-do validate plugin
     (plugin.fn_set_cb_msg)(callback_msg::callback_msg);
     update_config(&desc);
     reload_ui(&desc);
@@ -157,6 +173,101 @@ fn load_plugin(path: &str) -> ResultType<()> {
     Ok(())
 }
 
+fn handle_event(method: &[u8], id: &str, event: &[u8]) -> ResultType<()> {
+    match PLUGINS.read().unwrap().get(id) {
+        Some(plugin) => {
+            let ret = (plugin.fn_call)(method.as_ptr() as _, event.as_ptr(), event.len());
+            if ret.is_null() {
+                Ok(())
+            } else {
+                let (code, msg) = get_code_msg_from_ret(ret);
+                unsafe {
+                    libc::free(ret);
+                }
+                bail!(
+                    "Failed to handle plugin event, id: {}, method: {}, code: {}, msg: {}",
+                    id,
+                    std::string::String::from_utf8(method.to_vec()).unwrap_or_default(),
+                    code,
+                    msg
+                );
+            }
+        }
+        None => bail!("Plugin {} not found", id),
+    }
+}
+
+#[inline]
+pub fn handle_ui_event(id: &str, event: &[u8]) -> ResultType<()> {
+    handle_event(METHOD_HANDLE_UI, id, event)
+}
+
+#[inline]
+pub fn handle_server_event(id: &str, event: &[u8]) -> ResultType<()> {
+    handle_event(METHOD_HANDLE_PEER, id, event)
+}
+
+#[inline]
+pub fn handle_client_event(id: &str, event: &[u8]) -> Option<Message> {
+    match PLUGINS.read().unwrap().get(id) {
+        Some(plugin) => {
+            let ret = (plugin.fn_call)(
+                METHOD_HANDLE_PEER.as_ptr() as _,
+                event.as_ptr(),
+                event.len(),
+            );
+            if ret.is_null() {
+                None
+            } else {
+                let (code, msg) = get_code_msg_from_ret(ret);
+                unsafe {
+                    libc::free(ret);
+                }
+                if code > ERR_RUSTDESK_HANDLE_BASE && code < ERR_PLUGIN_HANDLE_BASE {
+                    let name = match PLUGINS.read().unwrap().get(id) {
+                        Some(plugin) => plugin.desc.as_ref().unwrap().name(),
+                        None => "",
+                    };
+                    match code {
+                        ERR_CALL_NOT_SUPPORTED_METHOD => Some(make_plugin_response(
+                            id,
+                            name,
+                            "plugin method is not supported",
+                        )),
+                        ERR_CALL_INVALID_ARGS => Some(make_plugin_response(
+                            id,
+                            name,
+                            "plugin arguments is invalid",
+                        )),
+                        _ => Some(make_plugin_response(id, name, &msg)),
+                    }
+                } else {
+                    log::error!(
+                        "Failed to handle client event, code: {}, msg: {}",
+                        code,
+                        msg
+                    );
+                    None
+                }
+            }
+        }
+        None => Some(make_plugin_response(id, "", "plugin not found")),
+    }
+}
+
+fn make_plugin_response(id: &str, name: &str, msg: &str) -> Message {
+    let mut misc = Misc::new();
+    misc.set_plugin_response(PluginResponse {
+        id: id.to_owned(),
+        name: name.to_owned(),
+        msg: msg.to_owned(),
+        ..Default::default()
+    });
+    let mut msg_out = Message::new();
+    msg_out.set_misc(misc);
+    msg_out
+}
+
 fn update_config(desc: &Desc) {
     super::config::set_local_items(desc.id(), &desc.config().local);
     super::config::set_peer_items(desc.id(), &desc.config().peer);