From: Michael Wallner <mike@php.net>
Date: Wed, 30 Sep 2015 12:47:07 +0000 (+0200)
Subject: Merge branch 'v1.1.x'
X-Git-Tag: release-2.0.0RC1~7
X-Git-Url: https://git.m6w6.name/?a=commitdiff_plain;h=9cc19c9972c60749d34b5b99f2393f02772b6cb7;p=m6w6%2Fext-raphf

Merge branch 'v1.1.x'
---

9cc19c9972c60749d34b5b99f2393f02772b6cb7
diff --cc README.md
index 34f117e,63b3f63..785297b
--- a/README.md
+++ b/README.md
@@@ -1,6 -1,6 +1,6 @@@
- # pecl/raphf
+ # ext-raphf
  
- ## About:
 -[![Build Status](https://travis-ci.org/m6w6/ext-raphf.svg?branch=v1.1.x)](https://travis-ci.org/m6w6/ext-raphf)
++[![Build Status](https://travis-ci.org/m6w6/ext-raphf.svg?branch=master)](https://travis-ci.org/m6w6/ext-raphf)
  
  The "Resource and Persistent Handle Factory" extension provides facilities to manage those in a convenient manner.
  
diff --cc src/php_raphf_api.c
index 0000000,1de0fc0..f867af6
mode 000000,100644..100644
--- a/src/php_raphf_api.c
+++ b/src/php_raphf_api.c
@@@ -1,0 -1,715 +1,699 @@@
+ /*
+     +--------------------------------------------------------------------+
+     | PECL :: raphf                                                      |
+     +--------------------------------------------------------------------+
+     | Redistribution and use in source and binary forms, with or without |
+     | modification, are permitted provided that the conditions mentioned |
+     | in the accompanying LICENSE file are met.                          |
+     +--------------------------------------------------------------------+
+     | Copyright (c) 2013, Michael Wallner <mike@php.net>                 |
+     +--------------------------------------------------------------------+
+ */
+ 
+ #ifdef HAVE_CONFIG_H
+ #	include "config.h"
+ #endif
+ 
+ #include "php.h"
+ #include "php_ini.h"
+ #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;
+ };
+ 
+ ZEND_BEGIN_MODULE_GLOBALS(raphf)
+ 	struct php_persistent_handle_globals persistent_handle;
+ 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
+ #if PHP_RAPHF_DEBUG_PHANDLES
+ #	undef inline
+ #	define inline
+ #endif
+ 
+ php_resource_factory_t *php_resource_factory_init(php_resource_factory_t *f,
+ 		php_resource_factory_ops_t *fops, void *data, void (*dtor)(void *data))
+ {
+ 	if (!f) {
+ 		f = emalloc(sizeof(*f));
+ 	}
+ 	memset(f, 0, sizeof(*f));
+ 
+ 	memcpy(&f->fops, fops, sizeof(*fops));
+ 
+ 	f->data = data;
+ 	f->dtor = dtor;
+ 
+ 	f->refcount = 1;
+ 
+ 	return f;
+ }
+ 
+ unsigned php_resource_factory_addref(php_resource_factory_t *rf)
+ {
+ 	return ++rf->refcount;
+ }
+ 
+ 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);
+ 		}
+ 	}
+ }
+ 
+ void php_resource_factory_free(php_resource_factory_t **f)
+ {
+ 	if (*f) {
+ 		php_resource_factory_dtor(*f);
+ 		if (!(*f)->refcount) {
+ 			efree(*f);
+ 			*f = NULL;
+ 		}
+ 	}
+ }
+ 
 -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);
+ 	}
+ }
+ 
+ php_resource_factory_t *php_persistent_handle_resource_factory_init(
+ 		php_resource_factory_t *a, php_persistent_handle_factory_t *pf)
+ {
+ 	return php_resource_factory_init(a,
+ 			php_persistent_handle_get_resource_factory_ops(), pf,
+ 			(void(*)(void*)) php_persistent_handle_abandon);
+ }
+ 
+ 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
+ 	pefree(*list, 1);
+ 	*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)
+ {
 -	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 ((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))) {
+ 			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;
+ 
+ #if PHP_RAPHF_DEBUG_PHANDLES
+ 	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);
+ 	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;
+ 			++list->used;
+ 		}
+ 	}
+ 
+ 	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);
+ 		if (list) {
+ 			++list->used;
+ 		}
+ 		++a->provider->list.used;
+ 	}
+ 
+ 	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);
+ 	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;
+ 		--list->used;
+ 	}
+ }
+ 
 -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);
