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