feat(alloc): add estrdup

Author: Qard

allowed_bindings.rs

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

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(|| {