Convert resource to object in Sysvshm extension

Author: kocsismate

UPGRADING

@@ -421,6 +421,12 @@ PHP 8.0 UPGRADE NOTES
     Return value checks using is_resource() should be replaced with checks
     for `false`.
 
+- Sysvshm:
+  . shm_attach() will now return an Sysvshm object rather than a resource.
+    Return value checks using is_resource() should be replaced with checks
+    for `false`. The shm_detach() function no longer has an effect, instead
+    the Sysvshm instance is automatically destroyed if it is no longer referenced.
+
 - tidy:
   . The $use_include_path parameter, which was not used internally, has been
     removed from tidy_repair_string().

ext/sysvsem/tests/sysv.phpt

@@ -29,13 +29,13 @@ if (! sem_acquire($sem_id)) {
 }
 echo "Success acquire semaphore.\n";
 
-$shm_id =   shm_attach($SHMKEY, $MEMSIZE);
+$shm_id = shm_attach($SHMKEY, $MEMSIZE);
 if ($shm_id === FALSE) {
     echo "Fail to attach shared memory.\n";
     sem_remove($sem_id);
     exit;
 }
-echo "Success to attach shared memory : $shm_id.\n";
+echo "Success to attach shared memory.\n";
 
 // Write variable 1
 if (!shm_put_var($shm_id, 1, "Variable 1")) {
@@ -48,7 +48,7 @@ echo "Write var1 to shared memory.\n";
 
 // Write variable 2
 if (!shm_put_var($shm_id, 2, "Variable 2")) {
-    echo "Fail to put var 2 on shared memory $shm_id.\n";
+    echo "Fail to put var 2 on shared memory.\n";
     sem_remove($sem_id);
     shm_remove ($shm_id);
     exit;
@@ -58,15 +58,15 @@ echo "Write var2 to shared memory.\n";
 // Read variable 1
 $var1   =   shm_get_var ($shm_id, 1);
 if ($var1 === FALSE) {
-    echo "Fail to retrieve Var 1 from Shared memory $shm_id, return value=$var1.\n";
+    echo "Fail to retrieve Var 1 from Shared memory, return value=$var1.\n";
 } else {
     echo "Read var1=$var1.\n";
 }
 
 // Read variable 1
 $var2   =   shm_get_var ($shm_id, 2);
 if ($var1 === FALSE) {
-    echo "Fail to retrieve Var 2 from Shared memory $shm_id, return value=$var2.\n";
+    echo "Fail to retrieve Var 2 from Shared memory, return value=$var2.\n";
 } else {
     echo "Read var2=$var2.\n";
 }
@@ -81,7 +81,7 @@ if (!sem_release($sem_id)) {
 if (shm_remove ($shm_id)) {
     echo "Shared memory successfully removed from SysV.\n";
 } else {
-    echo "Fail to remove $shm_id shared memory from SysV.\n";
+    echo "Fail to remove shared memory from SysV.\n";
 }
 
 // Remove semaphore
@@ -101,7 +101,7 @@ echo "End.\n";
 Start.
 Got semaphore.
 Success acquire semaphore.
-Success to attach shared memory : %s.
+Success to attach shared memory.
 Write var1 to shared memory.
 Write var2 to shared memory.
 Read var1=Variable 1.

ext/sysvshm/php_sysvshm.h

@@ -38,10 +38,7 @@ extern zend_module_entry sysvshm_module_entry;
 # include <sys/shm.h>
 #endif
 
-#define PHP_SHM_RSRC_NAME "sysvshm"
-
 typedef struct {
-	int le_shm;
 	zend_long init_mem;
 } sysvshm_module;
 
@@ -64,6 +61,7 @@ typedef struct {
 	key_t key;               /* key set by user */
 	zend_long id;                 /* returned by shmget */
 	sysvshm_chunk_head *ptr; /* memory address of shared memory */
+	zend_object std;
 } sysvshm_shm;
 
 PHP_MINIT_FUNCTION(sysvshm);

ext/sysvshm/sysvshm.c

@@ -29,8 +29,44 @@
 #include "ext/standard/info.h"
 #include "ext/standard/php_var.h"
 #include "zend_smart_str.h"
+#include "Zend/zend_interfaces.h"
 #include "php_ini.h"
 
+/* Sysvshm class */
+
+zend_class_entry *sysvshm_ce;
+static zend_object_handlers sysvshm_object_handlers;
+
+static inline sysvshm_shm *sysvshm_from_obj(zend_object *obj) {
+	return (sysvshm_shm *)((char *)(obj) - XtOffsetOf(sysvshm_shm, std));
+}
+
+#define Z_SYSVSHM_P(zv) sysvshm_from_obj(Z_OBJ_P(zv))
+
+static zend_object *sysvshm_create_object(zend_class_entry *class_type) {
+	sysvshm_shm *intern = zend_object_alloc(sizeof(sysvshm_shm), class_type);
+
+	zend_object_std_init(&intern->std, class_type);
+	object_properties_init(&intern->std, class_type);
+	intern->std.handlers = &sysvshm_object_handlers;
+
+	return &intern->std;
+}
+
+static zend_function *sysvshm_get_constructor(zend_object *object) {
+	zend_throw_error(NULL, "Cannot directly construct Sysvshm, use shm_attach() instead");
+	return NULL;
+}
+
+static void sysvshm_free_obj(zend_object *object)
+{
+	sysvshm_shm *sysvshm = sysvshm_from_obj(object);
+
+	shmdt((void *) sysvshm->ptr);
+
+	zend_object_std_dtor(&sysvshm->std);
+}
+
 /* {{{ sysvshm_module_entry
  */
 zend_module_entry sysvshm_module_entry = {
@@ -53,33 +89,29 @@ ZEND_GET_MODULE(sysvshm)
 
 #undef shm_ptr					/* undefine AIX-specific macro */
 
-#define SHM_FETCH_RESOURCE(shm_ptr, z_ptr) do { \
-	if ((shm_ptr = (sysvshm_shm *)zend_fetch_resource(Z_RES_P(z_ptr), PHP_SHM_RSRC_NAME, php_sysvshm.le_shm)) == NULL) { \
-		RETURN_THROWS(); \
-	} \
-} while (0)
-
 THREAD_LS sysvshm_module php_sysvshm;
 
 static int php_put_shm_data(sysvshm_chunk_head *ptr, zend_long key, const char *data, zend_long len);
 static zend_long php_check_shm_data(sysvshm_chunk_head *ptr, zend_long key);
 static int php_remove_shm_data(sysvshm_chunk_head *ptr, zend_long shm_varpos);
 
-/* {{{ php_release_sysvshm
- */
-static void php_release_sysvshm(zend_resource *rsrc)
-{
-	sysvshm_shm *shm_ptr = (sysvshm_shm *) rsrc->ptr;
-	shmdt((void *) shm_ptr->ptr);
-	efree(shm_ptr);
-}
-/* }}} */
-
 /* {{{ PHP_MINIT_FUNCTION
  */
 PHP_MINIT_FUNCTION(sysvshm)
 {
-	php_sysvshm.le_shm = zend_register_list_destructors_ex(php_release_sysvshm, NULL, PHP_SHM_RSRC_NAME, module_number);
+	zend_class_entry ce;
+	INIT_CLASS_ENTRY(ce, "Sysvshm", class_Sysvshm_methods);
+	sysvshm_ce = zend_register_internal_class(&ce);
+	sysvshm_ce->ce_flags |= ZEND_ACC_FINAL;
+	sysvshm_ce->create_object = sysvshm_create_object;
+	sysvshm_ce->serialize = zend_class_serialize_deny;
+	sysvshm_ce->unserialize = zend_class_unserialize_deny;
+
+	memcpy(&sysvshm_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
+	sysvshm_object_handlers.offset = XtOffsetOf(sysvshm_shm, std);
+	sysvshm_object_handlers.free_obj = sysvshm_free_obj;
+	sysvshm_object_handlers.get_constructor = sysvshm_get_constructor;
+	sysvshm_object_handlers.clone_obj = NULL;
 
 	if (cfg_get_long("sysvshm.init_mem", &php_sysvshm.init_mem) == FAILURE) {
 		php_sysvshm.init_mem=10000;
@@ -116,25 +148,25 @@ PHP_FUNCTION(shm_attach)
 		RETURN_FALSE;
   	}
 
-	shm_list_ptr = (sysvshm_shm *) emalloc(sizeof(sysvshm_shm));
+	object_init_ex(return_value, sysvshm_ce);
 
 	/* get the id from a specified key or create new shared memory */
 	if ((shm_id = shmget(shm_key, 0, 0)) < 0) {
 		if (shm_size < (zend_long)sizeof(sysvshm_chunk_head)) {
 			php_error_docref(NULL, E_WARNING, "Failed for key 0x" ZEND_XLONG_FMT ": memorysize too small", shm_key);
-			efree(shm_list_ptr);
+			zval_ptr_dtor(return_value);
 			RETURN_FALSE;
 		}
 		if ((shm_id = shmget(shm_key, shm_size, shm_flag | IPC_CREAT | IPC_EXCL)) < 0) {
 			php_error_docref(NULL, E_WARNING, "Failed for key 0x" ZEND_XLONG_FMT ": %s", shm_key, strerror(errno));
-			efree(shm_list_ptr);
+			zval_ptr_dtor(return_value);
 			RETURN_FALSE;
 		}
 	}
 
 	if ((shm_ptr = shmat(shm_id, NULL, 0)) == (void *) -1) {
 		php_error_docref(NULL, E_WARNING, "Failed for key 0x" ZEND_XLONG_FMT ": %s", shm_key, strerror(errno));
-		efree(shm_list_ptr);
+		zval_ptr_dtor(return_value);
 		RETURN_FALSE;
 	}
 
@@ -148,40 +180,40 @@ PHP_FUNCTION(shm_attach)
 		chunk_ptr->free = shm_size-chunk_ptr->end;
 	}
 
+	shm_list_ptr = Z_SYSVSHM_P(return_value);
+
 	shm_list_ptr->key = shm_key;
 	shm_list_ptr->id = shm_id;
 	shm_list_ptr->ptr = chunk_ptr;
-
-	RETURN_RES(zend_register_resource(shm_list_ptr, php_sysvshm.le_shm));
 }
 /* }}} */
 
-/* {{{ proto bool shm_detach(resource shm_identifier)
+/* {{{ proto bool shm_detach(Sysvshm shm_identifier)
    Disconnects from shared memory segment */
 PHP_FUNCTION(shm_detach)
 {
 	zval *shm_id;
-	sysvshm_shm *shm_list_ptr;
 
-	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "r", &shm_id)) {
+	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "O", &shm_id, sysvshm_ce)) {
 		RETURN_THROWS();
 	}
-	SHM_FETCH_RESOURCE(shm_list_ptr, shm_id);
-	RETURN_BOOL(SUCCESS == zend_list_close(Z_RES_P(shm_id)));
+
+	RETURN_TRUE;
 }
 /* }}} */
 
