xref: /PHP-7.1/ext/standard/user_filters.c (revision ccd4716e)
1 /*
2    +----------------------------------------------------------------------+
3    | PHP Version 7                                                        |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1997-2018 The PHP Group                                |
6    +----------------------------------------------------------------------+
7    | This source file is subject to version 3.01 of the PHP license,      |
8    | that is bundled with this package in the file LICENSE, and is        |
9    | available through the world-wide-web at the following url:           |
10    | http://www.php.net/license/3_01.txt                                  |
11    | If you did not receive a copy of the PHP license and are unable to   |
12    | obtain it through the world-wide-web, please send a note to          |
13    | license@php.net so we can mail you a copy immediately.               |
14    +----------------------------------------------------------------------+
15    | Authors:                                                             |
16    | Wez Furlong (wez@thebrainroom.com)                                   |
17    | Sara Golemon (pollita@php.net)                                       |
18    +----------------------------------------------------------------------+
19 */
20 
21 /* $Id$ */
22 
23 #include "php.h"
24 #include "php_globals.h"
25 #include "ext/standard/basic_functions.h"
26 #include "ext/standard/file.h"
27 
28 #define PHP_STREAM_BRIGADE_RES_NAME	"userfilter.bucket brigade"
29 #define PHP_STREAM_BUCKET_RES_NAME "userfilter.bucket"
30 #define PHP_STREAM_FILTER_RES_NAME "userfilter.filter"
31 
32 struct php_user_filter_data {
33 	zend_class_entry *ce;
34 	/* variable length; this *must* be last in the structure */
35 	zend_string *classname;
36 };
37 
38 /* to provide context for calling into the next filter from user-space */
39 static int le_userfilters;
40 static int le_bucket_brigade;
41 static int le_bucket;
42 
43 /* define the base filter class */
44 
PHP_FUNCTION(user_filter_nop)45 PHP_FUNCTION(user_filter_nop)
46 {
47 }
48 ZEND_BEGIN_ARG_INFO(arginfo_php_user_filter_filter, 0)
49 	ZEND_ARG_INFO(0, in)
50 	ZEND_ARG_INFO(0, out)
51 	ZEND_ARG_INFO(1, consumed)
52 	ZEND_ARG_INFO(0, closing)
53 ZEND_END_ARG_INFO()
54 
55 ZEND_BEGIN_ARG_INFO(arginfo_php_user_filter_onCreate, 0)
56 ZEND_END_ARG_INFO()
57 
58 ZEND_BEGIN_ARG_INFO(arginfo_php_user_filter_onClose, 0)
59 ZEND_END_ARG_INFO()
60 
61 static const zend_function_entry user_filter_class_funcs[] = {
62 	PHP_NAMED_FE(filter,	PHP_FN(user_filter_nop),		arginfo_php_user_filter_filter)
63 	PHP_NAMED_FE(onCreate,	PHP_FN(user_filter_nop),		arginfo_php_user_filter_onCreate)
64 	PHP_NAMED_FE(onClose,	PHP_FN(user_filter_nop),		arginfo_php_user_filter_onClose)
65 	PHP_FE_END
66 };
67 
68 static zend_class_entry user_filter_class_entry;
69 
ZEND_RSRC_DTOR_FUNC(php_bucket_dtor)70 static ZEND_RSRC_DTOR_FUNC(php_bucket_dtor)
71 {
72 	php_stream_bucket *bucket = (php_stream_bucket *)res->ptr;
73 	if (bucket) {
74 		php_stream_bucket_delref(bucket);
75 		bucket = NULL;
76 	}
77 }
78 
PHP_MINIT_FUNCTION(user_filters)79 PHP_MINIT_FUNCTION(user_filters)
80 {
81 	zend_class_entry *php_user_filter;
82 	/* init the filter class ancestor */
83 	INIT_CLASS_ENTRY(user_filter_class_entry, "php_user_filter", user_filter_class_funcs);
84 	if ((php_user_filter = zend_register_internal_class(&user_filter_class_entry)) == NULL) {
85 		return FAILURE;
86 	}
87 	zend_declare_property_string(php_user_filter, "filtername", sizeof("filtername")-1, "", ZEND_ACC_PUBLIC);
88 	zend_declare_property_string(php_user_filter, "params", sizeof("params")-1, "", ZEND_ACC_PUBLIC);
89 
90 	/* init the filter resource; it has no dtor, as streams will always clean it up
91 	 * at the correct time */
92 	le_userfilters = zend_register_list_destructors_ex(NULL, NULL, PHP_STREAM_FILTER_RES_NAME, 0);
93 
94 	if (le_userfilters == FAILURE) {
95 		return FAILURE;
96 	}
97 
98 	/* Filters will dispose of their brigades */
99 	le_bucket_brigade = zend_register_list_destructors_ex(NULL, NULL, PHP_STREAM_BRIGADE_RES_NAME, module_number);
100 	/* Brigades will dispose of their buckets */
101 	le_bucket = zend_register_list_destructors_ex(php_bucket_dtor, NULL, PHP_STREAM_BUCKET_RES_NAME, module_number);
102 
103 	if (le_bucket_brigade == FAILURE) {
104 		return FAILURE;
105 	}
106 
107 	REGISTER_LONG_CONSTANT("PSFS_PASS_ON",			PSFS_PASS_ON,			CONST_CS | CONST_PERSISTENT);
108 	REGISTER_LONG_CONSTANT("PSFS_FEED_ME",			PSFS_FEED_ME,			CONST_CS | CONST_PERSISTENT);
109 	REGISTER_LONG_CONSTANT("PSFS_ERR_FATAL",		PSFS_ERR_FATAL,			CONST_CS | CONST_PERSISTENT);
110 
111 	REGISTER_LONG_CONSTANT("PSFS_FLAG_NORMAL",		PSFS_FLAG_NORMAL,		CONST_CS | CONST_PERSISTENT);
112 	REGISTER_LONG_CONSTANT("PSFS_FLAG_FLUSH_INC",	PSFS_FLAG_FLUSH_INC,	CONST_CS | CONST_PERSISTENT);
113 	REGISTER_LONG_CONSTANT("PSFS_FLAG_FLUSH_CLOSE",	PSFS_FLAG_FLUSH_CLOSE,	CONST_CS | CONST_PERSISTENT);
114 
115 	return SUCCESS;
116 }
117 
PHP_RSHUTDOWN_FUNCTION(user_filters)118 PHP_RSHUTDOWN_FUNCTION(user_filters)
119 {
120 	if (BG(user_filter_map)) {
121 		zend_hash_destroy(BG(user_filter_map));
122 		efree(BG(user_filter_map));
123 		BG(user_filter_map) = NULL;
124 	}
125 
126 	return SUCCESS;
127 }
128 
userfilter_dtor(php_stream_filter * thisfilter)129 static void userfilter_dtor(php_stream_filter *thisfilter)
130 {
131 	zval *obj = &thisfilter->abstract;
132 	zval func_name;
133 	zval retval;
134 
135 	if (obj == NULL) {
136 		/* If there's no object associated then there's nothing to dispose of */
137 		return;
138 	}
139 
140 	ZVAL_STRINGL(&func_name, "onclose", sizeof("onclose")-1);
141 
142 	call_user_function_ex(NULL,
143 			obj,
144 			&func_name,
145 			&retval,
146 			0, NULL,
147 			0, NULL);
148 
149 	zval_ptr_dtor(&retval);
150 	zval_ptr_dtor(&func_name);
151 
152 	/* kill the object */
153 	zval_ptr_dtor(obj);
154 }
155 
userfilter_filter(php_stream * stream,php_stream_filter * thisfilter,php_stream_bucket_brigade * buckets_in,php_stream_bucket_brigade * buckets_out,size_t * bytes_consumed,int flags)156 php_stream_filter_status_t userfilter_filter(
157 			php_stream *stream,
158 			php_stream_filter *thisfilter,
159 			php_stream_bucket_brigade *buckets_in,
160 			php_stream_bucket_brigade *buckets_out,
161 			size_t *bytes_consumed,
162 			int flags
163 			)
164 {
165 	int ret = PSFS_ERR_FATAL;
166 	zval *obj = &thisfilter->abstract;
167 	zval func_name;
168 	zval retval;
169 	zval args[4];
170 	zval zpropname;
171 	int call_result;
172 
173 	/* the userfilter object probably doesn't exist anymore */
174 	if (CG(unclean_shutdown)) {
175 		return ret;
176 	}
177 
178 	if (!zend_hash_str_exists_ind(Z_OBJPROP_P(obj), "stream", sizeof("stream")-1)) {
179 		zval tmp;
180 
181 		/* Give the userfilter class a hook back to the stream */
182 		php_stream_to_zval(stream, &tmp);
183 		zval_copy_ctor(&tmp);
184 		add_property_zval(obj, "stream", &tmp);
185 		/* add_property_zval increments the refcount which is unwanted here */
186 		zval_ptr_dtor(&tmp);
187 	}
188 
189 	ZVAL_STRINGL(&func_name, "filter", sizeof("filter")-1);
190 
191 	/* Setup calling arguments */
192 	ZVAL_RES(&args[0], zend_register_resource(buckets_in, le_bucket_brigade));
193 	ZVAL_RES(&args[1], zend_register_resource(buckets_out, le_bucket_brigade));
194 
195 	if (bytes_consumed) {
196 		ZVAL_LONG(&args[2], *bytes_consumed);
197 	} else {
198 		ZVAL_NULL(&args[2]);
199 	}
200 
201 	ZVAL_BOOL(&args[3], flags & PSFS_FLAG_FLUSH_CLOSE);
202 
203 	call_result = call_user_function_ex(NULL,
204 			obj,
205 			&func_name,
206 			&retval,
207 			4, args,
208 			0, NULL);
209 
210 	zval_ptr_dtor(&func_name);
211 
212 	if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
213 		convert_to_long(&retval);
214 		ret = (int)Z_LVAL(retval);
215 	} else if (call_result == FAILURE) {
216 		php_error_docref(NULL, E_WARNING, "failed to call filter function");
217 	}
218 
219 	if (bytes_consumed) {
220 		*bytes_consumed = zval_get_long(&args[2]);
221 	}
222 
223 	if (buckets_in->head) {
224 		php_stream_bucket *bucket = buckets_in->head;
225 
226 		php_error_docref(NULL, E_WARNING, "Unprocessed filter buckets remaining on input brigade");
227 		while ((bucket = buckets_in->head)) {
228 			/* Remove unconsumed buckets from the brigade */
229 			php_stream_bucket_unlink(bucket);
230 			php_stream_bucket_delref(bucket);
231 		}
232 	}
233 	if (ret != PSFS_PASS_ON) {
234 		php_stream_bucket *bucket = buckets_out->head;
235 		while (bucket != NULL) {
236 			php_stream_bucket_unlink(bucket);
237 			php_stream_bucket_delref(bucket);
238 			bucket = buckets_out->head;
239 		}
240 	}
241 
242 	/* filter resources are cleaned up by the stream destructor,
243 	 * keeping a reference to the stream resource here would prevent it
244 	 * from being destroyed properly */
245 	ZVAL_STRINGL(&zpropname, "stream", sizeof("stream")-1);
246 	Z_OBJ_HANDLER_P(obj, unset_property)(obj, &zpropname, NULL);
247 	zval_ptr_dtor(&zpropname);
248 
249 	zval_ptr_dtor(&args[3]);
250 	zval_ptr_dtor(&args[2]);
251 	zval_ptr_dtor(&args[1]);
252 	zval_ptr_dtor(&args[0]);
253 
254 	return ret;
255 }
256 
257 static php_stream_filter_ops userfilter_ops = {
258 	userfilter_filter,
259 	userfilter_dtor,
260 	"user-filter"
261 };
262 
user_filter_factory_create(const char * filtername,zval * filterparams,int persistent)263 static php_stream_filter *user_filter_factory_create(const char *filtername,
264 		zval *filterparams, int persistent)
265 {
266 	struct php_user_filter_data *fdat = NULL;
267 	php_stream_filter *filter;
268 	zval obj, zfilter;
269 	zval func_name;
270 	zval retval;
271 	size_t len;
272 
273 	/* some sanity checks */
274 	if (persistent) {
275 		php_error_docref(NULL, E_WARNING,
276 				"cannot use a user-space filter with a persistent stream");
277 		return NULL;
278 	}
279 
280 	len = strlen(filtername);
281 
282 	/* determine the classname/class entry */
283 	if (NULL == (fdat = zend_hash_str_find_ptr(BG(user_filter_map), (char*)filtername, len))) {
284 		char *period;
285 
286 		/* Userspace Filters using ambiguous wildcards could cause problems.
287            i.e.: myfilter.foo.bar will always call into myfilter.foo.*
288                  never seeing myfilter.*
289            TODO: Allow failed userfilter creations to continue
290                  scanning through the list */
291 		if ((period = strrchr(filtername, '.'))) {
292 			char *wildcard = safe_emalloc(len, 1, 3);
293 
294 			/* Search for wildcard matches instead */
295 			memcpy(wildcard, filtername, len + 1); /* copy \0 */
296 			period = wildcard + (period - filtername);
297 			while (period) {
298 				*period = '\0';
299 				strncat(wildcard, ".*", 2);
300 				if (NULL != (fdat = zend_hash_str_find_ptr(BG(user_filter_map), wildcard, strlen(wildcard)))) {
301 					period = NULL;
302 				} else {
303 					*period = '\0';
304 					period = strrchr(wildcard, '.');
305 				}
306 			}
307 			efree(wildcard);
308 		}
309 		if (fdat == NULL) {
310 			php_error_docref(NULL, E_WARNING,
311 					"Err, filter \"%s\" is not in the user-filter map, but somehow the user-filter-factory was invoked for it!?", filtername);
312 			return NULL;
313 		}
314 	}
315 
316 	/* bind the classname to the actual class */
317 	if (fdat->ce == NULL) {
318 		if (NULL == (fdat->ce = zend_lookup_class(fdat->classname))) {
319 			php_error_docref(NULL, E_WARNING,
320 					"user-filter \"%s\" requires class \"%s\", but that class is not defined",
321 					filtername, ZSTR_VAL(fdat->classname));
322 			return NULL;
323 		}
324 	}
325 
326 	filter = php_stream_filter_alloc(&userfilter_ops, NULL, 0);
327 	if (filter == NULL) {
328 		return NULL;
329 	}
330 
331 	/* create the object */
332 	object_init_ex(&obj, fdat->ce);
333 
334 	/* filtername */
335 	add_property_string(&obj, "filtername", (char*)filtername);
336 
337 	/* and the parameters, if any */
338 	if (filterparams) {
339 		add_property_zval(&obj, "params", filterparams);
340 	} else {
341 		add_property_null(&obj, "params");
342 	}
343 
344 	/* invoke the constructor */
345 	ZVAL_STRINGL(&func_name, "oncreate", sizeof("oncreate")-1);
346 
347 	call_user_function_ex(NULL,
348 			&obj,
349 			&func_name,
350 			&retval,
351 			0, NULL,
352 			0, NULL);
353 
354 	if (Z_TYPE(retval) != IS_UNDEF) {
355 		if (Z_TYPE(retval) == IS_FALSE) {
356 			/* User reported filter creation error "return false;" */
357 			zval_ptr_dtor(&retval);
358 
359 			/* Kill the filter (safely) */
360 			ZVAL_UNDEF(&filter->abstract);
361 			php_stream_filter_free(filter);
362 
363 			/* Kill the object */
364 			zval_ptr_dtor(&obj);
365 
366 			/* Report failure to filter_alloc */
367 			return NULL;
368 		}
369 		zval_ptr_dtor(&retval);
370 	}
371 	zval_ptr_dtor(&func_name);
372 
373 	/* set the filter property, this will be used during cleanup */
374 	ZVAL_RES(&zfilter, zend_register_resource(filter, le_userfilters));
375 	ZVAL_COPY_VALUE(&filter->abstract, &obj);
376 	add_property_zval(&obj, "filter", &zfilter);
377 	/* add_property_zval increments the refcount which is unwanted here */
378 	zval_ptr_dtor(&zfilter);
379 
380 	return filter;
381 }
382 
383 static php_stream_filter_factory user_filter_factory = {
384 	user_filter_factory_create
385 };
386 
filter_item_dtor(zval * zv)387 static void filter_item_dtor(zval *zv)
388 {
389 	struct php_user_filter_data *fdat = Z_PTR_P(zv);
390 	zend_string_release(fdat->classname);
391 	efree(fdat);
392 }
393 
394 /* {{{ proto object stream_bucket_make_writeable(resource brigade)
395    Return a bucket object from the brigade for operating on */
PHP_FUNCTION(stream_bucket_make_writeable)396 PHP_FUNCTION(stream_bucket_make_writeable)
397 {
398 	zval *zbrigade, zbucket;
399 	php_stream_bucket_brigade *brigade;
400 	php_stream_bucket *bucket;
401 
402 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &zbrigade) == FAILURE) {
403 		RETURN_FALSE;
404 	}
405 
406 	if ((brigade = (php_stream_bucket_brigade*)zend_fetch_resource(
407 					Z_RES_P(zbrigade), PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade)) == NULL) {
408 		RETURN_FALSE;
409 	}
410 
411 	ZVAL_NULL(return_value);
412 
413 	if (brigade->head && (bucket = php_stream_bucket_make_writeable(brigade->head))) {
414 		ZVAL_RES(&zbucket, zend_register_resource(bucket, le_bucket));
415 		object_init(return_value);
416 		add_property_zval(return_value, "bucket", &zbucket);
417 		/* add_property_zval increments the refcount which is unwanted here */
418 		zval_ptr_dtor(&zbucket);
419 		add_property_stringl(return_value, "data", bucket->buf, bucket->buflen);
420 		add_property_long(return_value, "datalen", bucket->buflen);
421 	}
422 }
423 /* }}} */
424 
425 /* {{{ php_stream_bucket_attach */
php_stream_bucket_attach(int append,INTERNAL_FUNCTION_PARAMETERS)426 static void php_stream_bucket_attach(int append, INTERNAL_FUNCTION_PARAMETERS)
427 {
428 	zval *zbrigade, *zobject;
429 	zval *pzbucket, *pzdata;
430 	php_stream_bucket_brigade *brigade;
431 	php_stream_bucket *bucket;
432 
433 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ro", &zbrigade, &zobject) == FAILURE) {
434 		RETURN_FALSE;
435 	}
436 
437 	if (NULL == (pzbucket = zend_hash_str_find(Z_OBJPROP_P(zobject), "bucket", sizeof("bucket")-1))) {
438 		php_error_docref(NULL, E_WARNING, "Object has no bucket property");
439 		RETURN_FALSE;
440 	}
441 
442 	if ((brigade = (php_stream_bucket_brigade*)zend_fetch_resource(
443 					Z_RES_P(zbrigade), PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade)) == NULL) {
444 		RETURN_FALSE;
445 	}
446 
447 	if ((bucket = (php_stream_bucket *)zend_fetch_resource_ex(pzbucket, PHP_STREAM_BUCKET_RES_NAME, le_bucket)) == NULL) {
448 		RETURN_FALSE;
449 	}
450 
451 	if (NULL != (pzdata = zend_hash_str_find(Z_OBJPROP_P(zobject), "data", sizeof("data")-1)) && Z_TYPE_P(pzdata) == IS_STRING) {
452 		if (!bucket->own_buf) {
453 			bucket = php_stream_bucket_make_writeable(bucket);
454 		}
455 		if (bucket->buflen != Z_STRLEN_P(pzdata)) {
456 			bucket->buf = perealloc(bucket->buf, Z_STRLEN_P(pzdata), bucket->is_persistent);
457 			bucket->buflen = Z_STRLEN_P(pzdata);
458 		}
459 		memcpy(bucket->buf, Z_STRVAL_P(pzdata), bucket->buflen);
460 	}
461 
462 	if (append) {
463 		php_stream_bucket_append(brigade, bucket);
464 	} else {
465 		php_stream_bucket_prepend(brigade, bucket);
466 	}
467 	/* This is a hack necessary to accommodate situations where bucket is appended to the stream
468  	 * multiple times. See bug35916.phpt for reference.
469 	 */
470 	if (bucket->refcount == 1) {
471 		bucket->refcount++;
472 	}
473 }
474 /* }}} */
475 
476 /* {{{ proto void stream_bucket_prepend(resource brigade, object bucket)
477    Prepend bucket to brigade */
PHP_FUNCTION(stream_bucket_prepend)478 PHP_FUNCTION(stream_bucket_prepend)
479 {
480 	php_stream_bucket_attach(0, INTERNAL_FUNCTION_PARAM_PASSTHRU);
481 }
482 /* }}} */
483 
484 /* {{{ proto void stream_bucket_append(resource brigade, object bucket)
485    Append bucket to brigade */
PHP_FUNCTION(stream_bucket_append)486 PHP_FUNCTION(stream_bucket_append)
487 {
488 	php_stream_bucket_attach(1, INTERNAL_FUNCTION_PARAM_PASSTHRU);
489 }
490 /* }}} */
491 
492 /* {{{ proto resource stream_bucket_new(resource stream, string buffer)
493    Create a new bucket for use on the current stream */
PHP_FUNCTION(stream_bucket_new)494 PHP_FUNCTION(stream_bucket_new)
495 {
496 	zval *zstream, zbucket;
497 	php_stream *stream;
498 	char *buffer;
499 	char *pbuffer;
500 	size_t buffer_len;
501 	php_stream_bucket *bucket;
502 
503 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs", &zstream, &buffer, &buffer_len) == FAILURE) {
504 		RETURN_FALSE;
505 	}
506 
507 	php_stream_from_zval(stream, zstream);
508 
509 	if (!(pbuffer = pemalloc(buffer_len, php_stream_is_persistent(stream)))) {
510 		RETURN_FALSE;
511 	}
512 
513 	memcpy(pbuffer, buffer, buffer_len);
514 
515 	bucket = php_stream_bucket_new(stream, pbuffer, buffer_len, 1, php_stream_is_persistent(stream));
516 
517 	if (bucket == NULL) {
518 		RETURN_FALSE;
519 	}
520 
521 	ZVAL_RES(&zbucket, zend_register_resource(bucket, le_bucket));
522 	object_init(return_value);
523 	add_property_zval(return_value, "bucket", &zbucket);
524 	/* add_property_zval increments the refcount which is unwanted here */
525 	zval_ptr_dtor(&zbucket);
526 	add_property_stringl(return_value, "data", bucket->buf, bucket->buflen);
527 	add_property_long(return_value, "datalen", bucket->buflen);
528 }
529 /* }}} */
530 
531 /* {{{ proto array stream_get_filters(void)
532    Returns a list of registered filters */
PHP_FUNCTION(stream_get_filters)533 PHP_FUNCTION(stream_get_filters)
534 {
535 	zend_string *filter_name;
536 	HashTable *filters_hash;
537 
538 	if (zend_parse_parameters_none() == FAILURE) {
539 		return;
540 	}
541 
542 	array_init(return_value);
543 
544 	filters_hash = php_get_stream_filters_hash();
545 
546 	if (filters_hash) {
547 		ZEND_HASH_FOREACH_STR_KEY(filters_hash, filter_name) {
548 			if (filter_name) {
549 				add_next_index_str(return_value, zend_string_copy(filter_name));
550 			}
551 		} ZEND_HASH_FOREACH_END();
552 	}
553 	/* It's okay to return an empty array if no filters are registered */
554 }
555 /* }}} */
556 
557 /* {{{ proto bool stream_filter_register(string filtername, string classname)
558    Registers a custom filter handler class */
PHP_FUNCTION(stream_filter_register)559 PHP_FUNCTION(stream_filter_register)
560 {
561 	zend_string *filtername, *classname;
562 	struct php_user_filter_data *fdat;
563 
564 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS", &filtername, &classname) == FAILURE) {
565 		RETURN_FALSE;
566 	}
567 
568 	RETVAL_FALSE;
569 
570 	if (!ZSTR_LEN(filtername)) {
571 		php_error_docref(NULL, E_WARNING, "Filter name cannot be empty");
572 		return;
573 	}
574 
575 	if (!ZSTR_LEN(classname)) {
576 		php_error_docref(NULL, E_WARNING, "Class name cannot be empty");
577 		return;
578 	}
579 
580 	if (!BG(user_filter_map)) {
581 		BG(user_filter_map) = (HashTable*) emalloc(sizeof(HashTable));
582 		zend_hash_init(BG(user_filter_map), 8, NULL, (dtor_func_t) filter_item_dtor, 0);
583 	}
584 
585 	fdat = ecalloc(1, sizeof(struct php_user_filter_data));
586 	fdat->classname = zend_string_copy(classname);
587 
588 	if (zend_hash_add_ptr(BG(user_filter_map), filtername, fdat) != NULL &&
589 			php_stream_filter_register_factory_volatile(ZSTR_VAL(filtername), &user_filter_factory) == SUCCESS) {
590 		RETVAL_TRUE;
591 	} else {
592 		zend_string_release(classname);
593 		efree(fdat);
594 	}
595 }
596 /* }}} */
597 
598 
599 /*
600  * Local variables:
601  * tab-width: 4
602  * c-basic-offset: 4
603  * End:
604  * vim600: sw=4 ts=4 fdm=marker
605  * vim<600: sw=4 ts=4
606  */
607