+ 				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) {
+ 			ALLOC_HASHTABLE(ht);
+ 			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;
+ 	}
+ 
+ 	return ht;
+ }
+ 
+ static php_resource_factory_ops_t php_persistent_handle_resource_factory_ops = {
+ 	(php_resource_factory_handle_ctor_t) php_persistent_handle_acquire,
+ 	(php_resource_factory_handle_copy_t) php_persistent_handle_accrete,
+ 	(php_resource_factory_handle_dtor_t) php_persistent_handle_release
+ };
+ 
+ php_resource_factory_ops_t *php_persistent_handle_get_resource_factory_ops(void)
+ {
+ 	return &php_persistent_handle_resource_factory_ops;
+ }
+ 
+ ZEND_BEGIN_ARG_INFO_EX(ai_raphf_stat_persistent_handles, 0, 0, 0)
+ ZEND_END_ARG_INFO();
+ 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);
+ 	}
+ 	RETURN_FALSE;
+ }
+ 
+ ZEND_BEGIN_ARG_INFO_EX(ai_raphf_clean_persistent_handles, 0, 0, 0)
+ 	ZEND_ARG_INFO(0, name)
+ 	ZEND_ARG_INFO(0, ident)
+ 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),
+ 			ai_raphf_stat_persistent_handles, 0)
+ 	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}
+ };
+ 
+ PHP_INI_BEGIN()
+ 	STD_PHP_INI_ENTRY("raphf.persistent_handle.limit", "-1", PHP_INI_SYSTEM,
+ 			OnUpdateLong, persistent_handle.limit, zend_raphf_globals,
+ 			raphf_globals)
+ PHP_INI_END()
+ 
+ static HashTable *php_persistent_handles_global_hash;
+ 
+ static PHP_GINIT_FUNCTION(raphf)
+ {
+ 	raphf_globals->persistent_handle.limit = -1;
+ 
+ 	zend_hash_init(&raphf_globals->persistent_handle.hash, 0, NULL,
+ 			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);
+ 	}
+ }
+ 
+ static PHP_GSHUTDOWN_FUNCTION(raphf)
+ {
+ 	zend_hash_destroy(&raphf_globals->persistent_handle.hash);
+ }
+ 
+ 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), "%u", 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;
+ }
+ 
+ PHP_MINFO_FUNCTION(raphf)
+ {
+ 	php_info_print_table_start();
+ 	php_info_print_table_header(2,
+ 			"Resource and persistent handle factory support", "enabled");
+ 	php_info_print_table_row(2, "Extension version", PHP_RAPHF_VERSION);
+ 	php_info_print_table_end();
+ 
+ 	php_info_print_table_start();
+ 	php_info_print_table_colspan_header(4, "Persistent handles in this "
+ #ifdef ZTS
+ 			"thread"
+ #else
+ 			"process"
+ #endif
+ 	);
+ 	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();
+ 
+ 	DISPLAY_INI_ENTRIES();
+ }
+ 
+ zend_module_entry raphf_module_entry = {
+ 	STANDARD_MODULE_HEADER,
+ 	"raphf",
+ 	raphf_functions,
+ 	PHP_MINIT(raphf),
+ 	PHP_MSHUTDOWN(raphf),
+ 	NULL,
+ 	NULL,
+ 	PHP_MINFO(raphf),
+ 	PHP_RAPHF_VERSION,
+ 	ZEND_MODULE_GLOBALS(raphf),
+ 	PHP_GINIT(raphf),
+ 	PHP_GSHUTDOWN(raphf),
+ 	NULL,
+ 	STANDARD_MODULE_PROPERTIES_EX
+ };
+ /* }}} */
+ 
+ #ifdef COMPILE_DL_RAPHF
+ ZEND_GET_MODULE(raphf)
+ #endif
+ 
 -