-/* {{{ proto bool shm_remove(resource shm_identifier)
+/* {{{ proto bool shm_remove(Sysvshm shm_identifier)
    Removes shared memory from Unix systems */
 PHP_FUNCTION(shm_remove)
 {
 	zval *shm_id;
 	sysvshm_shm *shm_list_ptr;
 
-	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "r", &shm_id)) {
+	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "O", &shm_id, sysvshm_ce)) {
 		RETURN_THROWS();
 	}
-	SHM_FETCH_RESOURCE(shm_list_ptr, shm_id);
+
+	shm_list_ptr = Z_SYSVSHM_P(shm_id);
 
 	if (shmctl(shm_list_ptr->id, IPC_RMID, NULL) < 0) {
 		php_error_docref(NULL, E_WARNING, "Failed for key 0x%x, id " ZEND_LONG_FMT ": %s", shm_list_ptr->key, Z_LVAL_P(shm_id), strerror(errno));
@@ -192,7 +224,7 @@ PHP_FUNCTION(shm_remove)
 }
 /* }}} */
 
-/* {{{ proto bool shm_put_var(resource shm_identifier, int variable_key, mixed variable)
+/* {{{ proto bool shm_put_var(Sysvshm shm_identifier, int variable_key, mixed variable)
    Inserts or updates a variable in shared memory */
 PHP_FUNCTION(shm_put_var)
 {
@@ -203,7 +235,7 @@ PHP_FUNCTION(shm_put_var)
 	smart_str shm_var = {0};
 	php_serialize_data_t var_hash;
 
-	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "rlz", &shm_id, &shm_key, &arg_var)) {
+	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Olz", &shm_id, sysvshm_ce, &shm_key, &arg_var)) {
 		RETURN_THROWS();
 	}
 
