Example mini_curl: Constructor.

Author: jmjoy

examples/mini-curl/src/lib.rs

@@ -1,14 +1,18 @@
+use curl::easy::Easy;
 use phper::{
     c_str_ptr, php_fn, php_function, php_minfo, php_minfo_function, php_minit, php_minit_function,
     php_mshutdown, php_mshutdown_function, php_rinit, php_rinit_function, php_rshutdown,
     php_rshutdown_function,
-    sys::{php_info_print_table_end, php_info_print_table_start, PHP_INI_SYSTEM},
+    sys::{
+        php_error_docref0, php_info_print_table_end, php_info_print_table_start, E_WARNING,
+        PHP_INI_SYSTEM,
+    },
     zend::{
         api::{FunctionEntries, FunctionEntryBuilder},
-        compile::{create_zend_arg_info, MultiInternalArgInfo},
+        compile::{create_zend_arg_info, MultiInternalArgInfo, Visibility},
         ini::{create_ini_entry, IniEntries},
         modules::{create_zend_module_entry, ModuleArgs, ModuleEntry},
-        types::{ClassEntry, ExecuteData, ReturnValue, SetVal},
+        types::{ClassEntry, ExecuteData, ReturnValue, SetVal, Value},
     },
     zend_get_module,
 };
@@ -23,6 +27,7 @@ static INI_ENTRIES: IniEntries<1> =
 fn module_init(args: ModuleArgs) -> bool {
     args.register_ini_entries(&INI_ENTRIES);
     MINI_CURL_CE.init("MiniCurl", &MINI_CURL_METHODS);
+    MINI_CURL_CE.declare_property("_rust_easy_ptr", 0, Visibility::Private);
     true
 }
 
