feat(sapi): add global module handling

Author: joelwurtz

Dockerfile

@@ -0,0 +1,12 @@
+FROM php:zts-bullseye
+
+# Install rust
+RUN apt-get update && apt-get install -y curl clang
+
+# Add app user with uid 1000
+RUN useradd -m -u 1000 app
+USER app
+
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+
+ENV PATH="/home/app/.cargo/bin:${PATH}"

allowed_bindings.rs

@@ -307,6 +307,7 @@ bind! {
     _zend_bailout,
     sapi_startup,
     sapi_shutdown,
+    sapi_module,
     php_module_startup,
     php_module_shutdown,
     php_request_startup,

src/embed/mod.rs

@@ -16,12 +16,11 @@ use crate::ffi::{
 };
 use crate::types::{ZendObject, Zval};
 use crate::zend::{panic_wrapper, try_catch, ExecutorGlobals};
-use parking_lot::{const_rwlock, RwLock};
+use parking_lot::{const_mutex, Mutex};
 use std::ffi::{c_char, c_void, CString, NulError};
 use std::panic::{resume_unwind, RefUnwindSafe};
 use std::path::Path;
 use std::ptr::null_mut;
-
 pub use ffi::ext_php_rs_sapi_startup;
 pub use sapi::SapiModule;
 
@@ -43,8 +42,6 @@ impl EmbedError {
     }
 }
 
-static RUN_FN_LOCK: RwLock<()> = const_rwlock(());
-
 impl Embed {
     /// Run a php script from a file
     ///
@@ -135,7 +132,11 @@ impl Embed {
         // 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();
+        let _guard = {
+            static RUN_FN_LOCK: Mutex<()> = const_mutex(());
+
+            RUN_FN_LOCK.lock()
+        };
 
         let panic = unsafe {
             ext_php_rs_embed_callback(
@@ -206,6 +207,7 @@ impl Embed {
 
 #[cfg(test)]
 mod tests {
+    use crate::ffi::sapi_module;
     use super::Embed;
 
     #[test]

src/embed/sapi.rs

@@ -1,15 +1,56 @@
 //! Builder and objects for creating modules in PHP. A module is the base of a
 //! PHP extension.
 
-use crate::ffi::sapi_module_struct;
+use crate::ffi::{sapi_module, sapi_module_struct};
 
 /// A Zend module entry, also known as an extension.
 pub type SapiModule = sapi_module_struct;
 
+pub fn set_global_module(module: SapiModule) {
+    // leak the module to the global scope
+    let module = Box::leak(Box::new(module));
+
+    unsafe {
+        sapi_module = *module;
+    }
+}
+
+pub fn get_global_module() -> Option<&'static SapiModule> {
+    let module = unsafe { &*&raw const sapi_module };
+
+    if module.name.is_null() {
+        return None;
+    }
+
+    Some(module)
+}
+
 impl SapiModule {
     /// Allocates the module entry on the heap, returning a pointer to the
     /// memory location. The caller is responsible for the memory pointed to.
     pub fn into_raw(self) -> *mut Self {
         Box::into_raw(Box::new(self))
     }
+
+    pub fn name(&self) -> &str {
+        unsafe { std::ffi::CStr::from_ptr(self.name).to_str().unwrap() }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::embed::Embed;
+    use super::*;
+
+    #[test]
+    fn test_get_global_module() {
+        Embed::run(|| {
+            let module = get_global_module();
+
+            assert!(module.is_some());
+            let module = module.unwrap();
+
+            assert_eq!(module.name(), "embed");
+        })
+    }
 }

src/zend/try_catch.rs

@@ -105,7 +105,7 @@ pub unsafe fn bailout() -> ! {
 #[cfg(feature = "embed")]
 #[cfg(test)]
 mod tests {
-    use crate::embed::Embed;
+    use crate::embed::{ext_php_rs_sapi_startup, Embed};
     use crate::zend::{bailout, try_catch};
     use std::ptr::null_mut;
 
@@ -179,20 +179,22 @@ mod tests {
 
     #[test]
     fn test_memory_leak() {
-        let mut ptr = null_mut();
+        Embed::run(|| {
+            let mut ptr = null_mut();
 
-        let _ = try_catch(|| {
-            let mut result = "foo".to_string();
-            ptr = &mut result;
+            let _ = try_catch(|| {
+                let mut result = "foo".to_string();
+                ptr = &mut result;
 
-            unsafe {
-                bailout();
-            }
-        });
+                unsafe {
+                    bailout();
+                }
+            });
 
-        // Check that the string is never released
-        let result = unsafe { &*ptr as &str };
+            // Check that the string is never released
+            let result = unsafe { &*ptr as &str };
 
-        assert_eq!(result, "foo");
+            assert_eq!(result, "foo");
+        });
     }
 }