+ /*
+  * Local variables:
+  * tab-width: 4
+  * c-basic-offset: 4
+  * End:
+  * vim600: noet sw=4 ts=4 fdm=marker
+  * vim<600: noet sw=4 ts=4
+  */
diff --cc src/php_raphf_api.h
index 0000000,ffc9a03..e9f0581
mode 000000,100644..100644
--- a/src/php_raphf_api.h
+++ b/src/php_raphf_api.h
@@@ -1,0 -1,430 +1,417 @@@
+ /*
+     +--------------------------------------------------------------------+
+     | PECL :: raphf                                                      |
+     +--------------------------------------------------------------------+
+     | Redistribution and use in source and binary forms, with or without |
+     | modification, are permitted provided that the conditions mentioned |
+     | in the accompanying LICENSE file are met.                          |
+     +--------------------------------------------------------------------+
+     | Copyright (c) 2013, Michael Wallner <mike@php.net>                 |
+     +--------------------------------------------------------------------+
+ */
+ 
+ #ifndef PHP_RAPHF_API_H
+ #define PHP_RAPHF_API_H
+ 
++#include "php_raphf.h"
++
+ /**
+  * A resource constructor.
+  *
+  * @param opaque is the \a data from php_persistent_handle_provide()
+  * @param init_arg is the \a init_arg from php_resource_factory_init()
+  * @return the created (persistent) handle
+  */
 -typedef void *(*php_resource_factory_handle_ctor_t)(void *opaque,
 -		void *init_arg TSRMLS_DC);
++typedef void *(*php_resource_factory_handle_ctor_t)(void *opaque, void *init_arg);
+ 
+ /**
+  * The copy constructor of a resource.
+  *
+  * @param opaque the factory's data
+  * @param handle the (persistent) handle to copy
+  */
 -typedef void *(*php_resource_factory_handle_copy_t)(void *opaque,
 -		void *handle TSRMLS_DC);
++typedef void *(*php_resource_factory_handle_copy_t)(void *opaque, void *handle);
+ 
+ /**
+  * The destructor of a resource.
+  *
+  * @param opaque the factory's data
+  * @param handle the handle to destroy
+  */
 -typedef void (*php_resource_factory_handle_dtor_t)(void *opaque,
 -		void *handle TSRMLS_DC);
++typedef void (*php_resource_factory_handle_dtor_t)(void *opaque, void *handle);
+ 
+ /**
+  * The resource ops consisting of a ctor, a copy ctor and a dtor.
+  *
+  * Define this ops and register them with php_persistent_handle_provide()
+  * in MINIT.
+  */
+ typedef struct php_resource_factory_ops {
+ 	/** The resource constructor */
+ 	php_resource_factory_handle_ctor_t ctor;
+ 	/** The resource's copy constructor */
+ 	php_resource_factory_handle_copy_t copy;
+ 	/** The resource's destructor */
+ 	php_resource_factory_handle_dtor_t dtor;
+ } php_resource_factory_ops_t;
+ 
+ /**
+  * The resource factory.
+  */
+ typedef struct php_resource_factory {
+ 	/** The resource ops */
+ 	php_resource_factory_ops_t fops;
+ 	/** Opaque user data */
+ 	void *data;
+ 	/** User data destructor */
+ 	void (*dtor)(void *data);
+ 	/** How often this factory is referenced */
+ 	unsigned refcount;
+ } php_resource_factory_t;
+ 
+ /**
+  * Initialize a resource factory.
+  *
+  * If you register a \a dtor for a resource factory used with a persistent
+  * handle provider, be sure to call php_persistent_handle_cleanup() for your
+  * registered provider in MSHUTDOWN, else the dtor will point to no longer
+  * available memory if the extension has already been unloaded.
+  *
+  * @param f the factory to initialize; if NULL allocated on the heap
+  * @param fops the resource ops to assign to the factory
+  * @param data opaque user data; may be NULL
+  * @param dtor a destructor for the data; may be NULL
+  * @return \a f or an allocated resource factory
+  */
+ PHP_RAPHF_API php_resource_factory_t *php_resource_factory_init(
+ 		php_resource_factory_t *f, php_resource_factory_ops_t *fops, void *data,
+ 		void (*dtor)(void *data));
+ 
+ /**
+  * Increase the refcount of the resource factory.
+  *
+  * @param rf the resource factory
+  * @return the new refcount
+  */
+ PHP_RAPHF_API unsigned php_resource_factory_addref(php_resource_factory_t *rf);
+ 
+ /**
+  * Destroy the resource factory.
+  *
+  * If the factory's refcount reaches 0, the \a dtor for \a data is called.
+  *
+  * @param f the resource factory
+  */
+ PHP_RAPHF_API void php_resource_factory_dtor(php_resource_factory_t *f);
+ 
+ /**
+  * Destroy and free the resource factory.
+  *
 - * Calls php_resource_factory_dtor() and frees \æ f if the factory's refcount
++ * Calls php_resource_factory_dtor() and frees \a f if the factory's refcount
+  * reached 0.
+  *
+  * @param f the resource factory
+  */
+ PHP_RAPHF_API void php_resource_factory_free(php_resource_factory_t **f);
+ 
+ /**
+  * Construct a resource by the resource factory \a f
+  *
+  * @param f the resource factory
+  * @param init_arg for the resource constructor
+  * @return the new resource
+  */
+ PHP_RAPHF_API void *php_resource_factory_handle_ctor(php_resource_factory_t *f,
 -		void *init_arg TSRMLS_DC);
