X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=php_raphf.c;h=811464b55e2980b98579fb69b65846e83b919a7a;hb=484e626bee35fc8a26bc44a51afc9d0cdd0508c1;hp=2c785dd72c00201f2e21d4377fa7a7abf520d6ef;hpb=c01edad3209f9e20c8192bf562f2a994752b25cb;p=m6w6%2Fext-raphf

diff --git a/php_raphf.c b/php_raphf.c
index 2c785dd..811464b 100644
--- a/php_raphf.c
+++ b/php_raphf.c
@@ -19,6 +19,10 @@
 #include "ext/standard/info.h"
 #include "php_raphf.h"
 
+#ifndef PHP_RAPHF_TEST
+#	define PHP_RAPHF_TEST 0
+#endif
+
 struct php_persistent_handle_globals {
 	ulong limit;
 	HashTable hash;
@@ -30,7 +34,7 @@ ZEND_END_MODULE_GLOBALS(raphf)
 
 #ifdef ZTS
 #	define PHP_RAPHF_G ((zend_raphf_globals *) \
-		(*((void ***) tsrm_ls))[TSRM_UNSHUFFLE_RSRC_ID(raphf_globals_id)])
+		(*((void ***) tsrm_get_ls_cache()))[TSRM_UNSHUFFLE_RSRC_ID(raphf_globals_id)])
 #else
 #	define PHP_RAPHF_G (&raphf_globals)
 #endif
@@ -88,29 +92,26 @@ void php_resource_factory_free(php_resource_factory_t **f)
 	}
 }
 
-void *php_resource_factory_handle_ctor(php_resource_factory_t *f,
-		void *init_arg TSRMLS_DC)
+void *php_resource_factory_handle_ctor(php_resource_factory_t *f, void *init_arg)
 {
 	if (f->fops.ctor) {
-		return f->fops.ctor(f->data, init_arg TSRMLS_CC);
+		return f->fops.ctor(f->data, init_arg);
 	}
 	return NULL;
 }
 
-void *php_resource_factory_handle_copy(php_resource_factory_t *f,
-		void *handle TSRMLS_DC)
+void *php_resource_factory_handle_copy(php_resource_factory_t *f, void *handle)
 {
 	if (f->fops.copy) {
-		return f->fops.copy(f->data, handle TSRMLS_CC);
+		return f->fops.copy(f->data, handle);
 	}
 	return NULL;
 }
 
-void php_resource_factory_handle_dtor(php_resource_factory_t *f,
-		void *handle TSRMLS_DC)
+void php_resource_factory_handle_dtor(php_resource_factory_t *f, void *handle)
 {
 	if (f->fops.dtor) {
-		f->fops.dtor(f->data, handle TSRMLS_CC);
+		f->fops.dtor(f->data, handle);
 	}
 }
 
@@ -126,23 +127,26 @@ static inline php_persistent_handle_list_t *php_persistent_handle_list_init(
 	return list;
 }
 