@@ -69,13 +74,31 @@ static MINI_CURL_METHODS: FunctionEntries<2> = FunctionEntries::new([
 
 #[php_function]
 pub fn mini_curl_construct(execute_data: &mut ExecuteData) -> impl SetVal {
-    match execute_data
-        .parse_parameters_optional("")
-        .map(|_url: &str| {})
-    {
-        Some(_) => ReturnValue::Bool(true),
-        None => ReturnValue::Bool(false),
+    let url = match execute_data.parse_parameters_optional::<&str, _>("") {
+        Some(url) => url,
+        None => return ReturnValue::Bool(false),
+    };
+
+    let this = execute_data.get_this();
+
+    let mut easy = Box::new(Easy::new());
+
+    if !url.is_empty() {
+        if let Err(e) = easy.url(url) {
+            unsafe {
+                php_error_docref0(
+                    null(),
+                    E_WARNING as i32,
+                    format!("curl set failed: {}\0", e).as_ptr().cast(),
+                );
+            }
+            return ReturnValue::Bool(false);
+        }
     }
+
+    MINI_CURL_CE.update_property(this, "_rust_easy_ptr", Box::into_raw(easy) as i64);
+
+    ReturnValue::Null
 }
 
 #[php_function]
@@ -84,6 +107,15 @@ pub fn mini_curl_destruct(execute_data: &mut ExecuteData) -> impl SetVal {
         return ReturnValue::Bool(false);
     }
 
+    let this = execute_data.get_this();
+    let ptr = MINI_CURL_CE.read_property(this, "_rust_easy_ptr");
+    let ptr = ptr.try_into_value().unwrap();
+    if let Value::Long(ptr) = ptr {
+        unsafe {
+            drop(Box::from_raw(ptr as *mut Easy));
+        }
+    }
+
     ReturnValue::Null
 }
 

examples/mini-curl/tests/php/test.php

@@ -4,7 +4,8 @@
 ini_set("display_startup_errors", "On");
 error_reporting(E_ALL);
 
-new MiniCurl("http://httpbin.org/ip");
+$mc = new MiniCurl("http://httpbin.org/ip");
+var_dump($mc);
 
 function assert_eq($left, $right) {
     if ($left !== $right) {

phper-sys/php_wrapper.h

@@ -6,6 +6,8 @@
 #include <ext/standard/info.h>
 #include <zend_exceptions.h>
 
+typedef void (ZEND_FASTCALL *zif_handler)(INTERNAL_FUNCTION_PARAMETERS);
+
 zend_string *zend_string_init_(const char *str, size_t len, int persistent);
 zend_string *zend_new_interned_string_(zend_string *str);
 zend_class_entry phper_init_class_entry_ex(const char *class_name, size_t class_name_len, const zend_function_entry *functions);

phper/src/zend/types.rs

@@ -3,10 +3,11 @@ use crate::{
     sys::{
         self, phper_get_this, phper_init_class_entry_ex, phper_z_strval_p, phper_zval_get_type,
         phper_zval_stringl, zend_class_entry, zend_declare_property_bool,
-        zend_declare_property_null, zend_declare_property_stringl, zend_execute_data, zend_long,
-        zend_parse_parameters, zend_read_property, zend_register_internal_class,
-        zend_throw_exception, zval, IS_DOUBLE, IS_FALSE, IS_LONG, IS_NULL, IS_TRUE,
-        ZEND_RESULT_CODE_SUCCESS,
+        zend_declare_property_long, zend_declare_property_null, zend_declare_property_stringl,
+        zend_execute_data, zend_long, zend_parse_parameters, zend_read_property,
+        zend_register_internal_class, zend_throw_exception, zend_update_property_bool,
+        zend_update_property_long, zend_update_property_null, zend_update_property_stringl, zval,
+        IS_DOUBLE, IS_FALSE, IS_LONG, IS_NULL, IS_TRUE, ZEND_RESULT_CODE_SUCCESS,
     },
     zend::{api::FunctionEntries, compile::Visibility, exceptions::Throwable},
 };
@@ -57,16 +58,24 @@ impl ClassEntry {
     pub fn declare_property(
         &self,
         name: impl AsRef<str>,
-        value: impl DeclareProperty,
+        value: impl HandleProperty,
         access_type: Visibility,
     ) -> bool {
         unsafe {
-            let name = name.as_ref();
-            value.declare_property(self.get(), name, access_type as c_int)
+            value.declare_property(self.get(), name.as_ref(), access_type as c_int)
                 == ZEND_RESULT_CODE_SUCCESS
         }
     }
 
+    pub fn update_property(
+        &self,
+        object: *mut zval,
+        name: impl AsRef<str>,
+        value: impl HandleProperty,
+    ) {
+        unsafe { value.update_property(self.get(), object, name.as_ref()) }
+    }
+
     pub fn read_property(&self, this: *mut zval, name: impl AsRef<str>) -> &mut Val {
         let name = name.as_ref();
         unsafe {
@@ -85,16 +94,18 @@ impl ClassEntry {
 
 unsafe impl Sync for ClassEntry {}
 
-pub trait DeclareProperty {
+pub trait HandleProperty {
     unsafe fn declare_property(
         self,
         ce: *mut zend_class_entry,
         name: &str,
         access_type: c_int,
     ) -> c_int;
+
+    unsafe fn update_property(self, scope: *mut zend_class_entry, object: *mut zval, name: &str);
 }
 
-impl DeclareProperty for () {
+impl HandleProperty for () {
     unsafe fn declare_property(
         self,
         ce: *mut zend_class_entry,
@@ -103,9 +114,13 @@ impl DeclareProperty for () {
     ) -> i32 {
         zend_declare_property_null(ce, name.as_ptr().cast(), name.len(), access_type)
     }
+
+    unsafe fn update_property(self, scope: *mut zend_class_entry, object: *mut zval, name: &str) {
+        zend_update_property_null(scope, object, name.as_ptr().cast(), name.len())
+    }
 }
 
-impl DeclareProperty for bool {
+impl HandleProperty for bool {
     unsafe fn declare_property(
         self,
         ce: *mut zend_class_entry,
@@ -120,9 +135,46 @@ impl DeclareProperty for bool {
             access_type,
         )
     }
+
+    unsafe fn update_property(self, scope: *mut zend_class_entry, object: *mut zval, name: &str) {
+        zend_update_property_bool(
+            scope,
+            object,
+            name.as_ptr().cast(),
+            name.len(),
+            self as zend_long,
+        )
+    }
+}
+
+impl HandleProperty for i64 {
+    unsafe fn declare_property(
+        self,
+        ce: *mut zend_class_entry,
+        name: &str,
+        access_type: i32,
+    ) -> i32 {
+        zend_declare_property_long(
+            ce,
+            name.as_ptr().cast(),
+            name.len(),
+            self as zend_long,
+            access_type,
+        )
+    }
+
+    unsafe fn update_property(self, scope: *mut zend_class_entry, object: *mut zval, name: &str) {
+        zend_update_property_long(
+            scope,
+            object,
+            name.as_ptr().cast(),
+            name.len(),
+            self as zend_long,
+        )
+    }
 }
 
-impl DeclareProperty for &str {
+impl HandleProperty for &str {
     unsafe fn declare_property(
         self,
         ce: *mut zend_class_entry,
@@ -138,6 +190,17 @@ impl DeclareProperty for &str {
             access_type,
         )
     }
+
+    unsafe fn update_property(self, scope: *mut zend_class_entry, object: *mut zval, name: &str) {
+        zend_update_property_stringl(
+            scope,
+            object,
+            name.as_ptr().cast(),
+            name.len(),
+            self.as_ptr().cast(),
+            self.len(),
+        )
+    }
 }
 
 #[repr(transparent)]