++		void *init_arg);
+ 
+ /**
+  * Create a copy of the resource \a handle
+  *
+  * @param f the resource factory
+  * @param handle the resource to copy
+  * @return the copy
+  */
+ PHP_RAPHF_API void *php_resource_factory_handle_copy(php_resource_factory_t *f,
 -		void *handle TSRMLS_DC);
++		void *handle);
+ 
+ /**
+  * Destroy (and free) the resource
+  *
+  * @param f the resource factory
+  * @param handle the resource to destroy
+  */
+ PHP_RAPHF_API void php_resource_factory_handle_dtor(php_resource_factory_t *f,
 -		void *handle TSRMLS_DC);
++		void *handle);
+ 
+ /**
+  * Persistent handles storage
+  */
+ typedef struct php_persistent_handle_list {
+ 	/** Storage of free resources */
+ 	HashTable free;
+ 	/** Count of acquired resources */
+ 	ulong used;
+ } php_persistent_handle_list_t;
+ 
+ /**
+  * Definition of a persistent handle provider.
+  * Holds a resource factory an a persistent handle list.
+  */
+ typedef struct php_persistent_handle_provider {
+ 	 /**
+ 	  * The list of free handles.
+ 	  * Hash of "ident" => array(handles) entries. Persistent handles are
+ 	  * acquired out of this list.
+ 	  */
+ 	php_persistent_handle_list_t list;
+ 
+ 	/**
+ 	 * The resource factory.
+ 	 * New handles are created by this factory.
+ 	 */
+ 	php_resource_factory_t rf;
+ } php_persistent_handle_provider_t;
+ 
+ typedef struct php_persistent_handle_factory php_persistent_handle_factory_t;
+ 
+ /**
+  * Wakeup the persistent handle on re-acquisition.
+  */
+ typedef void (*php_persistent_handle_wakeup_t)(
 -		php_persistent_handle_factory_t *f, void **handle TSRMLS_DC);
++		php_persistent_handle_factory_t *f, void **handle);
+ /**
+  * Retire the persistent handle on release.
+  */
+ typedef void (*php_persistent_handle_retire_t)(
 -		php_persistent_handle_factory_t *f, void **handle TSRMLS_DC);
++		php_persistent_handle_factory_t *f, void **handle);
+ 
+ /**
+  * Definition of a persistent handle factory.
+  *
+  * php_persistent_handle_concede() will return a pointer to a
 - * php_persistent_handle_factory if a provider for the \a name_str has
++ * php_persistent_handle_factory if a provider for the \a name has
+  * been registered with php_persistent_handle_provide().
+  */
+ struct php_persistent_handle_factory {
+ 	/** The persistent handle provider */
+ 	php_persistent_handle_provider_t *provider;
+ 	/** The persistent handle wakeup routine; may be NULL */
+ 	php_persistent_handle_wakeup_t wakeup;
+ 	/** The persistent handle retire routine; may be NULL */
+ 	php_persistent_handle_retire_t retire;
+ 
+ 	/** The ident for which this factory manages resources */
 -	struct {
 -		/** ident string */
 -		char *str;
 -		/** ident length */
 -		size_t len;
 -	} ident;
++	zend_string *ident;
+ 
+ 	/** Whether it has to be free'd on php_persistent_handle_abandon() */
+ 	unsigned free_on_abandon:1;
+ };
+ 
+ /**
+  * Register a persistent handle provider in MINIT.
+  *
+  * Registers a factory provider for \a name_str with \a fops resource factory
+  * ops. Call this in your MINIT.
+  *
+  * A php_resource_factory will be created with \a fops, \a data and \a dtor
+  * and will be stored together with a php_persistent_handle_list in the global
+  * raphf hash.
+  *
+  * A php_persistent_handle_factory can then be retrieved by
+  * php_persistent_handle_concede() at runtime.
+  *
 - * @param name_str the provider name, e.g. "http\Client\Curl"
 - * @param name_len the provider name length, e.g. strlen("http\Client\Curl")
++ * @param name the provider name, e.g. "http\Client\Curl"
+  * @param fops the resource factory ops
+  * @param data opaque user data
+  * @param dtor \a data destructor
+  * @return SUCCESS/FAILURE
+  */
 -PHP_RAPHF_API int /* SUCCESS|FAILURE */ 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);
