feat(alloc): add estrdup

Author: Qard

allowed_bindings.rs

@@ -27,6 +27,7 @@ bind! {
     _call_user_function_impl,
     _efree,
     _emalloc,
+    _estrdup,
     _zend_executor_globals,
     _sapi_globals_struct,
     _sapi_module_struct,

docsrs_bindings.rs

@@ -204,11 +204,11 @@ pub type __uid_t = ::std::os::raw::c_uint;
 pub type __gid_t = ::std::os::raw::c_uint;
 pub type __ino_t = ::std::os::raw::c_ulong;
 pub type __mode_t = ::std::os::raw::c_uint;
-pub type __nlink_t = ::std::os::raw::c_ulong;
+pub type __nlink_t = ::std::os::raw::c_uint;
 pub type __off_t = ::std::os::raw::c_long;
 pub type __off64_t = ::std::os::raw::c_long;
 pub type __time_t = ::std::os::raw::c_long;
-pub type __blksize_t = ::std::os::raw::c_long;
+pub type __blksize_t = ::std::os::raw::c_int;
 pub type __blkcnt_t = ::std::os::raw::c_long;
 pub type __syscall_slong_t = ::std::os::raw::c_long;
 pub type gid_t = __gid_t;
@@ -490,6 +490,15 @@ extern "C" {
         __zend_orig_lineno: u32,
     );
 }
+extern "C" {
+    pub fn _estrdup(
+        s: *const ::std::os::raw::c_char,
+        __zend_filename: *const ::std::os::raw::c_char,
+        __zend_lineno: u32,
+        __zend_orig_filename: *const ::std::os::raw::c_char,
+        __zend_orig_lineno: u32,
+    ) -> *mut ::std::os::raw::c_char;
+}
 extern "C" {
     pub fn __zend_malloc(len: usize) -> *mut ::std::os::raw::c_void;
 }
@@ -768,19 +777,20 @@ pub type zend_class_arrayaccess_funcs = _zend_class_arrayaccess_funcs;
 pub struct stat {
     pub st_dev: __dev_t,
     pub st_ino: __ino_t,
-    pub st_nlink: __nlink_t,
     pub st_mode: __mode_t,
+    pub st_nlink: __nlink_t,
     pub st_uid: __uid_t,
     pub st_gid: __gid_t,
-    pub __pad0: ::std::os::raw::c_int,
     pub st_rdev: __dev_t,
+    pub __pad1: __dev_t,
     pub st_size: __off_t,
     pub st_blksize: __blksize_t,
+    pub __pad2: ::std::os::raw::c_int,
     pub st_blocks: __blkcnt_t,
     pub st_atim: timespec,
     pub st_mtim: timespec,
     pub st_ctim: timespec,
-    pub __glibc_reserved: [__syscall_slong_t; 3usize],
+    pub __glibc_reserved: [::std::os::raw::c_int; 2usize],
 }
 pub type zend_stream_fsizer_t =
     ::std::option::Option<unsafe extern "C" fn(handle: *mut ::std::os::raw::c_void) -> usize>;
@@ -1420,7 +1430,7 @@ pub struct _zend_execute_data {
     pub run_time_cache: *mut *mut ::std::os::raw::c_void,
     pub extra_named_params: *mut zend_array,
 }
-pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
+pub type __jmp_buf = [::std::os::raw::c_ulonglong; 22usize];
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct __jmp_buf_tag {

src/alloc.rs

@@ -3,8 +3,11 @@
 
 use cfg_if::cfg_if;
 
-use crate::ffi::{_efree, _emalloc};
-use std::{alloc::Layout, ffi::c_void};
+use crate::ffi::{_efree, _emalloc, _estrdup};
+use std::{
+    alloc::Layout,
+    ffi::{c_char, c_void, CString},
+};
 
 /// Uses the PHP memory allocator to allocate request-bound memory.
 ///
@@ -62,3 +65,66 @@ pub unsafe fn efree(ptr: *mut u8) {
         }
     }
 }
+
+/// Duplicates a string using the PHP memory manager.
+///
+/// # Parameters
+///
+/// * `string` - The string to duplicate, which can be any type that can be
+///   converted into a `Vec<u8>`.
+///
+/// # Returns
+///
+/// A pointer to the duplicated string in the PHP memory manager.
+pub fn estrdup(string: impl Into<Vec<u8>>) -> *mut c_char {
+    let string = unsafe { CString::from_vec_unchecked(string.into()) }.into_raw();
+
+    let result = unsafe {
+        #[cfg(php_debug)]
+        {
+            _estrdup(string, std::ptr::null_mut(), 0, std::ptr::null_mut(), 0)
+        }
+        #[cfg(not(php_debug))]
+        {
+            _estrdup(string)
+        }
+    };
+
+    drop(unsafe { CString::from_raw(string) });
+    result
+}
+
+#[cfg(test)]
+#[cfg(feature = "embed")]
+mod test {
+    use super::*;
+    use crate::embed::Embed;
+    use std::ffi::CStr;
+
+    #[test]
+    fn test_emalloc() {
+        Embed::run(|| {
+            let layout = Layout::from_size_align(16, 8).expect("should create layout");
+            let ptr = emalloc(layout);
+            assert!(!ptr.is_null());
+            unsafe { efree(ptr) };
+        });
+    }
+
+    #[test]
+    fn test_estrdup() {
+        Embed::run(|| {
+            let original = "Hello, world!";
+            let duplicated = estrdup(original);
+            assert!(!duplicated.is_null());
+
+            let duplicated_str = unsafe { CStr::from_ptr(duplicated) };
+            assert_eq!(
+                duplicated_str.to_str().expect("should convert to str"),
+                original
+            );
+
+            unsafe { efree(duplicated.cast::<u8>()) }
+        });
+    }
+}

src/exception.rs

@@ -342,6 +342,7 @@ mod tests {
         });
     }
 
+    #[cfg(feature = "anyhow")]
     #[test]
     fn test_from_anyhow() {
         Embed::run(|| {