-static int php_persistent_handle_apply_stat(zval *p TSRMLS_DC, int argc,
-		va_list argv, zend_hash_key *key)
+static int php_persistent_handle_apply_stat(zval *p, int argc, va_list argv,
+		zend_hash_key *key)
 {
 	php_persistent_handle_list_t *list = Z_PTR_P(p);
 	zval zsubentry, *zentry = va_arg(argv, zval *);
 
 	array_init(&zsubentry);
-	add_assoc_long_ex(&zsubentry, ZEND_STRS("used"), list->used);
-	add_assoc_long_ex(&zsubentry, ZEND_STRS("free"),
+	add_assoc_long_ex(&zsubentry, ZEND_STRL("used"), list->used);
+	add_assoc_long_ex(&zsubentry, ZEND_STRL("free"),
 			zend_hash_num_elements(&list->free));
-	add_assoc_zval_ex(zentry, key->key->val, key->key->len, &zsubentry);
-
+	if (key->key) {
+		add_assoc_zval_ex(zentry, key->key->val, key->key->len, &zsubentry);
+	} else {
+		add_index_zval(zentry, key->h, &zsubentry);
+	}
 	return ZEND_HASH_APPLY_KEEP;
 }
 
-static int php_persistent_handle_apply_statall(zval *p TSRMLS_DC, int argc,
-		va_list argv, zend_hash_key *key)
+static int php_persistent_handle_apply_statall(zval *p, int argc, va_list argv,
+		zend_hash_key *key)
 {
 	php_persistent_handle_provider_t *provider = Z_PTR_P(p);
 	HashTable *ht = va_arg(argv, HashTable *);
@@ -150,14 +154,19 @@ static int php_persistent_handle_apply_statall(zval *p TSRMLS_DC, int argc,
 
 	array_init(&zentry);
 
-	zend_hash_apply_with_arguments(&provider->list.free TSRMLS_CC,
+	zend_hash_apply_with_arguments(&provider->list.free,
 			php_persistent_handle_apply_stat, 1, &zentry);
-	zend_symtable_update(ht, key->key, &zentry);
+
+	if (key->key) {
+		zend_hash_update(ht, key->key, &zentry);
+	} else {
+		zend_hash_index_update(ht, key->h, &zentry);
+	}
 
 	return ZEND_HASH_APPLY_KEEP;
 }
 
-static int php_persistent_handle_apply_cleanup_ex(zval *p, void *arg TSRMLS_DC)
+static int php_persistent_handle_apply_cleanup_ex(zval *p, void *arg)
 {
 	php_resource_factory_t *rf = arg;
 	void *handle = Z_PTR_P(p);
@@ -165,17 +174,17 @@ static int php_persistent_handle_apply_cleanup_ex(zval *p, void *arg TSRMLS_DC)
 #if PHP_RAPHF_DEBUG_PHANDLES
 	fprintf(stderr, "DESTROY: %p\n", handle);
 #endif
-	php_resource_factory_handle_dtor(rf, handle TSRMLS_CC);
+	php_resource_factory_handle_dtor(rf, handle);
 	return ZEND_HASH_APPLY_REMOVE;
 }
 
-static int php_persistent_handle_apply_cleanup(zval *p, void *arg TSRMLS_DC)
+static int php_persistent_handle_apply_cleanup(zval *p, void *arg)
 {
 	php_resource_factory_t *rf = arg;
 	php_persistent_handle_list_t *list = Z_PTR_P(p);
 
 	zend_hash_apply_with_argument(&list->free,
-			php_persistent_handle_apply_cleanup_ex, rf TSRMLS_CC);
+			php_persistent_handle_apply_cleanup_ex, rf);
 	if (list->used) {
 		return ZEND_HASH_APPLY_KEEP;
 	}
@@ -189,21 +198,21 @@ static int php_persistent_handle_apply_cleanup(zval *p, void *arg TSRMLS_DC)
 
 static inline void php_persistent_handle_list_dtor(
 		php_persistent_handle_list_t *list,
-		php_persistent_handle_provider_t *provider TSRMLS_DC)
+		php_persistent_handle_provider_t *provider)
 {
 #if PHP_RAPHF_DEBUG_PHANDLES
 	fprintf(stderr, "LSTDTOR: %p\n", list);
 #endif
 	zend_hash_apply_with_argument(&list->free,
-			php_persistent_handle_apply_cleanup_ex, &provider->rf TSRMLS_CC);
+			php_persistent_handle_apply_cleanup_ex, &provider->rf);
 	zend_hash_destroy(&list->free);
 }
 
 static inline void php_persistent_handle_list_free(
 		php_persistent_handle_list_t **list,
-		php_persistent_handle_provider_t *provider TSRMLS_DC)
+		php_persistent_handle_provider_t *provider)
 {
-	php_persistent_handle_list_dtor(*list, provider TSRMLS_CC);
+	php_persistent_handle_list_dtor(*list, provider);
 #if PHP_RAPHF_DEBUG_PHANDLES
 	fprintf(stderr, "LSTFREE: %p\n", *list);
 #endif
@@ -211,23 +220,22 @@ static inline void php_persistent_handle_list_free(
 	*list = NULL;
 }
 
-static int php_persistent_handle_list_apply_dtor(zval *p,
-		void *provider TSRMLS_DC)
+static int php_persistent_handle_list_apply_dtor(zval *p, void *provider)
 {
 	php_persistent_handle_list_t *list = Z_PTR_P(p);
-	php_persistent_handle_list_free(&list, provider TSRMLS_CC);
+
+	php_persistent_handle_list_free(&list, provider );
 	ZVAL_PTR(p, NULL);
 	return ZEND_HASH_APPLY_REMOVE;
 }
 
 static inline php_persistent_handle_list_t *php_persistent_handle_list_find(
 		php_persistent_handle_provider_t *provider, const char *ident_str,
-		size_t ident_len TSRMLS_DC)
+		size_t ident_len)
 {
 	php_persistent_handle_list_t *list;
 
-	list = zend_symtable_str_find_ptr(&provider->list.free, ident_str,
-			ident_len + 1);
+	list = zend_symtable_str_find_ptr(&provider->list.free, ident_str, ident_len);
 
 	if (list) {
 #if PHP_RAPHF_DEBUG_PHANDLES
@@ -247,13 +255,13 @@ static inline php_persistent_handle_list_t *php_persistent_handle_list_find(
 #endif
 			return list;
 		}
-		php_persistent_handle_list_free(&list, provider TSRMLS_CC);
+		php_persistent_handle_list_free(&list, provider);
 	}
 
 	return NULL;
 }
 