++PHP_RAPHF_API ZEND_RESULT_CODE php_persistent_handle_provide(
++		zend_string *name, php_resource_factory_ops_t *fops,
++		void *data, void (*dtor)(void *));
+ 
+ /**
+  * Retrieve a persistent handle factory at runtime.
+  *
 - * If a persistent handle provider has been registered for \a name_str, a new
 - * php_persistent_handle_factory creating resources in the \a ident_str
++ * If a persistent handle provider has been registered for \a name, a new
++ * php_persistent_handle_factory creating resources in the \a ident
+  * namespace will be constructed.
+  *
+  * The wakeup routine \a wakeup and the retire routine \a retire will be
+  * assigned to the new php_persistent_handle_factory.
+  *
+  * @param a pointer to a factory; allocated on the heap if NULL
 - * @param name_str the provider name, e.g. "http\Client\Curl"
 - * @param name_len the provider name length, e.g. strlen("http\Client\Curl")
 - * @param ident_str the subsidiary namespace, e.g. "php.net:80"
 - * @param ident_len the subsidiary namespace lenght, e.g. strlen("php.net:80")
++ * @param name the provider name, e.g. "http\Client\Curl"
++ * @param ident the subsidiary namespace, e.g. "php.net:80"
+  * @param wakeup any persistent handle wakeup routine
+  * @param retire any persistent handle retire routine
+  * @return \a a or an allocated persistent handle factory
+  */
+ PHP_RAPHF_API 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);
+ 
+ /**
+  * Abandon the persistent handle factory.
+  *
+  * Destroy a php_persistent_handle_factory created by
+  * php_persistent_handle_concede(). If the memory for the factory was allocated,
+  * it will automatically be free'd.
+  *
+  * @param a the persistent handle factory to destroy
+  */
+ PHP_RAPHF_API void php_persistent_handle_abandon(
+ 		php_persistent_handle_factory_t *a);
+ 
+ /**
+  * Acquire a persistent handle.
+  *
+  * That is, either re-use a resource from the free list or create a new handle.
+  *
+  * If a handle is acquired from the free list, the
+  * php_persistent_handle_factory::wakeup callback will be executed for that
+  * handle.
+  *
+  * @param a the persistent handle factory
+  * @param init_arg the \a init_arg for php_resource_factory_handle_ctor()
+  * @return the acquired resource
+  */
+ PHP_RAPHF_API void *php_persistent_handle_acquire(
 -		php_persistent_handle_factory_t *a, void *init_arg TSRMLS_DC);
++		php_persistent_handle_factory_t *a, void *init_arg);
+ 
+ /**
+  * Release a persistent handle.
+  *
+  * That is, either put it back into the free list for later re-use or clean it
+  * up with php_resource_factory_handle_dtor().
+  *
+  * If a handle is put back into the free list, the
+  * php_persistent_handle_factory::retire callback will be executed for that
+  * handle.
+  *
+  * @param a the persistent handle factory
+  * @param handle the handle to release
+  */
+ PHP_RAPHF_API void php_persistent_handle_release(
 -		php_persistent_handle_factory_t *a, void *handle TSRMLS_DC);
++		php_persistent_handle_factory_t *a, void *handle);
+ 
+ /**
+  * Copy a persistent handle.
+  *
+  * Let the underlying resource factory copy the \a handle.
+  *
+  * @param a the persistent handle factory
+  * @param handle the resource to accrete
+  */
+ PHP_RAPHF_API void *php_persistent_handle_accrete(
 -		php_persistent_handle_factory_t *a, void *handle TSRMLS_DC);
