X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-raphf;a=blobdiff_plain;f=src%2Fphp_raphf_api.c;h=d71ce36c305ea236c79318e9445857f4fb129bc2;hp=1de0fc0c2bc780bad5b1f9815b9f021cc1f6d1c2;hb=HEAD;hpb=b1022d895db9be6ad9cfb43ad70bea0a829eba61

diff --git a/src/php_raphf_api.c b/src/php_raphf_api.c
index 1de0fc0..d71ce36 100644
--- a/src/php_raphf_api.c
+++ b/src/php_raphf_api.c
@@ -19,8 +19,12 @@
 #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;
+	unsigned long limit;
 	HashTable hash;
 };
 
@@ -30,22 +34,13 @@ 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
 
 ZEND_DECLARE_MODULE_GLOBALS(raphf)
 
-#if PHP_VERSION_ID < 50500
-#undef SUCCESS
-#undef FAILURE
-typedef enum {
-	SUCCESS = 0,
-	FAILURE = -1
-} ZEND_RESULT_CODE;
-#endif
-
 #ifndef PHP_RAPHF_DEBUG_PHANDLES
 #	define PHP_RAPHF_DEBUG_PHANDLES 0
 #endif
@@ -79,9 +74,7 @@ unsigned php_resource_factory_addref(php_resource_factory_t *rf)
 
 void php_resource_factory_dtor(php_resource_factory_t *f)
 {
-	--f->refcount;
-
-	if (!f->refcount) {
+	if (!--f->refcount) {
 		if (f->dtor) {
 			f->dtor(f->data);
 		}
@@ -99,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);
 	}
 }
 
@@ -138,110 +128,104 @@ zend_bool php_resource_factory_is_persistent(php_resource_factory_t *a)
 	return a->dtor == (void(*)(void *)) php_persistent_handle_abandon;
 }
 
