mirror/rustdesk
1
0
Fork 0
mirror of https://github.com/rustdesk/rustdesk.git synced 2024-11-28 07:39:36 +08:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Revert "plugin_framework, change return type"

Browse Source 
This reverts commit 9c6b303fa2.
This commit is contained in:
fufesou 2023-05-04 19:21:13 +08:00
parent 9c6b303fa2
commit 1243d8f434
4 changed files with 83 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/plugin/callback_ext.rs
View File

@ -3,6 +3,7 @@
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
use super::*; use super::*;
use std::{ffi::c_void, ptr::null};
const EXT_SUPPORT_BLOCK_INPUT: &str = "block-input"; const EXT_SUPPORT_BLOCK_INPUT: &str = "block-input";
@ -10,7 +11,7 @@ pub(super) fn ext_support_callback(
id: &str, id: &str,
peer: &str, peer: &str,
msg: &super::callback_msg::MsgToExtSupport, msg: &super::callback_msg::MsgToExtSupport,
) -> PluginReturn { ) -> *const c_void {
match &msg.r#type as _ { match &msg.r#type as _ {
EXT_SUPPORT_BLOCK_INPUT => { EXT_SUPPORT_BLOCK_INPUT => {
// let supported_plugins = []; // let supported_plugins = [];
@ -18,25 +19,25 @@ pub(super) fn ext_support_callback(
let supported = true; let supported = true;
if supported { if supported {
if msg.data.len() != 1 { if msg.data.len() != 1 {
return PluginReturn::new( return make_return_code_msg(
errno::ERR_CALLBACK_INVALID_ARGS, errno::ERR_CALLBACK_INVALID_ARGS,
"Invalid data length", "Invalid data length",
); );
} }
let block = msg.data[0] != 0; let block = msg.data[0] != 0;
if crate::server::plugin_block_input(peer, block) == block { if crate::server::plugin_block_input(peer, block) == block {
PluginReturn::success() null()
} else { } else {
PluginReturn::new(errno::ERR_CALLBACK_FAILED, "") make_return_code_msg(errno::ERR_CALLBACK_FAILED, "")
} }
} else { } else {
PluginReturn::new( make_return_code_msg(
errno::ERR_CALLBACK_PLUGIN_ID, errno::ERR_CALLBACK_PLUGIN_ID,
&format!("This operation is not supported for plugin '{}', please contact the RustDesk team for support.", 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, errno::ERR_CALLBACK_TARGET_TYPE,
&format!("Unknown target type '{}'", &msg.r#type), &format!("Unknown target type '{}'", &msg.r#type),
), ),

27
src/plugin/callback_msg.rs
View File

@ -6,6 +6,7 @@ use serde_json;
use std::{ use std::{
collections::HashMap, collections::HashMap,
ffi::{c_char, c_void}, ffi::{c_char, c_void},
ptr::null,
sync::Arc, sync::Arc,
}; };
@ -62,9 +63,11 @@ macro_rules! cb_msg_field {
($field: ident) => { ($field: ident) => {
let $field = match cstr_to_string($field) { let $field = match cstr_to_string($field) {
Err(e) => { Err(e) => {
let msg = format!("Failed to convert {} to string, {}", stringify!($field), e); log::error!("Failed to convert {} to string, {}", stringify!($field), e);
log::error!("{}", &msg); return make_return_code_msg(
return PluginReturn::new(errno::ERR_CALLBACK_INVALID_ARGS, &msg); errno::ERR_CALLBACK_INVALID_ARGS,
&format!("Failed to convert {} to string, {}", stringify!($field), e),
);
} }
Ok(v) => v, Ok(v) => v,
}; };
@ -74,7 +77,7 @@ macro_rules! cb_msg_field {
macro_rules! early_return_value { macro_rules! early_return_value {
($e:expr, $code: ident, $($arg:tt)*) => { ($e:expr, $code: ident, $($arg:tt)*) => {
match $e { match $e {
Err(e) => return PluginReturn::new( Err(e) => return make_return_code_msg(
errno::$code, errno::$code,
&format!("Failed to {} '{}'", format_args!($($arg)*), e), &format!("Failed to {} '{}'", format_args!($($arg)*), e),
), ),
@ -102,7 +105,7 @@ pub(super) extern "C" fn cb_msg(
id: *const c_char, id: *const c_char,
content: *const c_void, content: *const c_void,
len: usize, len: usize,
) -> PluginReturn { ) -> *const c_void {
cb_msg_field!(peer); cb_msg_field!(peer);
cb_msg_field!(target); cb_msg_field!(target);
cb_msg_field!(id); cb_msg_field!(id);
@ -119,9 +122,9 @@ pub(super) extern "C" fn cb_msg(
..Default::default() ..Default::default()
}; };
session.send_plugin_request(request); session.send_plugin_request(request);
PluginReturn::success() null()
} else { } else {
PluginReturn::new( make_return_code_msg(
errno::ERR_CALLBACK_PEER_NOT_FOUND, errno::ERR_CALLBACK_PEER_NOT_FOUND,
&format!("Failed to find session for peer '{}'", peer), &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()) let content = std::string::String::from_utf8(content_slice[2..].to_vec())
.unwrap_or("".to_string()); .unwrap_or("".to_string());
push_event_to_ui(channel, &peer, &content); push_event_to_ui(channel, &peer, &content);
PluginReturn::success() null()
} }
MSG_TO_CONFIG_TARGET => { MSG_TO_CONFIG_TARGET => {
let s = early_return_value!( 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. // No need to set the peer id for location config.
push_option_to_ui(ui.channel, &id, "", &msg, ui); push_option_to_ui(ui.channel, &id, "", &msg, ui);
} }
PluginReturn::success() null()
} }
config::CONFIG_TYPE_PEER => { config::CONFIG_TYPE_PEER => {
let _r = early_return_value!( let _r = early_return_value!(
@ -170,9 +173,9 @@ pub(super) extern "C" fn cb_msg(
if let Some(ui) = &msg.ui { if let Some(ui) = &msg.ui {
push_option_to_ui(ui.channel, &id, &peer, &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, errno::ERR_CALLBACK_TARGET_TYPE,
&format!("Unknown target type '{}'", &msg.r#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) super::callback_ext::ext_support_callback(&id, &peer, &msg)
} }
_ => PluginReturn::new( _ => make_return_code_msg(
errno::ERR_CALLBACK_TARGET, errno::ERR_CALLBACK_TARGET,
&format!("Unknown target '{}'", target), &format!("Unknown target '{}'", target),
), ),

79
src/plugin/mod.rs
View File

@ -1,19 +1,16 @@
use hbb_common::{libc, ResultType}; use hbb_common::{libc, ResultType};
use std::{ use std::ffi::{c_char, c_void, CStr};
ffi::{c_char, c_void, CStr},
ptr::null,
};
mod callback_ext;
mod callback_msg; mod callback_msg;
mod callback_ext;
mod config; mod config;
pub mod desc; pub mod desc;
mod errno; mod errno;
pub mod ipc; pub mod ipc;
pub mod native;
pub mod native_handlers;
mod plog; mod plog;
mod plugins; mod plugins;
pub mod native;
pub mod native_handlers;
pub use plugins::{ pub use plugins::{
handle_client_event, handle_listen_event, handle_server_event, handle_ui_event, load_plugin, 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}; 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] #[inline]
fn cstr_to_string(cstr: *const c_char) -> ResultType<String> { fn cstr_to_string(cstr: *const c_char) -> ResultType<String> {
Ok(String::from_utf8(unsafe { 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] #[inline]
fn free_c_ptr(ret: *mut c_void) { fn free_c_ptr(ret: *mut c_void) {
if !ret.is_null() { if !ret.is_null() {

58
src/plugin/plugins.rs
View File

@ -38,7 +38,7 @@ struct PluginInfo {
/// Return null ptr if success. /// 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. /// 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. /// 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. /// Reset the plugin.
/// ///
/// data: The initialize data. /// data: The initialize data.
@ -46,13 +46,13 @@ type PluginFuncInit = extern "C" fn(data: *const InitData) -> PluginReturn;
/// Return null ptr if success. /// 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. /// 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. /// 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. /// Clear the plugin.
/// ///
/// Return null ptr if success. /// 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. /// 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. /// 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. /// Get the description of the plugin.
/// Return the description. The plugin allocate memory with `libc::malloc` and return the pointer. /// Return the description. The plugin allocate memory with `libc::malloc` and return the pointer.
type PluginFuncDesc = extern "C" fn() -> *const c_char; type PluginFuncDesc = extern "C" fn() -> *const c_char;
@ -74,7 +74,7 @@ type CallbackMsg = extern "C" fn(
id: *const c_char, id: *const c_char,
content: *const c_void, content: *const c_void,
len: usize, len: usize,
) -> PluginReturn; ) -> *const c_void;
/// Callback to get the config. /// Callback to get the config.
/// peer, key are utf8 strings(null terminated). /// peer, key are utf8 strings(null terminated).
/// ///
@ -123,7 +123,7 @@ type PluginFuncClientCall = extern "C" fn(
peer: *const c_char, peer: *const c_char,
args: *const c_void, args: *const c_void,
len: usize, len: usize,
) -> PluginReturn; ) -> *const c_void;
/// The main function of the plugin on the server(remote) side. /// The main function of the plugin on the server(remote) side.
/// ///
/// method: The method. "handle_ui" or "handle_peer" /// method: The method. "handle_ui" or "handle_peer"
@ -144,7 +144,7 @@ type PluginFuncServerCall = extern "C" fn(
len: usize, len: usize,
out: *mut *mut c_void, out: *mut *mut c_void,
out_len: *mut usize, out_len: *mut usize,
) -> PluginReturn; ) -> *const c_void;
/// The plugin callbacks. /// The plugin callbacks.
/// msg: The callback to send message to peer or ui. /// 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<()> { fn init(&self, data: &InitData, path: &str) -> ResultType<()> {
let init_ret = (self.init)(data as _); let init_ret = (self.init)(data as _);
if !init_ret.is_success() { if !init_ret.is_null() {
let msg = cstr_to_string(init_ret.msg).unwrap_or_default(); let (code, msg) = get_code_msg_from_ret(init_ret);
free_c_ptr(init_ret.msg as _); free_c_ptr(init_ret as _);
bail!( bail!(
"Failed to init plugin {}, code: {}, msg: {}", "Failed to init plugin {}, code: {}, msg: {}",
path, path,
init_ret.code, code,
msg msg
); );
} }
@ -238,13 +238,13 @@ macro_rules! make_plugin {
fn clear(&self, id: &str) { fn clear(&self, id: &str) {
let clear_ret = (self.clear)(); let clear_ret = (self.clear)();
if !clear_ret.is_success() { if !clear_ret.is_null() {
let msg = cstr_to_string(clear_ret.msg).unwrap_or_default(); let (code, msg) = get_code_msg_from_ret(clear_ret);
free_c_ptr(clear_ret.msg as _); free_c_ptr(clear_ret as _);
log::error!( log::error!(
"Failed to clear plugin {}, code: {}, msg: {}", "Failed to clear plugin {}, code: {}, msg: {}",
id, id,
clear_ret.code, code,
msg msg
); );
} }
@ -413,16 +413,16 @@ fn handle_event(method: &[u8], id: &str, peer: &str, event: &[u8]) -> ResultType
event.as_ptr() as _, event.as_ptr() as _,
event.len(), event.len(),
); );
if ret.is_success() { if ret.is_null() {
Ok(()) Ok(())
} else { } else {
let msg = cstr_to_string(ret.msg).unwrap_or_default(); let (code, msg) = get_code_msg_from_ret(ret);
free_c_ptr(ret.msg as _); free_c_ptr(ret as _);
bail!( bail!(
"Failed to handle plugin event, id: {}, method: {}, code: {}, msg: {}", "Failed to handle plugin event, id: {}, method: {}, code: {}, msg: {}",
id, id,
std::string::String::from_utf8(method.to_vec()).unwrap_or_default(), std::string::String::from_utf8(method.to_vec()).unwrap_or_default(),
ret.code, code,
msg msg
); );
} }
@ -469,14 +469,14 @@ fn _handle_listen_event(event: String, peer: String) {
evt_bytes.as_ptr() as _, evt_bytes.as_ptr() as _,
evt_bytes.len(), evt_bytes.len(),
); );
if !ret.is_success() { if !ret.is_null() {
let msg = cstr_to_string(ret.msg).unwrap_or_default(); let (code, msg) = get_code_msg_from_ret(ret);
free_c_ptr(ret.msg as _); free_c_ptr(ret as _);
log::error!( log::error!(
"Failed to handle plugin listen event, id: {}, event: {}, code: {}, msg: {}", "Failed to handle plugin listen event, id: {}, event: {}, code: {}, msg: {}",
id, id,
event, event,
ret.code, code,
msg msg
); );
} }
@ -510,18 +510,18 @@ pub fn handle_client_event(id: &str, peer: &str, event: &[u8]) -> Message {
&mut out as _, &mut out as _,
&mut out_len as _, &mut out_len as _,
); );
if ret.is_success() { if ret.is_null() {
let msg = make_plugin_request(id, out, out_len); let msg = make_plugin_request(id, out, out_len);
free_c_ptr(out as _); free_c_ptr(out as _);
msg msg
} else { } else {
let msg = cstr_to_string(ret.msg).unwrap_or_default(); let (code, msg) = get_code_msg_from_ret(ret);
free_c_ptr(ret.msg as _); free_c_ptr(ret as _);
if ret.code > ERR_RUSTDESK_HANDLE_BASE && ret.code < ERR_PLUGIN_HANDLE_BASE { if code > ERR_RUSTDESK_HANDLE_BASE && code < ERR_PLUGIN_HANDLE_BASE {
log::debug!( log::debug!(
"Plugin {} failed to handle client event, code: {}, msg: {}", "Plugin {} failed to handle client event, code: {}, msg: {}",
id, id,
ret.code, code,
msg msg
); );
let name = match PLUGIN_INFO.read().unwrap().get(id) { 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 => "???", None => "???",
} }
.to_owned(); .to_owned();
match ret.code { match code {
ERR_CALL_NOT_SUPPORTED_METHOD => { ERR_CALL_NOT_SUPPORTED_METHOD => {
make_plugin_failure(id, &name, "Plugin method is not supported") 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!( log::error!(
"Plugin {} failed to handle client event, code: {}, msg: {}", "Plugin {} failed to handle client event, code: {}, msg: {}",
id, id,
ret.code, code,
msg msg
); );
let msg = make_plugin_request(id, out, out_len); let msg = make_plugin_request(id, out, out_len);