++		php_persistent_handle_factory_t *a, void *handle);
+ 
+ /**
+  * Retrieve persistent handle resource factory ops.
+  *
+  * These ops can be used to mask a persistent handle factory as
+  * resource factory itself, so you can transparently use the
+  * resource factory API, both for persistent and non-persistent
+  * ressources.
+  *
+  * Example:
+  * \code{.c}
 - * php_resource_factory_t *create_my_rf(const char *persistent_id_str,
 - *                                      size_t persistent_id_len TSRMLS_DC)
++ * php_resource_factory_t *create_my_rf(zend_string *persistent_id)
+  * {
+  *     php_resource_factory_t *rf;
+  *
 - *     if (persistent_id_str) {
++ *     if (persistent_id) {
+  *         php_persistent_handle_factory_t *pf;
+  *         php_resource_factory_ops_t *ops;
++ *         zend_string *ns = zend_string_init("my", 2, 1);
+  *
+  *         ops = php_persistent_handle_get_resource_factory_ops();
 - *
 - *         pf = php_persistent_handle_concede(NULL, "my", 2,
 - *             persistent_id_str, persistent_id_len, NULL, NULL TSRMLS_CC);
 - *
++ *         pf = php_persistent_handle_concede(NULL, ns, persistent_id, NULL, NULL);
+  *         rf = php_persistent_handle_resource_factory_init(NULL, pf);
++ *         zend_string_release(ns);
+  *     } else {
+  *         rf = php_resource_factory_init(NULL, &myops, NULL, NULL);
+  *     }
+  *     return rf;
+  * }
+  * \endcode
+  */
+ PHP_RAPHF_API php_resource_factory_ops_t *
+ php_persistent_handle_get_resource_factory_ops(void);
+ 
+ /**
+  * Create a resource factory for persistent handles.
+  *
+  * This will create a resource factory with persistent handle ops, which wraps
+  * the provided reource factory \a pf.
+  *
+  * @param a the persistent handle resource factory to initialize
+  * @param pf the resource factory to wrap
+  */
+ PHP_RAPHF_API php_resource_factory_t *
+ php_persistent_handle_resource_factory_init(php_resource_factory_t *a,
+ 		php_persistent_handle_factory_t *pf);
+ 
+ /**
+  * Check whether a resource factory is a persistent handle resource factory.
+  *
+  * @param a the resource factory to check
+  */
+ PHP_RAPHF_API zend_bool php_resource_factory_is_persistent(
+ 		php_resource_factory_t *a);
+ 
+ /**
+  * Clean persistent handles up.
+  *
 - * Destroy persistent handles of provider \a name_str and in subsidiary
 - * namespace \a ident_str.
++ * Destroy persistent handles of provider \a name and in subsidiary
++ * namespace \a ident.
+  *
 - * If \a name_str is NULL, all persistent handles of all providers with a
 - * matching \a ident_str will be cleaned up.
++ * If \a name is NULL, all persistent handles of all providers with a
++ * matching \a ident will be cleaned up.
+  *
 - * If \a ident_str is NULL all persistent handles of the provider will be
++ * If \a identr is NULL all persistent handles of the provider will be
+  * cleaned up.
+  *
 - * Ergo, if both, \a name_str and \a ident_str are NULL, then all
++ * Ergo, if both, \a name and \a ident are NULL, then all
+  * persistent handles will be cleaned up.
+  *
+  * You must call this in MSHUTDOWN, if your resource factory ops hold a
+  * registered php_resource_factory::dtor, else the dtor will point to
+  * memory not any more available if the extension has already been unloaded.
+  *
 - * @param name_str the provider name; may be NULL
 - * @param name_len the provider name length
 - * @param ident_str the subsidiary namespace name; may be NULL
 - * @param ident_len the subsidiary namespace name length
++ * @param name the provider name; may be NULL
++ * @param ident the subsidiary namespace name; may be NULL
+  */
 -PHP_RAPHF_API void php_persistent_handle_cleanup(const char *name_str,
 -		size_t name_len, const char *ident_str, size_t ident_len TSRMLS_DC);
++PHP_RAPHF_API void php_persistent_handle_cleanup(zend_string *name,
++		zend_string *ident);
+ 
+ /**
+  * Retrieve statistics about the current process/thread's persistent handles.
+  *
+  * @return a HashTable like:
+  * \code
+  *     [
+  *         "name" => [
+  *             "ident" => [
+  *                 "used" => 1,
+  *                 "free" => 0,
+  *             ]
+  *         ]
+  *     ]
+  * \endcode
+  */
 -PHP_RAPHF_API HashTable *php_persistent_handle_statall(HashTable *ht TSRMLS_DC);
++PHP_RAPHF_API HashTable *php_persistent_handle_statall(HashTable *ht);
+ 
+ #endif	/* PHP_RAPHF_API_H */
+ 
+ 
+ /*
+  * Local variables:
+  * tab-width: 4
+  * c-basic-offset: 4
+  * End:
+  * vim600: noet sw=4 ts=4 fdm=marker
+  * vim<600: noet sw=4 ts=4
+  */