mirrors/gst-plugins-rs
mirrors/gst-plugins-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git synced 2024-06-16 21:20:33 +00:00
Code Issues Projects Releases Wiki Activity

Never let panics propagate to C and instead convert them to error messages

Browse source
This commit is contained in:
Sebastian Dröge 2016-09-04 00:27:04 +03:00
parent 95dd469fbf
commit f9adac5f7e
3 changed files with 247 additions and 166 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
src/error.rs
View file

@ -293,3 +293,38 @@ impl Error for UriError {
}
pub type UriValidator = Fn(&Url) -> Result<(), UriError>;
#[derive(Debug)]
pub struct PanicError;
impl ToGError for PanicError {
fn to_gerror(&self) -> (u32, i32) {
(gst_library_error_domain(), 1)
}
}
macro_rules! panic_to_error(
($wrap:expr, $ret:expr, $code:block) => {{
if $wrap.panicked.load(Ordering::Relaxed) {
error_msg!(PanicError, ["Panicked"]).post($wrap.raw);
return $ret;
}
let result = panic::catch_unwind(AssertUnwindSafe(|| $code));
match result {
Ok(result) => result,
Err(err) => {
$wrap.panicked.store(true, Ordering::Relaxed);
if let Some(cause) = err.downcast_ref::<&str>() {
error_msg!(PanicError, ["Panicked: {}", cause]).post($wrap.raw);
} else if let Some(cause) = err.downcast_ref::<String>() {
error_msg!(PanicError, ["Panicked: {}", cause]).post($wrap.raw);
} else {
error_msg!(PanicError, ["Panicked"]).post($wrap.raw);
}
$ret
}
}
}}
);

32
src/rssink.rs
View file