@@ -212,11 +244,7 @@ PHP_FUNCTION(shm_put_var)
 	php_var_serialize(&shm_var, arg_var, &var_hash);
 	PHP_VAR_SERIALIZE_DESTROY(var_hash);
 
-	shm_list_ptr = zend_fetch_resource(Z_RES_P(shm_id), PHP_SHM_RSRC_NAME, php_sysvshm.le_shm);
-	if (!shm_list_ptr) {
-		smart_str_free(&shm_var);
-		RETURN_THROWS();
-	}
+	shm_list_ptr = Z_SYSVSHM_P(shm_id);
 
 	/* insert serialized variable into shared memory */
 	ret = php_put_shm_data(shm_list_ptr->ptr, shm_key, shm_var.s? ZSTR_VAL(shm_var.s) : NULL, shm_var.s? ZSTR_LEN(shm_var.s) : 0);
@@ -232,7 +260,7 @@ PHP_FUNCTION(shm_put_var)
 }
 /* }}} */
 
-/* {{{ proto mixed shm_get_var(resource id, int variable_key)
+/* {{{ proto mixed shm_get_var(Sysvshm id, int variable_key)
    Returns a variable from shared memory */
 PHP_FUNCTION(shm_get_var)
 {
@@ -244,10 +272,11 @@ PHP_FUNCTION(shm_get_var)
 	sysvshm_chunk *shm_var;
 	php_unserialize_data_t var_hash;
 
-	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &shm_id, &shm_key)) {
+	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Ol", &shm_id, sysvshm_ce, &shm_key)) {
 		RETURN_THROWS();
 	}