-static int php_persistent_handle_apply_cleanup_all(zval *p TSRMLS_DC, int argc,
+static int php_persistent_handle_apply_cleanup_all(zval *p, int argc,
 		va_list argv, zend_hash_key *key)
 {
 	php_persistent_handle_provider_t *provider = Z_PTR_P(p);
@@ -263,14 +271,14 @@ static int php_persistent_handle_apply_cleanup_all(zval *p TSRMLS_DC, int argc,
 
 	if (ident_str && ident_len) {
 		if ((list = php_persistent_handle_list_find(provider, ident_str,
-				ident_len TSRMLS_CC))) {
+				ident_len))) {
 			zend_hash_apply_with_argument(&list->free,
 					php_persistent_handle_apply_cleanup_ex,
-					&provider->rf TSRMLS_CC);
+					&provider->rf);
 		}
 	} else {
 		zend_hash_apply_with_argument(&provider->list.free,
-				php_persistent_handle_apply_cleanup, &provider->rf TSRMLS_CC);
+				php_persistent_handle_apply_cleanup, &provider->rf);
 	}
 
 	return ZEND_HASH_APPLY_KEEP;
@@ -279,10 +287,9 @@ static int php_persistent_handle_apply_cleanup_all(zval *p TSRMLS_DC, int argc,
 static void php_persistent_handle_hash_dtor(zval *p)
 {
 	php_persistent_handle_provider_t *provider = Z_PTR_P(p);
-	TSRMLS_FETCH();
 
 	zend_hash_apply_with_argument(&provider->list.free,
-			php_persistent_handle_list_apply_dtor, provider TSRMLS_CC);
+			php_persistent_handle_list_apply_dtor, provider);
 	zend_hash_destroy(&provider->list.free);
 	php_resource_factory_dtor(&provider->rf);
 	pefree(provider, 1);
@@ -290,7 +297,7 @@ static void php_persistent_handle_hash_dtor(zval *p)
 
 ZEND_RESULT_CODE php_persistent_handle_provide(const char *name_str,
 		size_t name_len, php_resource_factory_ops_t *fops, void *data,
-		void (*dtor)(void *) TSRMLS_DC)
+		void (*dtor)(void *))
 {
 	php_persistent_handle_provider_t *provider = pemalloc(sizeof(*provider), 1);
 
@@ -314,11 +321,12 @@ ZEND_RESULT_CODE php_persistent_handle_provide(const char *name_str,
 	return FAILURE;
 }
 
+
 php_persistent_handle_factory_t *php_persistent_handle_concede(
 		php_persistent_handle_factory_t *a, const char *name_str,
 		size_t name_len, const char *ident_str, size_t ident_len,
 		php_persistent_handle_wakeup_t wakeup,
-		php_persistent_handle_retire_t retire TSRMLS_DC)
+		php_persistent_handle_retire_t retire)
 {
 	php_persistent_handle_factory_t *free_a = NULL;
 
@@ -328,7 +336,7 @@ php_persistent_handle_factory_t *php_persistent_handle_concede(
 	memset(a, 0, sizeof(*a));
 
 	a->provider = zend_symtable_str_find_ptr(&PHP_RAPHF_G->persistent_handle.hash,
-			name_str, name_len+1);
+			name_str, name_len);
 
 	if (a->provider) {
 		a->ident.str = estrndup(ident_str, ident_len);
@@ -372,8 +380,7 @@ void php_persistent_handle_abandon(php_persistent_handle_factory_t *a)
 	}
 }
 