@ -22,7 +22,10 @@ use std::ffi::{CStr, CString};
use std::slice;
use std::ptr;
use std::panic::{self, AssertUnwindSafe};
use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering};
use url::Url;
@ -51,10 +54,11 @@ impl ToGError for SinkError {
}
pub struct SinkWrapper {
sink_raw: *mut c_void,
raw: *mut c_void,
uri: Mutex<(Option<Url>, bool)>,
uri_validator: Box<UriValidator>,
sink: Mutex<Box<Sink>>,
panicked: AtomicBool,
}
pub trait Sink {
@ -67,12 +71,13 @@ pub trait Sink {
}
impl SinkWrapper {
fn new(sink_raw: *mut c_void, sink: Box<Sink>) -> SinkWrapper {
fn new(raw: *mut c_void, sink: Box<Sink>) -> SinkWrapper {
SinkWrapper {
sink_raw: sink_raw,
raw: raw,
uri: Mutex::new((None, false)),
uri_validator: sink.uri_validator(),
sink: Mutex::new(sink),
panicked: AtomicBool::new(false),
}
}
}
@ -95,6 +100,8 @@ pub unsafe extern "C" fn sink_set_uri(ptr: *const SinkWrapper,
cerr: *mut c_void)
-> GBoolean {
let wrap: &SinkWrapper = &*ptr;
panic_to_error!(wrap, GBoolean::False, {
let uri_storage = &mut wrap.uri.lock().unwrap();
if uri_storage.1 {
@ -130,22 +137,28 @@ pub unsafe extern "C" fn sink_set_uri(ptr: *const SinkWrapper,
}
}
}
})
}
#[no_mangle]
pub unsafe extern "C" fn sink_get_uri(ptr: *const SinkWrapper) -> *mut c_char {
let wrap: &SinkWrapper = &*ptr;
panic_to_error!(wrap, ptr::null_mut(), {
let uri_storage = &mut wrap.uri.lock().unwrap();
match uri_storage.0 {
Some(ref uri) => CString::new(uri.as_ref().as_bytes()).unwrap().into_raw(),
None => ptr::null_mut(),
}
})
}
#[no_mangle]
pub unsafe extern "C" fn sink_start(ptr: *const SinkWrapper) -> GBoolean {
let wrap: &SinkWrapper = &*ptr;
panic_to_error!(wrap, GBoolean::False, {
let sink = &mut wrap.sink.lock().unwrap();
let uri = match *wrap.uri.lock().unwrap() {
@ -155,7 +168,7 @@ pub unsafe extern "C" fn sink_start(ptr: *const SinkWrapper) -> GBoolean {
uri.clone()
}
(None, _) => {
error_msg!(SinkError::OpenFailed, ["No URI given"]).post(wrap.sink_raw);
error_msg!(SinkError::OpenFailed, ["No URI given"]).post(wrap.raw);
return GBoolean::False;
}
};
@ -164,15 +177,17 @@ pub unsafe extern "C" fn sink_start(ptr: *const SinkWrapper) -> GBoolean {
Ok(..) => GBoolean::True,
Err(ref msg) => {
wrap.uri.lock().unwrap().1 = false;
msg.post(wrap.sink_raw);
msg.post(wrap.raw);
GBoolean::False
}
}
})
}
#[no_mangle]
pub unsafe extern "C" fn sink_stop(ptr: *const SinkWrapper) -> GBoolean {
let wrap: &SinkWrapper = &*ptr;
panic_to_error!(wrap, GBoolean::False, {
let sink = &mut wrap.sink.lock().unwrap();
match sink.stop() {
@ -181,10 +196,11 @@ pub unsafe extern "C" fn sink_stop(ptr: *const SinkWrapper) -> GBoolean {
GBoolean::True
}
Err(ref msg) => {
msg.post(wrap.sink_raw);
msg.post(wrap.raw);
GBoolean::False
}
}
})
}
#[no_mangle]
@ -193,6 +209,7 @@ pub unsafe extern "C" fn sink_render(ptr: *const SinkWrapper,
data_len: usize)
-> GstFlowReturn {
let wrap: &SinkWrapper = &*ptr;
panic_to_error!(wrap, GstFlowReturn::Error, {
let sink = &mut wrap.sink.lock().unwrap();
let data = slice::from_raw_parts(data_ptr, data_len);
@ -201,10 +218,11 @@ pub unsafe extern "C" fn sink_render(ptr: *const SinkWrapper,
Err(flow_error) => {
match flow_error {
FlowError::NotNegotiated(ref msg) |
FlowError::Error(ref msg) => msg.post(wrap.sink_raw),
FlowError::Error(ref msg) => msg.post(wrap.raw),
_ => (),
}
flow_error.to_native()
}
}
})
}

44
src/rssource.rs
View file

@ -22,7 +22,10 @@ use std::slice;
use std::ptr;
use std::u64;
use std::panic::{self, AssertUnwindSafe};
use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering};
use url::Url;
@ -51,10 +54,11 @@ impl ToGError for SourceError {
}
pub struct SourceWrapper {
source_raw: *mut c_void,
raw: *mut c_void,
uri: Mutex<(Option<Url>, bool)>,
uri_validator: Box<UriValidator>,
source: Mutex<Box<Source>>,
panicked: AtomicBool,
}
pub trait Source {
@ -70,12 +74,13 @@ pub trait Source {
}
impl SourceWrapper {
fn new(source_raw: *mut c_void, source: Box<Source>) -> SourceWrapper {
fn new(raw: *mut c_void, source: Box<Source>) -> SourceWrapper {
SourceWrapper {
source_raw: source_raw,
raw: raw,
uri: Mutex::new((None, false)),
uri_validator: source.uri_validator(),
source: Mutex::new(source),
panicked: AtomicBool::new(false),
}
}
}
@ -98,6 +103,8 @@ pub unsafe extern "C" fn source_set_uri(ptr: *const SourceWrapper,
cerr: *mut c_void)
-> GBoolean {
let wrap: &SourceWrapper = &*ptr;
panic_to_error!(wrap, GBoolean::False, {
let uri_storage = &mut wrap.uri.lock().unwrap();
if uri_storage.1 {
@ -133,41 +140,52 @@ pub unsafe extern "C" fn source_set_uri(ptr: *const SourceWrapper,
}
}
}
})
}
#[no_mangle]
pub unsafe extern "C" fn source_get_uri(ptr: *const SourceWrapper) -> *mut c_char {
let wrap: &SourceWrapper = &*ptr;
panic_to_error!(wrap, ptr::null_mut(), {
let uri_storage = &mut wrap.uri.lock().unwrap();
match uri_storage.0 {
Some(ref uri) => CString::new(uri.as_ref().as_bytes()).unwrap().into_raw(),
None => ptr::null_mut(),
}
})
}
#[no_mangle]
pub unsafe extern "C" fn source_is_seekable(ptr: *const SourceWrapper) -> GBoolean {
let wrap: &SourceWrapper = &*ptr;
panic_to_error!(wrap, GBoolean::False, {
let source = &wrap.source.lock().unwrap();
GBoolean::from_bool(source.is_seekable())
})
}
#[no_mangle]
pub unsafe extern "C" fn source_get_size(ptr: *const SourceWrapper) -> u64 {
let wrap: &SourceWrapper = &*ptr;
panic_to_error!(wrap, u64::MAX, {
let source = &wrap.source.lock().unwrap();
match source.get_size() {
Some(size) => size,
None => u64::MAX,
}
})
}
#[no_mangle]
pub unsafe extern "C" fn source_start(ptr: *const SourceWrapper) -> GBoolean {
let wrap: &SourceWrapper = &*ptr;
panic_to_error!(wrap, GBoolean::False, {
let source = &mut wrap.source.lock().unwrap();
let uri = match *wrap.uri.lock().unwrap() {
@ -177,7 +195,7 @@ pub unsafe extern "C" fn source_start(ptr: *const SourceWrapper) -> GBoolean {
uri.clone()
}
(None, _) => {
error_msg!(SourceError::OpenFailed, ["No URI given"]).post(wrap.source_raw);
error_msg!(SourceError::OpenFailed, ["No URI given"]).post(wrap.raw);
return GBoolean::False;
}
};
@ -186,15 +204,18 @@ pub unsafe extern "C" fn source_start(ptr: *const SourceWrapper) -> GBoolean {
Ok(..) => GBoolean::True,
Err(ref msg) => {
wrap.uri.lock().unwrap().1 = false;
msg.post(wrap.source_raw);
msg.post(wrap.raw);
GBoolean::False
}
}
})
}
#[no_mangle]
pub unsafe extern "C" fn source_stop(ptr: *const SourceWrapper) -> GBoolean {
let wrap: &SourceWrapper = &*ptr;
panic_to_error!(wrap, GBoolean::False, {
let source = &mut wrap.source.lock().unwrap();
match source.stop() {
@ -203,10 +224,11 @@ pub unsafe extern "C" fn source_stop(ptr: *const SourceWrapper) -> GBoolean {
GBoolean::True
}
Err(ref msg) => {
msg.post(wrap.source_raw);
msg.post(wrap.raw);
GBoolean::False
}
}
})
}
#[no_mangle]
@ -216,6 +238,8 @@ pub unsafe extern "C" fn source_fill(ptr: *const SourceWrapper,
data_len_ptr: *mut usize)
-> GstFlowReturn {
let wrap: &SourceWrapper = &*ptr;
panic_to_error!(wrap, GstFlowReturn::Error, {
let source = &mut wrap.source.lock().unwrap();
let mut data_len: &mut usize = &mut *data_len_ptr;
let mut data = slice::from_raw_parts_mut(data_ptr, *data_len);
@ -228,24 +252,28 @@ pub unsafe extern "C" fn source_fill(ptr: *const SourceWrapper,
Err(flow_error) => {
match flow_error {
FlowError::NotNegotiated(ref msg) |
FlowError::Error(ref msg) => msg.post(wrap.source_raw),
FlowError::Error(ref msg) => msg.post(wrap.raw),
_ => (),
}
flow_error.to_native()
}
}
})
}
#[no_mangle]
pub unsafe extern "C" fn source_seek(ptr: *const SourceWrapper, start: u64, stop: u64) -> GBoolean {
let wrap: &SourceWrapper = &*ptr;
panic_to_error!(wrap, GBoolean::False, {
let source = &mut wrap.source.lock().unwrap();
match source.seek(start, if stop == u64::MAX { None } else { Some(stop) }) {
Ok(..) => GBoolean::True,
Err(ref msg) => {
msg.post(wrap.source_raw);
msg.post(wrap.raw);
GBoolean::False
}
}
})
}