feat(sapi): add initial work on having it's own sapi

Author: joelwurtz

allowed_bindings.rs

@@ -260,7 +260,15 @@ bind! {
     zend_eval_string,
     zend_file_handle,
     zend_stream_init_filename,
+    zend_destroy_file_handle,
     php_execute_script,
     zend_register_module_ex,
-    _zend_bailout
+    _zend_bailout,
+    sapi_module_struct,
+    sapi_startup,
+    sapi_shutdown,
+    php_module_startup,
+    php_module_shutdown,
+    php_request_startup,
+    php_request_shutdown
 }

src/builders/mod.rs

@@ -4,7 +4,11 @@
 mod class;
 mod function;
 mod module;
+#[cfg(feature = "embed")]
+mod sapi;
 
 pub use class::ClassBuilder;
 pub use function::FunctionBuilder;
 pub use module::ModuleBuilder;
+#[cfg(feature = "embed")]
+pub use sapi::SapiBuilder;

src/builders/sapi.rs

@@ -0,0 +1,88 @@
+use crate::ffi::sapi_header_struct;
+use crate::{embed::SapiModule, error::Result};
+
+use std::ffi::c_void;
+use std::{ffi::CString, ptr};
+
+pub struct SapiBuilder {
+    name: String,
+    pretty_name: String,
+    module: SapiModule,
+}
+
+impl SapiBuilder {
+    pub fn new<T: Into<String>, U: Into<String>>(name: T, pretty_name: U) -> Self {
+        Self {
+            name: name.into(),
+            pretty_name: pretty_name.into(),
+            module: SapiModule {
+                name: ptr::null_mut(),
+                pretty_name: ptr::null_mut(),
+                startup: None,
+                shutdown: None,
+                activate: None,
+                deactivate: None,
+                ub_write: None,
+                flush: None,
+                get_stat: None,
+                getenv: None,
+                sapi_error: None,
+                header_handler: None,
+                send_headers: None,
+                send_header: None,
+                read_post: None,
+                read_cookies: None,
+                register_server_variables: None,
+                log_message: None,
+                get_request_time: None,
+                terminate_process: None,
+                php_ini_path_override: ptr::null_mut(),
+                default_post_reader: None,
+                treat_data: None,
+                executable_location: ptr::null_mut(),
+                php_ini_ignore: 0,
+                php_ini_ignore_cwd: 0,
+                get_fd: None,
+                force_http_10: None,
+                get_target_uid: None,
+                get_target_gid: None,
+                input_filter: None,
+                ini_defaults: None,
+                phpinfo_as_text: 0,
+                ini_entries: ptr::null_mut(),
+                additional_functions: ptr::null(),
+                input_filter_init: None,
+            },
+        }
+    }
+
+    /// Sets the send header function for this SAPI
+    ///
+    /// # Arguments
+    ///
+    /// * `func` - The function to be called on shutdown.
+    pub fn send_header_function(mut self, func: SapiSendHeaderFunc) -> Self {
+        self.module.send_header = Some(func);
+        self
+    }
+
+    /// Builds the extension and returns a `SapiModule`.
+    ///
+    /// Returns a result containing the sapi module if successful.
+    pub fn build(mut self) -> Result<SapiModule> {
+        self.module.name = CString::new(self.name)?.into_raw();
+        self.module.pretty_name = CString::new(self.pretty_name)?.into_raw();
+
+        if self.module.send_header.is_none() {
+            self.module.send_header = Some(dummy_send_header);
+        }
+
+        Ok(self.module)
+    }
+}
+
+/// A function to be called when the extension is starting up or shutting down.
+pub type SapiSendHeaderFunc =
+    extern "C" fn(header: *mut sapi_header_struct, server_context: *mut c_void);
+
+extern "C" fn dummy_send_header(_header: *mut sapi_header_struct, _server_context: *mut c_void) {}

src/embed/embed.c

@@ -13,3 +13,18 @@ void* ext_php_rs_embed_callback(int argc, char** argv, void* (*callback)(void *)
 
   return result;
 }
+
+void ext_php_rs_sapi_startup() {
+  #if defined(SIGPIPE) && defined(SIG_IGN)
+    signal(SIGPIPE, SIG_IGN);
+  #endif
+
+  #ifdef ZTS
+    php_tsrm_startup();
+    #ifdef PHP_WIN32
+      ZEND_TSRMLS_CACHE_UPDATE();
+    #endif
+  #endif
+
+  zend_signal_startup();
+}

src/embed/embed.h

@@ -2,3 +2,5 @@
 #include "sapi/embed/php_embed.h"
 
 void* ext_php_rs_embed_callback(int argc, char** argv, void* (*callback)(void *), void *ctx);
+
+void ext_php_rs_sapi_startup();

src/embed/ffi.rs

@@ -13,4 +13,6 @@ extern "C" {
         func: unsafe extern "C" fn(*const c_void) -> *const c_void,
         ctx: *const c_void,
     ) -> *mut c_void;
+
+    pub fn ext_php_rs_sapi_startup();
 }

src/embed/mod.rs

@@ -5,6 +5,7 @@
 //! You should only use this crate for test purpose, it's not production ready
 
 mod ffi;
+mod sapi;
 
 use crate::boxed::ZBox;
 use crate::embed::ffi::ext_php_rs_embed_callback;
@@ -20,6 +21,9 @@ 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;
+
 pub struct Embed;
 
 #[derive(Debug)]
@@ -86,7 +90,7 @@ impl Embed {
             zend_stream_init_filename(&mut file_handle, path.as_ptr());
         }
 
-        let exec_result = try_catch(|| unsafe { php_execute_script(&mut file_handle) });
+        let exec_result = try_catch(|| unsafe { php_execute_script(&mut file_handle) }, false);
 
         match exec_result {
             Err(_) => Err(EmbedError::CatchError),
@@ -180,13 +184,16 @@ impl Embed {
 
         let mut result = Zval::new();
 
-        let exec_result = try_catch(|| unsafe {
-            zend_eval_string(
-                cstr.as_ptr() as *const c_char,
-                &mut result,
-                b"run\0".as_ptr() as *const _,
-            )
-        });
+        let exec_result = try_catch(
+            || unsafe {
+                zend_eval_string(
+                    cstr.as_ptr() as *const c_char,
+                    &mut result,
+                    b"run\0".as_ptr() as *const _,
+                )
+            },
+            false,
+        );
 
         match exec_result {
             Err(_) => Err(EmbedError::CatchError),

src/embed/sapi.rs

@@ -0,0 +1,15 @@
+//! Builder and objects for creating modules in PHP. A module is the base of a
+//! PHP extension.
+
+use crate::ffi::sapi_module_struct;
+
+/// A Zend module entry, also known as an extension.
+pub type SapiModule = sapi_module_struct;
+
+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))
+    }
+}

src/ffi.rs

@@ -26,11 +26,19 @@ 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_first_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() -> !;
 }
 

src/wrapper.c

@@ -50,6 +50,16 @@ bool ext_php_rs_zend_try_catch(void* (*callback)(void *), void *ctx, void **resu
   return false;
 }
 
+bool ext_php_rs_zend_first_try_catch(void* (*callback)(void *), void *ctx, void **result) {
+  zend_first_try {
+    *result = callback(ctx);
+  } zend_catch {
+    return true;
+  } zend_end_try();
+
+  return false;
+}
+
 void ext_php_rs_zend_bailout() {
   zend_bailout();
 }