-
 static inline php_persistent_handle_list_t *php_persistent_handle_list_init(
 		php_persistent_handle_list_t *list)
 {
-	int free_list;
-
-	if ((free_list = !list)) {
-		list = pemalloc(sizeof(php_persistent_handle_list_t), 1);
+	if (!list) {
+		list = pemalloc(sizeof(*list), 1);
 	}
-
 	list->used = 0;
-
-	if (SUCCESS != zend_hash_init(&list->free, 0, NULL, NULL, 1)) {
-		if (free_list) {
-			pefree(list, 1);
-		}
-		list = NULL;
-	}
+	zend_hash_init(&list->free, 0, NULL, NULL, 1);
 
 	return list;
 }
 
-static int php_persistent_handle_apply_stat(void *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 = p;
-	zval *zsubentry, *zentry = va_arg(argv, zval *);
-
-	MAKE_STD_ZVAL(zsubentry);
-	array_init(zsubentry);
-	add_assoc_long_ex(zsubentry, ZEND_STRS("used"), (*list)->used);
-	add_assoc_long_ex(zsubentry, ZEND_STRS("free"),
-			zend_hash_num_elements(&(*list)->free));
-	add_assoc_zval_ex(zentry, key->arKey, key->nKeyLength, zsubentry);
+	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_STRL("used"), list->used);
+	add_assoc_long_ex(&zsubentry, ZEND_STRL("free"),
+			zend_hash_num_elements(&list->free));
+	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(void *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 = p;
+	php_persistent_handle_provider_t *provider = Z_PTR_P(p);
 	HashTable *ht = va_arg(argv, HashTable *);
-	zval *zentry;
+	zval zentry;
 
-	MAKE_STD_ZVAL(zentry);
-	array_init(zentry);
+	array_init(&zentry);
 
-	zend_hash_apply_with_arguments(&provider->list.free TSRMLS_CC,
-			php_persistent_handle_apply_stat, 1, zentry);
-	zend_symtable_update(ht, key->arKey, key->nKeyLength, &zentry,
-			sizeof(zval *), NULL);
+	zend_hash_apply_with_arguments(&provider->list.free,
+			php_persistent_handle_apply_stat, 1, &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(void *pp, void *arg TSRMLS_DC)
+static int php_persistent_handle_apply_cleanup_ex(zval *p, void *arg)
 {
 	php_resource_factory_t *rf = arg;
-	void **handle = pp;
+	void *handle = Z_PTR_P(p);
 
 #if PHP_RAPHF_DEBUG_PHANDLES
-	fprintf(stderr, "DESTROY: %p\n", *handle);
+	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(void *pp, 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 **listp = pp;
+	php_persistent_handle_list_t *list = Z_PTR_P(p);
 
-	zend_hash_apply_with_argument(&(*listp)->free,
-			php_persistent_handle_apply_cleanup_ex, rf TSRMLS_CC);
-	if ((*listp)->used) {
+	zend_hash_apply_with_argument(&list->free,
+			php_persistent_handle_apply_cleanup_ex, rf);
+	if (list->used) {
 		return ZEND_HASH_APPLY_KEEP;
 	}
-	zend_hash_destroy(&(*listp)->free);
+	zend_hash_destroy(&list->free);
 #if PHP_RAPHF_DEBUG_PHANDLES
-	fprintf(stderr, "LSTFREE: %p\n", *listp);
+	fprintf(stderr, "LSTFREE: %p\n", list);
 #endif
-	pefree(*listp, 1);
-	*listp = NULL;
+	pefree(list, 1);
 	return ZEND_HASH_APPLY_REMOVE;
 }
 
 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
@@ -249,148 +233,146 @@ static inline void php_persistent_handle_list_free(
 	*list = NULL;
 }
 
-static int php_persistent_handle_list_apply_dtor(void *listp,
-		void *provider TSRMLS_DC)
+static int php_persistent_handle_list_apply_dtor(zval *p, void *provider)
 {
-	php_persistent_handle_list_free(listp, provider TSRMLS_CC);
+	php_persistent_handle_list_t *list = Z_PTR_P(p);
+
+	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)
+		php_persistent_handle_provider_t *provider, zend_string *ident,
+		zend_bool create)
 {
-	php_persistent_handle_list_t **list, *new_list;
-	ZEND_RESULT_CODE rv = zend_symtable_find(&provider->list.free, ident_str,
-			ident_len + 1, (void *) &list);
+	php_persistent_handle_list_t *list;
+	zval *zlist = zend_symtable_find(&provider->list.free, ident);
 
-	if (SUCCESS == rv) {
+	if (zlist && (list = Z_PTR_P(zlist))) {
 #if PHP_RAPHF_DEBUG_PHANDLES
-		fprintf(stderr, "LSTFIND: %p\n", *list);
+		fprintf(stderr, "LSTFIND: %p\n", list);
 #endif
-		return *list;
+		return list;
 	}
 
-	if ((new_list = php_persistent_handle_list_init(NULL))) {
-		rv = zend_symtable_update(&provider->list.free, ident_str, ident_len+1,
-				(void *) &new_list,	sizeof(php_persistent_handle_list_t *),
-				(void *) &list);
-		if (SUCCESS == rv) {
+	if (create && (list = php_persistent_handle_list_init(NULL))) {
+		zval p, *rv;
+		zend_string *id;
+
+		ZVAL_PTR(&p, list);
+		id = zend_string_init(ident->val, ident->len, 1);
+		rv = zend_symtable_update(&provider->list.free, id, &p);
+		zend_string_release(id);
+
+		if (rv) {
 #if PHP_RAPHF_DEBUG_PHANDLES
-			fprintf(stderr, "LSTFIND: %p (new)\n", *list);
+			fprintf(stderr, "LSTFIND: %p (new)\n", list);
 #endif
-			return *list;
+			return list;
 		}
-		php_persistent_handle_list_free(&new_list, provider TSRMLS_CC);
+		php_persistent_handle_list_free(&list, provider);
 	}
 
 	return NULL;
 }
 
-static int php_persistent_handle_apply_cleanup_all(void *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 = p;
-	const char *ident_str = va_arg(argv, const char *);
-	size_t ident_len = va_arg(argv, size_t);
+	php_persistent_handle_provider_t *provider = Z_PTR_P(p);
+	zend_string *ident = va_arg(argv, zend_string *);
 	php_persistent_handle_list_t *list;
 
-	if (ident_str && ident_len) {
-		if ((list = php_persistent_handle_list_find(provider, ident_str,
-				ident_len TSRMLS_CC))) {
+	if (ident && ident->len) {
+		if ((list = php_persistent_handle_list_find(provider, ident, 0))) {
 			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;
 }
 
-static void php_persistent_handle_hash_dtor(void *p)
+static void php_persistent_handle_hash_dtor(zval *p)
 {
-	php_persistent_handle_provider_t *provider;
-	TSRMLS_FETCH();
+	php_persistent_handle_provider_t *provider = Z_PTR_P(p);
 
-	provider = (php_persistent_handle_provider_t *) p;
 	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);
 }
 
-PHP_RAPHF_API 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)
+ZEND_RESULT_CODE php_persistent_handle_provide(zend_string *name,
+		php_resource_factory_ops_t *fops, void *data, void (*dtor)(void *))
 {
-	ZEND_RESULT_CODE status = FAILURE;
-	php_persistent_handle_provider_t provider;
+	php_persistent_handle_provider_t *provider = pemalloc(sizeof(*provider), 1);
+
+	if (php_persistent_handle_list_init(&provider->list)) {
+		if (php_resource_factory_init(&provider->rf, fops, data, dtor)) {
+			zval p, *rv;
+			zend_string *ns;
 
-	if (php_persistent_handle_list_init(&provider.list)) {
-		if (php_resource_factory_init(&provider.rf, fops, data, dtor)) {
 #if PHP_RAPHF_DEBUG_PHANDLES
 			fprintf(stderr, "PROVIDE: %p %s\n", PHP_RAPHF_G, name_str);
 #endif
 
-			status = zend_symtable_update(&PHP_RAPHF_G->persistent_handle.hash,
-					name_str, name_len+1, (void *) &provider,
-					sizeof(php_persistent_handle_provider_t), NULL);
-			if (SUCCESS != status) {
-				php_resource_factory_dtor(&provider.rf);
+			ZVAL_PTR(&p, provider);
+			ns = zend_string_init(name->val, name->len, 1);
+			rv = zend_symtable_update(&PHP_RAPHF_G->persistent_handle.hash, ns, &p);
+			zend_string_release(ns);
+
+			if (rv) {
+				return SUCCESS;
 			}
+			php_resource_factory_dtor(&provider->rf);
 		}
 	}
 
-	return status;
+	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_factory_t *a,
+		zend_string *name, zend_string *ident,
 		php_persistent_handle_wakeup_t wakeup,
-		php_persistent_handle_retire_t retire TSRMLS_DC)
+		php_persistent_handle_retire_t retire)
 {
-	ZEND_RESULT_CODE status = FAILURE;
-	php_persistent_handle_factory_t *free_a = NULL;
+	zval *zprovider = zend_symtable_find(&PHP_RAPHF_G->persistent_handle.hash, name);
 
-	if (!a) {
-		free_a = a = emalloc(sizeof(*a));
-	}
-	memset(a, 0, sizeof(*a));
-
-	status = zend_symtable_find(&PHP_RAPHF_G->persistent_handle.hash, name_str,
-			name_len+1, (void *) &a->provider);
+	if (zprovider) {
+		zend_bool free_a = 0;
 
-	if (SUCCESS == status) {
-		a->ident.str = estrndup(ident_str, ident_len);
-		a->ident.len = ident_len;
+		if ((free_a = !a)) {
+			a = emalloc(sizeof(*a));
+		}
+		memset(a, 0, sizeof(*a));
 
+		a->provider = Z_PTR_P(zprovider);
+		a->ident = zend_string_copy(ident);
 		a->wakeup = wakeup;
 		a->retire = retire;
-
-		if (free_a) {
-			a->free_on_abandon = 1;
-		}
+		a->free_on_abandon = free_a;
 	} else {
-		if (free_a) {
-			efree(free_a);
-		}
 		a = NULL;
 	}
 
 #if PHP_RAPHF_DEBUG_PHANDLES
 	fprintf(stderr, "CONCEDE: %p %p (%s) (%s)\n", PHP_RAPHF_G,
-			a ? a->provider : NULL, name_str, ident_str);
+			a ? a->provider : NULL, name->val, ident->val);
 #endif
 
 	return a;
 }
 
-PHP_RAPHF_API void php_persistent_handle_abandon(
-		php_persistent_handle_factory_t *a)
+void php_persistent_handle_abandon(php_persistent_handle_factory_t *a)
 {
 	zend_bool f = a->free_on_abandon;
 
@@ -398,40 +380,37 @@ PHP_RAPHF_API void php_persistent_handle_abandon(
 	fprintf(stderr, "ABANDON: %p\n", a->provider);
 #endif
 
-	STR_FREE(a->ident.str);
+	zend_string_release(a->ident);
 	memset(a, 0, sizeof(*a));
 	if (f) {
 		efree(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;
-	ZEND_RESULT_CODE rv;
-	ulong index;
-	void **handle_ptr, *handle = NULL;
+	zval *p;
+	zend_ulong index;
+	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, 1);
 	if (list) {
 		zend_hash_internal_pointer_end(&list->free);
-		key = zend_hash_get_current_key(&list->free, NULL, &index, 0);
-		rv = zend_hash_get_current_data(&list->free, (void *) &handle_ptr);
-		if (HASH_KEY_NON_EXISTANT != key && SUCCESS == rv) {
-			handle = *handle_ptr;
+		key = zend_hash_get_current_key(&list->free, NULL, &index);
+		p = zend_hash_get_current_data(&list->free);
+		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);
+		fprintf(stderr, "CREATED: %p\n", handle);
 #endif
 		if (handle) {
 			++a->provider->list.used;
@@ -442,17 +421,14 @@ void *php_persistent_handle_acquire(
 	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, 1);
 		if (list) {
 			++list->used;
 		}
@@ -462,26 +438,22 @@ void *php_persistent_handle_accrete(
 	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, 1);
 	if (list) {
 		if (a->provider->list.used >= PHP_RAPHF_G->persistent_handle.limit) {
 #if PHP_RAPHF_DEBUG_PHANDLES
-			fprintf(stderr, "DESTROY: %p\n", *handle);
+			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(&list->free, (void *) &handle,
-					sizeof(void *), NULL);
+			zend_hash_next_index_insert_ptr(&list->free, handle);
 		}
 
 		--a->provider->list.used;
@@ -489,41 +461,37 @@ void php_persistent_handle_release(
 	}
 }
 
-void php_persistent_handle_cleanup(const char *name_str, size_t name_len,
-		const char *ident_str, size_t ident_len TSRMLS_DC)
+void php_persistent_handle_cleanup(zend_string *name, zend_string *ident)
 {
 	php_persistent_handle_provider_t *provider;
 	php_persistent_handle_list_t *list;
-	ZEND_RESULT_CODE rv;
 
-	if (name_str && name_len) {
-		rv = zend_symtable_find(&PHP_RAPHF_G->persistent_handle.hash, name_str,
-				name_len+1, (void *) &provider);
+	if (name) {
+		zval *zprovider = zend_symtable_find(&PHP_RAPHF_G->persistent_handle.hash,
+				name);
 
-		if (SUCCESS == rv) {
-			if (ident_str && ident_len) {
-				list = php_persistent_handle_list_find(provider, ident_str,
-						ident_len TSRMLS_CC);
+		if (zprovider && (provider = Z_PTR_P(zprovider))) {
+			if (ident) {
+				list = php_persistent_handle_list_find(provider, ident, 0);
 				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_persistent_handle_apply_cleanup_all, 2, ident_str,
-				ident_len);
+				&PHP_RAPHF_G->persistent_handle.hash,
+				php_persistent_handle_apply_cleanup_all, 1, ident);
 	}
 }
 
-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) {
@@ -531,7 +499,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;
@@ -557,7 +525,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);
@@ -571,16 +539,17 @@ ZEND_BEGIN_ARG_INFO_EX(ai_raphf_clean_persistent_handles, 0, 0, 0)
 ZEND_END_ARG_INFO();
 static PHP_FUNCTION(raphf_clean_persistent_handles)
 {
-	char *name_str = NULL, *ident_str = NULL;
-	int name_len = 0, ident_len = 0;
+	zend_string *name = NULL, *ident = NULL;
 
-	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!s!",
-			&name_str, &name_len, &ident_str, &ident_len)) {
-		php_persistent_handle_cleanup(name_str, name_len, ident_str,
-				ident_len TSRMLS_CC);
+	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "|S!S!", &name, &ident)) {
+		php_persistent_handle_cleanup(name, ident);
 	}
 }
 
+#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),
@@ -588,6 +557,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}
 };
 
@@ -607,8 +585,7 @@ static PHP_GINIT_FUNCTION(raphf)
 			php_persistent_handle_hash_dtor, 1);
 	if (php_persistent_handles_global_hash) {
 		zend_hash_copy(&raphf_globals->persistent_handle.hash,
-				php_persistent_handles_global_hash, NULL, NULL,
-				sizeof(php_persistent_handle_provider_t));
+				php_persistent_handles_global_hash, NULL);
 	}
 }
 
@@ -620,38 +597,47 @@ 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(void *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 = p;
+	php_persistent_handle_list_t *list = Z_PTR_P(p);
 	zend_hash_key *super_key = va_arg(argv, zend_hash_key *);
 	char used[21], free[21];
 
-	slprintf(used, sizeof(used), "%u", (*list)->used);
-	slprintf(free, sizeof(free), "%d", zend_hash_num_elements(&(*list)->free));
+	slprintf(used, sizeof(used), "%lu", list->used);
+	slprintf(free, sizeof(free), "%d", zend_hash_num_elements(&list->free));
 
-	php_info_print_table_row(4, super_key->arKey, key->arKey, used, free);
+	php_info_print_table_row(4, super_key->key->val, key->key->val, used, free);
 
 	return ZEND_HASH_APPLY_KEEP;
 }
 
-static int php_persistent_handle_apply_info(void *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 = p;
+	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;
@@ -675,7 +661,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();
 
@@ -704,7 +690,6 @@ zend_module_entry raphf_module_entry = {
 ZEND_GET_MODULE(raphf)
 #endif
 
-
 /*
  * Local variables:
  * tab-width: 4