-void *php_persistent_handle_acquire(php_persistent_handle_factory_t *a,
-		void *init_arg  TSRMLS_DC)
+void *php_persistent_handle_acquire(php_persistent_handle_factory_t *a, void *init_arg)
 {
 	int key;
 	zval *p;
@@ -381,8 +388,7 @@ void *php_persistent_handle_acquire(php_persistent_handle_factory_t *a,
 	void *handle = NULL;
 	php_persistent_handle_list_t *list;
 
-	list = php_persistent_handle_list_find(a->provider, a->ident.str,
-			a->ident.len TSRMLS_CC);
+	list = php_persistent_handle_list_find(a->provider, a->ident.str, a->ident.len);
 	if (list) {
 		zend_hash_internal_pointer_end(&list->free);
 		key = zend_hash_get_current_key(&list->free, NULL, &index, 0);
@@ -390,12 +396,11 @@ void *php_persistent_handle_acquire(php_persistent_handle_factory_t *a,
 		if (p && HASH_KEY_NON_EXISTENT != key) {
 			handle = Z_PTR_P(p);
 			if (a->wakeup) {
-				a->wakeup(a, &handle TSRMLS_CC);
+				a->wakeup(a, &handle);
 			}
 			zend_hash_index_del(&list->free, index);
 		} else {
-			handle = php_resource_factory_handle_ctor(&a->provider->rf,
-					init_arg TSRMLS_CC);
+			handle = php_resource_factory_handle_ctor(&a->provider->rf, init_arg);
 		}
 #if PHP_RAPHF_DEBUG_PHANDLES
 		fprintf(stderr, "CREATED: %p\n", handle);
@@ -409,17 +414,14 @@ void *php_persistent_handle_acquire(php_persistent_handle_factory_t *a,
 	return handle;
 }
 
-void *php_persistent_handle_accrete(php_persistent_handle_factory_t *a,
-		void *handle TSRMLS_DC)
+void *php_persistent_handle_accrete(php_persistent_handle_factory_t *a, void *handle)
 {
 	void *new_handle = NULL;
 	php_persistent_handle_list_t *list;
 
-	new_handle = php_resource_factory_handle_copy(&a->provider->rf,
-			handle TSRMLS_CC);
+	new_handle = php_resource_factory_handle_copy(&a->provider->rf, handle);
 	if (handle) {
-		list = php_persistent_handle_list_find(a->provider, a->ident.str,
-				a->ident.len TSRMLS_CC);
+		list = php_persistent_handle_list_find(a->provider, a->ident.str, a->ident.len);
 		if (list) {
 			++list->used;
 		}
@@ -429,22 +431,20 @@ void *php_persistent_handle_accrete(php_persistent_handle_factory_t *a,
 	return new_handle;
 }
 
-void php_persistent_handle_release(php_persistent_handle_factory_t *a,
-		void *handle TSRMLS_DC)
+void php_persistent_handle_release(php_persistent_handle_factory_t *a, void *handle)
 {
 	php_persistent_handle_list_t *list;
 
-	list = php_persistent_handle_list_find(a->provider, a->ident.str,
-			a->ident.len TSRMLS_CC);
+	list = php_persistent_handle_list_find(a->provider, a->ident.str, a->ident.len);
 	if (list) {
 		if (a->provider->list.used >= PHP_RAPHF_G->persistent_handle.limit) {
 #if PHP_RAPHF_DEBUG_PHANDLES
 			fprintf(stderr, "DESTROY: %p\n", handle);
 #endif
-			php_resource_factory_handle_dtor(&a->provider->rf, handle TSRMLS_CC);
+			php_resource_factory_handle_dtor(&a->provider->rf, handle);
 		} else {
 			if (a->retire) {
-				a->retire(a, &handle TSRMLS_CC);
+				a->retire(a, &handle);
 			}
 			zend_hash_next_index_insert_ptr(&list->free, handle);
 		}
@@ -455,39 +455,39 @@ void php_persistent_handle_release(php_persistent_handle_factory_t *a,
 }
 
 void php_persistent_handle_cleanup(const char *name_str, size_t name_len,
-		const char *ident_str, size_t ident_len TSRMLS_DC)
+		const char *ident_str, size_t ident_len)
 {
 	php_persistent_handle_provider_t *provider;
 	php_persistent_handle_list_t *list;
 
 	if (name_str && name_len) {
 		provider = zend_symtable_str_find_ptr(&PHP_RAPHF_G->persistent_handle.hash,
-				name_str, name_len+1);
+				name_str, name_len);
 
 		if (provider) {
 			if (ident_str && ident_len) {
 				list = php_persistent_handle_list_find(provider, ident_str,
-						ident_len TSRMLS_CC);
+						ident_len);
 				if (list) {
 					zend_hash_apply_with_argument(&list->free,
 							php_persistent_handle_apply_cleanup_ex,
-							&provider->rf TSRMLS_CC);
+							&provider->rf);
 				}
 			} else {
 				zend_hash_apply_with_argument(&provider->list.free,
 						php_persistent_handle_apply_cleanup,
-						&provider->rf TSRMLS_CC);
+						&provider->rf);
 			}
 		}
 	} else {
 		zend_hash_apply_with_arguments(
-				&PHP_RAPHF_G->persistent_handle.hash TSRMLS_CC,
+				&PHP_RAPHF_G->persistent_handle.hash,
 				php_persistent_handle_apply_cleanup_all, 2, ident_str,
 				ident_len);
 	}
 }
 
-HashTable *php_persistent_handle_statall(HashTable *ht TSRMLS_DC)
+HashTable *php_persistent_handle_statall(HashTable *ht)
 {
 	if (zend_hash_num_elements(&PHP_RAPHF_G->persistent_handle.hash)) {
 		if (!ht) {
@@ -495,7 +495,7 @@ HashTable *php_persistent_handle_statall(HashTable *ht TSRMLS_DC)
 			zend_hash_init(ht, 0, NULL, ZVAL_PTR_DTOR, 0);
 		}
 		zend_hash_apply_with_arguments(
-				&PHP_RAPHF_G->persistent_handle.hash TSRMLS_CC,
+				&PHP_RAPHF_G->persistent_handle.hash,
 				php_persistent_handle_apply_statall, 1, ht);
 	} else if (ht) {
 		ht = NULL;
@@ -521,7 +521,7 @@ static PHP_FUNCTION(raphf_stat_persistent_handles)
 {
 	if (SUCCESS == zend_parse_parameters_none()) {
 		object_init(return_value);
-		if (php_persistent_handle_statall(HASH_OF(return_value) TSRMLS_CC)) {
+		if (php_persistent_handle_statall(HASH_OF(return_value))) {
 			return;
 		}
 		zval_dtor(return_value);
@@ -538,13 +538,16 @@ static PHP_FUNCTION(raphf_clean_persistent_handles)
 	char *name_str = NULL, *ident_str = NULL;
 	int name_len = 0, ident_len = 0;
 
-	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!s!",
+	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|s!s!",
 			&name_str, &name_len, &ident_str, &ident_len)) {
-		php_persistent_handle_cleanup(name_str, name_len, ident_str,
-				ident_len TSRMLS_CC);
+		php_persistent_handle_cleanup(name_str, name_len, ident_str, ident_len);
 	}
 }
 
+#if PHP_RAPHF_TEST
+#	include "php_raphf_test.c"
+#endif
+
 static const zend_function_entry raphf_functions[] = {
 	ZEND_NS_FENTRY("raphf", stat_persistent_handles,
 			ZEND_FN(raphf_stat_persistent_handles),
@@ -552,6 +555,15 @@ static const zend_function_entry raphf_functions[] = {
 	ZEND_NS_FENTRY("raphf", clean_persistent_handles,
 			ZEND_FN(raphf_clean_persistent_handles),
 			ai_raphf_clean_persistent_handles, 0)
+#if PHP_RAPHF_TEST
+	ZEND_NS_FENTRY("raphf", provide, ZEND_FN(raphf_provide), NULL, 0)
+	ZEND_NS_FENTRY("raphf", conceal, ZEND_FN(raphf_conceal), NULL, 0)
+	ZEND_NS_FENTRY("raphf", concede, ZEND_FN(raphf_concede), NULL, 0)
+	ZEND_NS_FENTRY("raphf", dispute, ZEND_FN(raphf_dispute), NULL, 0)
+	ZEND_NS_FENTRY("raphf", handle_ctor, ZEND_FN(raphf_handle_ctor), NULL, 0)
+	ZEND_NS_FENTRY("raphf", handle_copy, ZEND_FN(raphf_handle_copy), NULL, 0)
+	ZEND_NS_FENTRY("raphf", handle_dtor, ZEND_FN(raphf_handle_dtor), NULL, 0)
+#endif
 	{0}
 };
 
@@ -583,18 +595,27 @@ static PHP_GSHUTDOWN_FUNCTION(raphf)
 PHP_MINIT_FUNCTION(raphf)
 {
 	php_persistent_handles_global_hash = &PHP_RAPHF_G->persistent_handle.hash;
+
+#if PHP_RAPHF_TEST
+	PHP_MINIT(raphf_test)(INIT_FUNC_ARGS_PASSTHRU);
+#endif
+
 	REGISTER_INI_ENTRIES();
 	return SUCCESS;
 }
 
 PHP_MSHUTDOWN_FUNCTION(raphf)
 {
+#if PHP_RAPHF_TEST
+	PHP_MSHUTDOWN(raphf_test)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
+#endif
+
 	UNREGISTER_INI_ENTRIES();
 	php_persistent_handles_global_hash = NULL;
 	return SUCCESS;
 }
 
-static int php_persistent_handle_apply_info_ex(zval *p TSRMLS_DC, int argc,
+static int php_persistent_handle_apply_info_ex(zval *p, int argc,
 		va_list argv, zend_hash_key *key)
 {
 	php_persistent_handle_list_t *list = Z_PTR_P(p);
@@ -609,12 +630,12 @@ static int php_persistent_handle_apply_info_ex(zval *p TSRMLS_DC, int argc,
 	return ZEND_HASH_APPLY_KEEP;
 }
 
-static int php_persistent_handle_apply_info(zval *p TSRMLS_DC, int argc,
+static int php_persistent_handle_apply_info(zval *p, int argc,
 		va_list argv, zend_hash_key *key)
 {
 	php_persistent_handle_provider_t *provider = Z_PTR_P(p);
 
-	zend_hash_apply_with_arguments(&provider->list.free TSRMLS_CC,
+	zend_hash_apply_with_arguments(&provider->list.free,
 			php_persistent_handle_apply_info_ex, 1, key);
 
 	return ZEND_HASH_APPLY_KEEP;
@@ -638,7 +659,7 @@ PHP_MINFO_FUNCTION(raphf)
 	);
 	php_info_print_table_header(4, "Provider", "Ident", "Used", "Free");
 	zend_hash_apply_with_arguments(
-			&PHP_RAPHF_G->persistent_handle.hash TSRMLS_CC,
+			&PHP_RAPHF_G->persistent_handle.hash,
 			php_persistent_handle_apply_info, 0);
 	php_info_print_table_end();
 
@@ -667,7 +688,6 @@ zend_module_entry raphf_module_entry = {
 ZEND_GET_MODULE(raphf)
 #endif
 
-
 /*
  * Local variables:
  * tab-width: 4