feat(zend): add helper for try catch and bailout in PHP

Author: joelwurtz

build.rs

@@ -248,6 +248,8 @@ fn main() -> Result<()> {
     for path in [
         manifest.join("src").join("wrapper.h"),
         manifest.join("src").join("wrapper.c"),
+        manifest.join("src").join("embed").join("embed.h"),
+        manifest.join("src").join("embed").join("embed.c"),
         manifest.join("allowed_bindings.rs"),
         manifest.join("windows_build.rs"),
         manifest.join("unix_build.rs"),

src/embed/embed.c

@@ -3,7 +3,7 @@
 // We actually use the PHP embed API to run PHP code in test
 // At some point we might want to use our own SAPI to do that
 void* ext_php_rs_embed_callback(int argc, char** argv, void* (*callback)(void *), void *ctx) {
-  void *result;
+  void *result = NULL;
 
   PHP_EMBED_START_BLOCK(argc, argv)
 

src/embed/ffi.rs

@@ -10,7 +10,7 @@ extern "C" {
     pub fn ext_php_rs_embed_callback(
         argc: c_int,
         argv: *mut *mut c_char,
-        func: unsafe extern "C" fn(*const c_void) -> *mut c_void,
+        func: unsafe extern "C" fn(*const c_void) -> *const c_void,
         ctx: *const c_void,
     ) -> *mut c_void;
 }

src/embed/mod.rs

@@ -13,10 +13,10 @@ use crate::ffi::{
     zend_stream_init_filename, ZEND_RESULT_CODE_SUCCESS,
 };
 use crate::types::{ZendObject, Zval};
-use crate::zend::ExecutorGlobals;
+use crate::zend::{panic_wrapper, ExecutorGlobals};
 use parking_lot::{const_rwlock, RwLock};
 use std::ffi::{c_char, c_void, CString, NulError};
-use std::panic::{catch_unwind, resume_unwind, RefUnwindSafe};
+use std::panic::{resume_unwind, RefUnwindSafe};
 use std::path::Path;
 use std::ptr::null_mut;
 
@@ -93,6 +93,12 @@ impl Embed {
     /// Which means subsequent calls to `Embed::eval` or `Embed::run_script` will be able to access
     /// variables defined in previous calls
     ///
+    /// # Returns
+    ///
+    /// * R - The result of the function passed to this method
+    ///
+    /// R must implement [`Default`] so it can be returned in case of a bailout
+    ///
     /// # Example
     ///
     /// ```
@@ -105,41 +111,36 @@ impl Embed {
     ///    assert_eq!(foo.unwrap().string().unwrap(), "foo");
     /// });
     /// ```
-    pub fn run<F: Fn() + RefUnwindSafe>(func: F) {
+    pub fn run<R, F: Fn() -> R + RefUnwindSafe>(func: F) -> R
+    where
+        R: Default,
+    {
         // @TODO handle php thread safe
         //
         // This is to prevent multiple threads from running php at the same time
         // At some point we should detect if php is compiled with thread safety and avoid doing that in this case
         let _guard = RUN_FN_LOCK.write();
 
-        unsafe extern "C" fn wrapper<F: Fn() + RefUnwindSafe>(ctx: *const c_void) -> *mut c_void {
-            // we try to catch panic here so we correctly shutdown php if it happens
-            // mandatory when we do assert on test as other test would not run correctly
-            let panic = catch_unwind(|| {
-                (*(ctx as *const F))();
-            });
-
-            let panic_ptr = Box::into_raw(Box::new(panic));
-
-            panic_ptr as *mut c_void
-        }
-
         let panic = unsafe {
             ext_php_rs_embed_callback(
                 0,
                 null_mut(),
-                wrapper::<F>,
+                panic_wrapper::<R, F>,
                 &func as *const F as *const c_void,
             )
         };
 
+        // This can happen if there is a bailout
         if panic.is_null() {
-            return;
+            return R::default();
         }
 
-        if let Err(err) = unsafe { *Box::from_raw(panic as *mut std::thread::Result<()>) } {
-            // we resume the panic here so it can be catched correctly by the test framework
-            resume_unwind(err);
+        match unsafe { *Box::from_raw(panic as *mut std::thread::Result<R>) } {
+            Ok(r) => r,
+            Err(err) => {
+                // we resume the panic here so it can be catched correctly by the test framework
+                resume_unwind(err);
+            }
         }
     }
 
@@ -244,4 +245,13 @@ mod tests {
             panic!("test panic");
         });
     }
+
+    #[test]
+    fn test_return() {
+        let foo = Embed::run(|| {
+            return "foo";
+        });
+
+        assert_eq!(foo, "foo");
+    }
 }

src/ffi.rs

@@ -26,6 +26,12 @@ extern "C" {
     pub fn ext_php_rs_zend_object_alloc(obj_size: usize, ce: *mut zend_class_entry) -> *mut c_void;
     pub fn ext_php_rs_zend_object_release(obj: *mut zend_object);
     pub fn ext_php_rs_executor_globals() -> *mut zend_executor_globals;
+    pub fn ext_php_rs_zend_try_catch(
+        func: unsafe extern "C" fn(*const c_void) -> *const c_void,
+        ctx: *const c_void,
+        result: *mut *mut c_void,
+    ) -> bool;
+    pub fn ext_php_rs_zend_bailout();
 }
 
 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

src/wrapper.c

@@ -39,3 +39,17 @@ zend_executor_globals *ext_php_rs_executor_globals() {
   return &executor_globals;
 #endif
 }
+
+bool ext_php_rs_zend_try_catch(void* (*callback)(void *), void *ctx, void **result) {
+  zend_try {
+    *result = callback(ctx);
+  } zend_catch {
+    return true;
+  } zend_end_try();
+
+  return false;
+}
+
+void ext_php_rs_zend_bailout() {
+  zend_bailout();
+}

src/wrapper.h

@@ -30,4 +30,6 @@ void ext_php_rs_set_known_valid_utf8(zend_string *zs);
 const char *ext_php_rs_php_build_id();
 void *ext_php_rs_zend_object_alloc(size_t obj_size, zend_class_entry *ce);
 void ext_php_rs_zend_object_release(zend_object *obj);
-zend_executor_globals *ext_php_rs_executor_globals();
+zend_executor_globals *ext_php_rs_executor_globals();
+bool ext_php_rs_zend_try_catch(void* (*callback)(void *), void *ctx, void **result);
+void ext_php_rs_zend_bailout();

src/zend/mod.rs

@@ -9,6 +9,7 @@ mod globals;
 mod handlers;
 mod ini_entry_def;
 mod module;
+mod try_catch;
 
 use crate::{error::Result, ffi::php_printf};
 use std::ffi::CString;
@@ -22,6 +23,8 @@ pub use globals::ExecutorGlobals;
 pub use handlers::ZendObjectHandlers;
 pub use ini_entry_def::IniEntryDef;
 pub use module::ModuleEntry;
+pub(crate) use try_catch::panic_wrapper;
+pub use try_catch::{bailout, try_catch};
 
 // Used as the format string for `php_printf`.
 const FORMAT_STR: &[u8] = b"%s\0";

src/zend/try_catch.rs

@@ -0,0 +1,126 @@
+use crate::ffi::{ext_php_rs_zend_bailout, ext_php_rs_zend_try_catch};
+use std::ffi::c_void;
+use std::panic::{catch_unwind, resume_unwind, RefUnwindSafe};
+use std::ptr::null_mut;
+
+#[derive(Debug)]
+pub struct CatchError;
+
+pub(crate) unsafe extern "C" fn panic_wrapper<R, F: Fn() -> R + RefUnwindSafe>(
+    ctx: *const c_void,
+) -> *const c_void {
+    // we try to catch panic here so we correctly shutdown php if it happens
+    // mandatory when we do assert on test as other test would not run correctly
+    let panic = catch_unwind(|| (*(ctx as *const F))());
+
+    Box::into_raw(Box::new(panic)) as *mut c_void
+}
+
+/// PHP propose a try catch mechanism in C using setjmp and longjmp (bailout)
+/// It store the arg of setjmp into the bailout field of the global executor
+/// If a bailout is triggered, the executor will jump to the setjmp and restore the previous setjmp
+///
+/// try_catch allow to use this mechanism
+///
+/// # Returns
+///
+/// * `Ok(R)` - The result of the function
+/// * `Err(CatchError)` - A bailout occurred during the execution
+pub fn try_catch<R, F: Fn() -> R + RefUnwindSafe>(func: F) -> Result<R, CatchError> {
+    let mut panic_ptr = null_mut();
+    let has_bailout = unsafe {
+        ext_php_rs_zend_try_catch(
+            panic_wrapper::<R, F>,
+            &func as *const F as *const c_void,
+            (&mut panic_ptr) as *mut *mut c_void,
+        )
+    };
+
+    let panic = panic_ptr as *mut std::thread::Result<R>;
+
+    // can be null if there is a bailout
+    if panic.is_null() || has_bailout {
+        return Err(CatchError);
+    }
+
+    match unsafe { *Box::from_raw(panic as *mut std::thread::Result<R>) } {
+        Ok(r) => Ok(r),
+        Err(err) => {
+            // we resume the panic here so it can be catched correctly by the test framework
+            resume_unwind(err);
+        }
+    }
+}
+
+/// Trigger a bailout
+///
+/// This function will stop the execution of the current script
+/// and jump to the last try catch block
+pub fn bailout() {
+    unsafe {
+        ext_php_rs_zend_bailout();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::embed::Embed;
+    use crate::zend::{bailout, try_catch};
+
+    #[test]
+    fn test_catch() {
+        Embed::run(|| {
+            let catch = try_catch(|| {
+                bailout();
+                assert!(false);
+            });
+
+            assert!(catch.is_err());
+        });
+    }
+
+    #[test]
+    fn test_no_catch() {
+        Embed::run(|| {
+            let catch = try_catch(|| {
+                assert!(true);
+            });
+
+            assert!(catch.is_ok());
+        });
+    }
+
+    #[test]
+    fn test_bailout() {
+        Embed::run(|| {
+            bailout();
+
+            assert!(false);
+        });
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_panic() {
+        Embed::run(|| {
+            let _ = try_catch(|| {
+                panic!("should panic");
+            });
+        });
+    }
+
+    #[test]
+    fn test_return() {
+        let foo = Embed::run(|| {
+            let result = try_catch(|| {
+                return "foo";
+            });
+
+            assert!(result.is_ok());
+
+            result.unwrap()
+        });
+
+        assert_eq!(foo, "foo");
+    }
+}