mirror/rustdesk
1
0
Fork 0
mirror of https://github.com/rustdesk/rustdesk.git synced 2024-12-01 01:29:02 +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 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),
),

27
src/plugin/callback_msg.rs
View File

@ -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),
),

79
src/plugin/mod.rs
View File

@ -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<String> {
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() {

58
src/plugin/plugins.rs
View File

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