From 1243d8f43433675408bdfbd2383b05327f4a357f Mon Sep 17 00:00:00 2001 From: fufesou Date: Thu, 4 May 2023 19:21:13 +0800 Subject: [PATCH] Revert "plugin_framework, change return type" This reverts commit 9c6b303fa25c410c8e170397589b10b0d4d9f6ab. --- src/plugin/callback_ext.rs | 13 ++++--- src/plugin/callback_msg.rs | 27 +++++++------ src/plugin/mod.rs | 79 +++++++++++++++----------------------- src/plugin/plugins.rs | 58 ++++++++++++++-------------- 4 files changed, 83 insertions(+), 94 deletions(-) diff --git a/src/plugin/callback_ext.rs b/src/plugin/callback_ext.rs index 715f47f7e..8312fffd4 100644 --- a/src/plugin/callback_ext.rs +++ b/src/plugin/callback_ext.rs @@ -3,6 +3,7 @@ // ----------------------------------------------------------------------------- use super::*; +use std::{ffi::c_void, ptr::null}; const EXT_SUPPORT_BLOCK_INPUT: &str = "block-input"; @@ -10,7 +11,7 @@ pub(super) fn ext_support_callback( id: &str, peer: &str, msg: &super::callback_msg::MsgToExtSupport, -) -> PluginReturn { +) -> *const c_void { match &msg.r#type as _ { EXT_SUPPORT_BLOCK_INPUT => { // let supported_plugins = []; @@ -18,25 +19,25 @@ pub(super) fn ext_support_callback( let supported = true; if supported { if msg.data.len() != 1 { - return PluginReturn::new( + 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 { - PluginReturn::success() + null() } else { - PluginReturn::new(errno::ERR_CALLBACK_FAILED, "") + make_return_code_msg(errno::ERR_CALLBACK_FAILED, "") } } else { - PluginReturn::new( + 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), ) } } - _ => PluginReturn::new( + _ => 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 6967e6853..db0191376 100644 --- a/src/plugin/callback_msg.rs +++ b/src/plugin/callback_msg.rs @@ -6,6 +6,7 @@ use serde_json; use std::{ collections::HashMap, ffi::{c_char, c_void}, + ptr::null, sync::Arc, }; @@ -62,9 +63,11 @@ macro_rules! cb_msg_field { ($field: ident) => { let $field = match cstr_to_string($field) { Err(e) => { - let msg = format!("Failed to convert {} to string, {}", stringify!($field), e); - log::error!("{}", &msg); - return PluginReturn::new(errno::ERR_CALLBACK_INVALID_ARGS, &msg); + 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, }; @@ -74,7 +77,7 @@ macro_rules! cb_msg_field { macro_rules! early_return_value { ($e:expr, $code: ident, $($arg:tt)*) => { match $e { - Err(e) => return PluginReturn::new( + Err(e) => return make_return_code_msg( errno::$code, &format!("Failed to {} '{}'", format_args!($($arg)*), e), ), @@ -102,7 +105,7 @@ pub(super) extern "C" fn cb_msg( id: *const c_char, content: *const c_void, len: usize, -) -> PluginReturn { +) -> *const c_void { cb_msg_field!(peer); cb_msg_field!(target); cb_msg_field!(id); @@ -119,9 +122,9 @@ pub(super) extern "C" fn cb_msg( ..Default::default() }; session.send_plugin_request(request); - PluginReturn::success() + null() } else { - PluginReturn::new( + make_return_code_msg( errno::ERR_CALLBACK_PEER_NOT_FOUND, &format!("Failed to find session for peer '{}'", peer), ) @@ -133,7 +136,7 @@ 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); - PluginReturn::success() + null() } MSG_TO_CONFIG_TARGET => { let s = early_return_value!( @@ -159,7 +162,7 @@ pub(super) extern "C" fn cb_msg( // No need to set the peer id for location config. push_option_to_ui(ui.channel, &id, "", &msg, ui); } - PluginReturn::success() + null() } config::CONFIG_TYPE_PEER => { let _r = early_return_value!( @@ -170,9 +173,9 @@ pub(super) extern "C" fn cb_msg( if let Some(ui) = &msg.ui { push_option_to_ui(ui.channel, &id, &peer, &msg, ui); } - PluginReturn::success() + null() } - _ => PluginReturn::new( + _ => make_return_code_msg( errno::ERR_CALLBACK_TARGET_TYPE, &format!("Unknown target type '{}'", &msg.r#type), ), @@ -192,7 +195,7 @@ pub(super) extern "C" fn cb_msg( ); super::callback_ext::ext_support_callback(&id, &peer, &msg) } - _ => PluginReturn::new( + _ => make_return_code_msg( errno::ERR_CALLBACK_TARGET, &format!("Unknown target '{}'", target), ), diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs index f5cbdc5dd..e15a7f7ca 100644 --- a/src/plugin/mod.rs +++ b/src/plugin/mod.rs @@ -1,19 +1,16 @@ use hbb_common::{libc, ResultType}; -use std::{ - ffi::{c_char, c_void, CStr}, - ptr::null, -}; +use std::ffi::{c_char, c_void, CStr}; -mod callback_ext; mod callback_msg; +mod callback_ext; mod config; pub mod desc; mod errno; pub mod ipc; -pub mod native; -pub mod native_handlers; mod plog; mod plugins; +pub mod native; +pub mod native_handlers; pub use plugins::{ handle_client_event, handle_listen_event, handle_server_event, handle_ui_event, load_plugin, @@ -32,46 +29,6 @@ pub const EVENT_ON_CONN_CLOSE_SERVER: &str = "on_conn_close_server"; pub use config::{ManagerConfig, PeerConfig, SharedConfig}; -/// The common return of plugin. -/// -/// [Note] -/// msg must be null if code is ERR_SUCCESS. -/// The msg must be freed by caller if it is not null. -#[repr(C)] -pub struct PluginReturn { - pub code: i32, - pub msg: *const c_char, -} - -impl PluginReturn { - pub fn success() -> Self { - PluginReturn { - code: errno::ERR_SUCCESS, - msg: null(), - } - } - - pub fn new(code: i32, msg: &str) -> Self { - let mut msg = msg.as_bytes().to_vec(); - msg.push(0); - let p = unsafe { - let p = libc::malloc(msg.len()) as *mut c_char; - libc::memcpy( - p as *mut libc::c_void, - msg.as_ptr() as *const libc::c_void, - msg.len(), - ); - p as *const c_char - }; - Self { code, msg: p } - } - - #[inline] - pub fn is_success(&self) -> bool { - self.code == errno::ERR_SUCCESS - } -} - #[inline] fn cstr_to_string(cstr: *const c_char) -> ResultType { Ok(String::from_utf8(unsafe { @@ -94,6 +51,34 @@ 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); + 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(); + (code, msg) +} + #[inline] fn free_c_ptr(ret: *mut c_void) { if !ret.is_null() { diff --git a/src/plugin/plugins.rs b/src/plugin/plugins.rs index 87fd92510..5c9a04e0a 100644 --- a/src/plugin/plugins.rs +++ b/src/plugin/plugins.rs @@ -38,7 +38,7 @@ struct PluginInfo { /// 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 PluginFuncInit = extern "C" fn(data: *const InitData) -> PluginReturn; +type PluginFuncInit = extern "C" fn(data: *const InitData) -> *const c_void; /// Reset the plugin. /// /// data: The initialize data. @@ -46,13 +46,13 @@ type PluginFuncInit = extern "C" fn(data: *const InitData) -> PluginReturn; /// 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 PluginFuncReset = extern "C" fn(data: *const InitData) -> PluginReturn; +type PluginFuncReset = extern "C" fn(data: *const InitData) -> *const c_void; /// Clear the plugin. /// /// 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 PluginFuncClear = extern "C" fn() -> PluginReturn; +type PluginFuncClear = extern "C" fn() -> *const c_void; /// Get the description of the plugin. /// Return the description. The plugin allocate memory with `libc::malloc` and return the pointer. type PluginFuncDesc = extern "C" fn() -> *const c_char; @@ -74,7 +74,7 @@ type CallbackMsg = extern "C" fn( id: *const c_char, content: *const c_void, len: usize, -) -> PluginReturn; +) -> *const c_void; /// Callback to get the config. /// peer, key are utf8 strings(null terminated). /// @@ -123,7 +123,7 @@ type PluginFuncClientCall = extern "C" fn( peer: *const c_char, args: *const c_void, len: usize, -) -> PluginReturn; +) -> *const c_void; /// The main function of the plugin on the server(remote) side. /// /// method: The method. "handle_ui" or "handle_peer" @@ -144,7 +144,7 @@ type PluginFuncServerCall = extern "C" fn( len: usize, out: *mut *mut c_void, out_len: *mut usize, -) -> PluginReturn; +) -> *const c_void; /// The plugin callbacks. /// msg: The callback to send message to peer or ui. @@ -223,13 +223,13 @@ macro_rules! make_plugin { fn init(&self, data: &InitData, path: &str) -> ResultType<()> { let init_ret = (self.init)(data as _); - if !init_ret.is_success() { - let msg = cstr_to_string(init_ret.msg).unwrap_or_default(); - free_c_ptr(init_ret.msg as _); + if !init_ret.is_null() { + let (code, msg) = get_code_msg_from_ret(init_ret); + free_c_ptr(init_ret as _); bail!( "Failed to init plugin {}, code: {}, msg: {}", path, - init_ret.code, + code, msg ); } @@ -238,13 +238,13 @@ macro_rules! make_plugin { fn clear(&self, id: &str) { let clear_ret = (self.clear)(); - if !clear_ret.is_success() { - let msg = cstr_to_string(clear_ret.msg).unwrap_or_default(); - free_c_ptr(clear_ret.msg as _); + if !clear_ret.is_null() { + let (code, msg) = get_code_msg_from_ret(clear_ret); + free_c_ptr(clear_ret as _); log::error!( "Failed to clear plugin {}, code: {}, msg: {}", id, - clear_ret.code, + code, msg ); } @@ -413,16 +413,16 @@ fn handle_event(method: &[u8], id: &str, peer: &str, event: &[u8]) -> ResultType event.as_ptr() as _, event.len(), ); - if ret.is_success() { + if ret.is_null() { Ok(()) } else { - let msg = cstr_to_string(ret.msg).unwrap_or_default(); - free_c_ptr(ret.msg as _); + let (code, msg) = get_code_msg_from_ret(ret); + free_c_ptr(ret as _); bail!( "Failed to handle plugin event, id: {}, method: {}, code: {}, msg: {}", id, std::string::String::from_utf8(method.to_vec()).unwrap_or_default(), - ret.code, + code, msg ); } @@ -469,14 +469,14 @@ fn _handle_listen_event(event: String, peer: String) { evt_bytes.as_ptr() as _, evt_bytes.len(), ); - if !ret.is_success() { - let msg = cstr_to_string(ret.msg).unwrap_or_default(); - free_c_ptr(ret.msg as _); + if !ret.is_null() { + let (code, msg) = get_code_msg_from_ret(ret); + free_c_ptr(ret as _); log::error!( "Failed to handle plugin listen event, id: {}, event: {}, code: {}, msg: {}", id, event, - ret.code, + code, msg ); } @@ -510,18 +510,18 @@ pub fn handle_client_event(id: &str, peer: &str, event: &[u8]) -> Message { &mut out as _, &mut out_len as _, ); - if ret.is_success() { + if ret.is_null() { let msg = make_plugin_request(id, out, out_len); free_c_ptr(out as _); msg } else { - let msg = cstr_to_string(ret.msg).unwrap_or_default(); - free_c_ptr(ret.msg as _); - if ret.code > ERR_RUSTDESK_HANDLE_BASE && ret.code < ERR_PLUGIN_HANDLE_BASE { + let (code, msg) = get_code_msg_from_ret(ret); + free_c_ptr(ret as _); + if code > ERR_RUSTDESK_HANDLE_BASE && code < ERR_PLUGIN_HANDLE_BASE { log::debug!( "Plugin {} failed to handle client event, code: {}, msg: {}", id, - ret.code, + code, msg ); let name = match PLUGIN_INFO.read().unwrap().get(id) { @@ -529,7 +529,7 @@ pub fn handle_client_event(id: &str, peer: &str, event: &[u8]) -> Message { None => "???", } .to_owned(); - match ret.code { + match code { ERR_CALL_NOT_SUPPORTED_METHOD => { make_plugin_failure(id, &name, "Plugin method is not supported") } @@ -542,7 +542,7 @@ pub fn handle_client_event(id: &str, peer: &str, event: &[u8]) -> Message { log::error!( "Plugin {} failed to handle client event, code: {}, msg: {}", id, - ret.code, + code, msg ); let msg = make_plugin_request(id, out, out_len);