-	SHM_FETCH_RESOURCE(shm_list_ptr, shm_id);
+
+	shm_list_ptr = Z_SYSVSHM_P(shm_id);
 
 	/* setup string-variable and serialize */
 	/* get serialized variable from shared memory */
@@ -269,34 +298,37 @@ PHP_FUNCTION(shm_get_var)
 }
 /* }}} */
 
-/* {{{ proto bool shm_has_var(resource id, int variable_key)
+/* {{{ proto bool shm_has_var(Sysvshm id, int variable_key)
 	Checks whether a specific entry exists */
 PHP_FUNCTION(shm_has_var)
 {
 	zval *shm_id;
 	zend_long shm_key;
 	sysvshm_shm *shm_list_ptr;
 
-	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &shm_id, &shm_key)) {
+	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Ol", &shm_id, sysvshm_ce, &shm_key)) {
 		RETURN_THROWS();
 	}
-	SHM_FETCH_RESOURCE(shm_list_ptr, shm_id);
+
+	shm_list_ptr = Z_SYSVSHM_P(shm_id);
+
 	RETURN_BOOL(php_check_shm_data(shm_list_ptr->ptr, shm_key) >= 0);
 }
 /* }}} */
 
-/* {{{ proto bool shm_remove_var(resource id, int variable_key)
+/* {{{ proto bool shm_remove_var(Sysvshm id, int variable_key)
    Removes variable from shared memory */
 PHP_FUNCTION(shm_remove_var)
 {
 	zval *shm_id;
 	zend_long shm_key, shm_varpos;
 	sysvshm_shm *shm_list_ptr;
 
-	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &shm_id, &shm_key)) {
+	if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Ol", &shm_id, sysvshm_ce, &shm_key)) {
 		RETURN_THROWS();
 	}
-	SHM_FETCH_RESOURCE(shm_list_ptr, shm_id);
+
+	shm_list_ptr = Z_SYSVSHM_P(shm_id);
 
 	shm_varpos = php_check_shm_data((shm_list_ptr->ptr), shm_key);