Annotation of embedaddon/php/ext/standard/user_filters.c, revision 1.1.1.2
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 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:
1.1.1.2 ! misho 21: /* $Id$ */
1.1 misho 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:
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:
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:
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:
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:
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:
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: if (FAILURE == zend_hash_find(Z_OBJPROP_P(obj), "stream", sizeof("stream"), (void**)&zstream)) {
184: /* Give the userfilter class a hook back to the stream */
185: ALLOC_INIT_ZVAL(zstream);
186: php_stream_to_zval(stream, zstream);
187: zval_copy_ctor(zstream);
188: add_property_zval(obj, "stream", zstream);
189: /* add_property_zval increments the refcount which is unwanted here */
190: zval_ptr_dtor(&zstream);
191: }
192:
193: ZVAL_STRINGL(&func_name, "filter", sizeof("filter")-1, 0);
194:
195: /* Setup calling arguments */
196: ALLOC_INIT_ZVAL(zin);
197: ZEND_REGISTER_RESOURCE(zin, buckets_in, le_bucket_brigade);
198: args[0] = &zin;
199:
200: ALLOC_INIT_ZVAL(zout);
201: ZEND_REGISTER_RESOURCE(zout, buckets_out, le_bucket_brigade);
202: args[1] = &zout;
203:
204: ALLOC_INIT_ZVAL(zconsumed);
205: if (bytes_consumed) {
206: ZVAL_LONG(zconsumed, *bytes_consumed);
207: } else {
208: ZVAL_NULL(zconsumed);
209: }
210: args[2] = &zconsumed;
211:
212: ALLOC_INIT_ZVAL(zclosing);
213: ZVAL_BOOL(zclosing, flags & PSFS_FLAG_FLUSH_CLOSE);
214: args[3] = &zclosing;
215:
216: call_result = call_user_function_ex(NULL,
217: &obj,
218: &func_name,
219: &retval,
220: 4, args,
221: 0, NULL TSRMLS_CC);
222:
223: if (call_result == SUCCESS && retval != NULL) {
224: convert_to_long(retval);
225: ret = Z_LVAL_P(retval);
226: } else if (call_result == FAILURE) {
227: php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to call filter function");
228: }
229:
230: if (bytes_consumed) {
231: *bytes_consumed = Z_LVAL_P(zconsumed);
232: }
233:
234: if (retval) {
235: zval_ptr_dtor(&retval);
236: }
237:
238: if (buckets_in->head) {
239: php_stream_bucket *bucket = buckets_in->head;
240:
241: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unprocessed filter buckets remaining on input brigade");
242: while ((bucket = buckets_in->head)) {
243: /* Remove unconsumed buckets from the brigade */
244: php_stream_bucket_unlink(bucket TSRMLS_CC);
245: php_stream_bucket_delref(bucket TSRMLS_CC);
246: }
247: }
248: if (ret != PSFS_PASS_ON) {
249: php_stream_bucket *bucket = buckets_out->head;
250: while (bucket != NULL) {
251: php_stream_bucket_unlink(bucket TSRMLS_CC);
252: php_stream_bucket_delref(bucket TSRMLS_CC);
253: bucket = buckets_out->head;
254: }
255: }
256:
257: /* filter resources are cleaned up by the stream destructor,
258: * keeping a reference to the stream resource here would prevent it
259: * from being destroyed properly */
260: INIT_ZVAL(zpropname);
261: ZVAL_STRINGL(&zpropname, "stream", sizeof("stream")-1, 0);
1.1.1.2 ! misho 262: Z_OBJ_HANDLER_P(obj, unset_property)(obj, &zpropname, 0 TSRMLS_CC);
1.1 misho 263:
264: zval_ptr_dtor(&zclosing);
265: zval_ptr_dtor(&zconsumed);
266: zval_ptr_dtor(&zout);
267: zval_ptr_dtor(&zin);
268:
269: return ret;
270: }
271:
272: static php_stream_filter_ops userfilter_ops = {
273: userfilter_filter,
274: userfilter_dtor,
275: "user-filter"
276: };
277:
278: static php_stream_filter *user_filter_factory_create(const char *filtername,
279: zval *filterparams, int persistent TSRMLS_DC)
280: {
281: struct php_user_filter_data *fdat = NULL;
282: php_stream_filter *filter;
283: zval *obj, *zfilter;
284: zval func_name;
285: zval *retval = NULL;
286: int len;
287:
288: /* some sanity checks */
289: if (persistent) {
290: php_error_docref(NULL TSRMLS_CC, E_WARNING,
291: "cannot use a user-space filter with a persistent stream");
292: return NULL;
293: }
294:
295: len = strlen(filtername);
296:
297: /* determine the classname/class entry */
298: if (FAILURE == zend_hash_find(BG(user_filter_map), (char*)filtername, len + 1, (void**)&fdat)) {
299: char *period;
300:
301: /* Userspace Filters using ambiguous wildcards could cause problems.
302: i.e.: myfilter.foo.bar will always call into myfilter.foo.*
303: never seeing myfilter.*
304: TODO: Allow failed userfilter creations to continue
305: scanning through the list */
306: if ((period = strrchr(filtername, '.'))) {
307: char *wildcard = emalloc(len + 3);
308:
309: /* Search for wildcard matches instead */
310: memcpy(wildcard, filtername, len + 1); /* copy \0 */
311: period = wildcard + (period - filtername);
312: while (period) {
313: *period = '\0';
314: strncat(wildcard, ".*", 2);
315: if (SUCCESS == zend_hash_find(BG(user_filter_map), wildcard, strlen(wildcard) + 1, (void**)&fdat)) {
316: period = NULL;
317: } else {
318: *period = '\0';
319: period = strrchr(wildcard, '.');
320: }
321: }
322: efree(wildcard);
323: }
324: if (fdat == NULL) {
325: php_error_docref(NULL TSRMLS_CC, E_WARNING,
326: "Err, filter \"%s\" is not in the user-filter map, but somehow the user-filter-factory was invoked for it!?", filtername);
327: return NULL;
328: }
329: }
330:
331: /* bind the classname to the actual class */
332: if (fdat->ce == NULL) {
333: if (FAILURE == zend_lookup_class(fdat->classname, strlen(fdat->classname),
334: (zend_class_entry ***)&fdat->ce TSRMLS_CC)) {
335: php_error_docref(NULL TSRMLS_CC, E_WARNING,
336: "user-filter \"%s\" requires class \"%s\", but that class is not defined",
337: filtername, fdat->classname);
338: return NULL;
339: }
340: fdat->ce = *(zend_class_entry**)fdat->ce;
341:
342: }
343:
344: filter = php_stream_filter_alloc(&userfilter_ops, NULL, 0);
345: if (filter == NULL) {
346: return NULL;
347: }
348:
349: /* create the object */
350: ALLOC_ZVAL(obj);
351: object_init_ex(obj, fdat->ce);
352: Z_SET_REFCOUNT_P(obj, 1);
353: Z_SET_ISREF_P(obj);
354:
355: /* filtername */
356: add_property_string(obj, "filtername", (char*)filtername, 1);
357:
358: /* and the parameters, if any */
359: if (filterparams) {
360: add_property_zval(obj, "params", filterparams);
361: } else {
362: add_property_null(obj, "params");
363: }
364:
365: /* invoke the constructor */
366: ZVAL_STRINGL(&func_name, "oncreate", sizeof("oncreate")-1, 0);
367:
368: call_user_function_ex(NULL,
369: &obj,
370: &func_name,
371: &retval,
372: 0, NULL,
373: 0, NULL TSRMLS_CC);
374:
375: if (retval) {
376: if (Z_TYPE_P(retval) == IS_BOOL && Z_LVAL_P(retval) == 0) {
377: /* User reported filter creation error "return false;" */
378: zval_ptr_dtor(&retval);
379:
380: /* Kill the filter (safely) */
381: filter->abstract = NULL;
382: php_stream_filter_free(filter TSRMLS_CC);
383:
384: /* Kill the object */
385: zval_ptr_dtor(&obj);
386:
387: /* Report failure to filter_alloc */
388: return NULL;
389: }
390: zval_ptr_dtor(&retval);
391: }
392:
393: /* set the filter property, this will be used during cleanup */
394: ALLOC_INIT_ZVAL(zfilter);
395: ZEND_REGISTER_RESOURCE(zfilter, filter, le_userfilters);
396: filter->abstract = obj;
397: add_property_zval(obj, "filter", zfilter);
398: /* add_property_zval increments the refcount which is unwanted here */
399: zval_ptr_dtor(&zfilter);
400:
401: return filter;
402: }
403:
404: static php_stream_filter_factory user_filter_factory = {
405: user_filter_factory_create
406: };
407:
408: static void filter_item_dtor(struct php_user_filter_data *fdat)
409: {
410: }
411:
412: /* {{{ proto object stream_bucket_make_writeable(resource brigade)
413: Return a bucket object from the brigade for operating on */
414: PHP_FUNCTION(stream_bucket_make_writeable)
415: {
416: zval *zbrigade, *zbucket;
417: php_stream_bucket_brigade *brigade;
418: php_stream_bucket *bucket;
419:
420: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zbrigade) == FAILURE) {
421: RETURN_FALSE;
422: }
423:
424: ZEND_FETCH_RESOURCE(brigade, php_stream_bucket_brigade *, &zbrigade, -1, PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade);
425:
426: ZVAL_NULL(return_value);
427:
428: if (brigade->head && (bucket = php_stream_bucket_make_writeable(brigade->head TSRMLS_CC))) {
429: ALLOC_INIT_ZVAL(zbucket);
430: ZEND_REGISTER_RESOURCE(zbucket, bucket, le_bucket);
431: object_init(return_value);
432: add_property_zval(return_value, "bucket", zbucket);
433: /* add_property_zval increments the refcount which is unwanted here */
434: zval_ptr_dtor(&zbucket);
435: add_property_stringl(return_value, "data", bucket->buf, bucket->buflen, 1);
436: add_property_long(return_value, "datalen", bucket->buflen);
437: }
438: }
439: /* }}} */
440:
441: /* {{{ php_stream_bucket_attach */
442: static void php_stream_bucket_attach(int append, INTERNAL_FUNCTION_PARAMETERS)
443: {
444: zval *zbrigade, *zobject;
445: zval **pzbucket, **pzdata;
446: php_stream_bucket_brigade *brigade;
447: php_stream_bucket *bucket;
448:
449: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zo", &zbrigade, &zobject) == FAILURE) {
450: RETURN_FALSE;
451: }
452:
453: if (FAILURE == zend_hash_find(Z_OBJPROP_P(zobject), "bucket", 7, (void**)&pzbucket)) {
454: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Object has no bucket property");
455: RETURN_FALSE;
456: }
457:
458: ZEND_FETCH_RESOURCE(brigade, php_stream_bucket_brigade *, &zbrigade, -1, PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade);
459: ZEND_FETCH_RESOURCE(bucket, php_stream_bucket *, pzbucket, -1, PHP_STREAM_BUCKET_RES_NAME, le_bucket);
460:
461: if (SUCCESS == zend_hash_find(Z_OBJPROP_P(zobject), "data", 5, (void**)&pzdata) && (*pzdata)->type == IS_STRING) {
462: if (!bucket->own_buf) {
463: bucket = php_stream_bucket_make_writeable(bucket TSRMLS_CC);
464: }
465: if ((int)bucket->buflen != Z_STRLEN_PP(pzdata)) {
466: bucket->buf = perealloc(bucket->buf, Z_STRLEN_PP(pzdata), bucket->is_persistent);
467: bucket->buflen = Z_STRLEN_PP(pzdata);
468: }
469: memcpy(bucket->buf, Z_STRVAL_PP(pzdata), bucket->buflen);
470: }
471:
472: if (append) {
473: php_stream_bucket_append(brigade, bucket TSRMLS_CC);
474: } else {
475: php_stream_bucket_prepend(brigade, bucket TSRMLS_CC);
476: }
477: /* This is a hack necessary to accomodate situations where bucket is appended to the stream
478: * multiple times. See bug35916.phpt for reference.
479: */
480: if (bucket->refcount == 1) {
481: bucket->refcount++;
482: }
483: }
484: /* }}} */
485:
486: /* {{{ proto void stream_bucket_prepend(resource brigade, resource bucket)
487: Prepend bucket to brigade */
488: PHP_FUNCTION(stream_bucket_prepend)
489: {
490: php_stream_bucket_attach(0, INTERNAL_FUNCTION_PARAM_PASSTHRU);
491: }
492: /* }}} */
493:
494: /* {{{ proto void stream_bucket_append(resource brigade, resource bucket)
495: Append bucket to brigade */
496: PHP_FUNCTION(stream_bucket_append)
497: {
498: php_stream_bucket_attach(1, INTERNAL_FUNCTION_PARAM_PASSTHRU);
499: }
500: /* }}} */
501:
502: /* {{{ proto resource stream_bucket_new(resource stream, string buffer)
503: Create a new bucket for use on the current stream */
504: PHP_FUNCTION(stream_bucket_new)
505: {
506: zval *zstream, *zbucket;
507: php_stream *stream;
508: char *buffer;
509: char *pbuffer;
510: int buffer_len;
511: php_stream_bucket *bucket;
512:
513: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &zstream, &buffer, &buffer_len) == FAILURE) {
514: RETURN_FALSE;
515: }
516:
517: php_stream_from_zval(stream, &zstream);
518:
519: if (!(pbuffer = pemalloc(buffer_len, php_stream_is_persistent(stream)))) {
520: RETURN_FALSE;
521: }
522:
523: memcpy(pbuffer, buffer, buffer_len);
524:
525: bucket = php_stream_bucket_new(stream, pbuffer, buffer_len, 1, php_stream_is_persistent(stream) TSRMLS_CC);
526:
527: if (bucket == NULL) {
528: RETURN_FALSE;
529: }
530:
531: ALLOC_INIT_ZVAL(zbucket);
532: ZEND_REGISTER_RESOURCE(zbucket, bucket, le_bucket);
533: object_init(return_value);
534: add_property_zval(return_value, "bucket", zbucket);
535: /* add_property_zval increments the refcount which is unwanted here */
536: zval_ptr_dtor(&zbucket);
537: add_property_stringl(return_value, "data", bucket->buf, bucket->buflen, 1);
538: add_property_long(return_value, "datalen", bucket->buflen);
539: }
540: /* }}} */
541:
542: /* {{{ proto array stream_get_filters(void)
543: Returns a list of registered filters */
544: PHP_FUNCTION(stream_get_filters)
545: {
546: char *filter_name;
1.1.1.2 ! misho 547: int key_flags;
! 548: uint filter_name_len = 0;
1.1 misho 549: HashTable *filters_hash;
550: ulong num_key;
551:
552: if (zend_parse_parameters_none() == FAILURE) {
553: return;
554: }
555:
556: array_init(return_value);
557:
558: filters_hash = php_get_stream_filters_hash();
559:
560: if (filters_hash) {
561: for(zend_hash_internal_pointer_reset(filters_hash);
562: (key_flags = zend_hash_get_current_key_ex(filters_hash, &filter_name, &filter_name_len, &num_key, 0, NULL)) != HASH_KEY_NON_EXISTANT;
563: zend_hash_move_forward(filters_hash))
564: if (key_flags == HASH_KEY_IS_STRING) {
565: add_next_index_stringl(return_value, filter_name, filter_name_len - 1, 1);
566: }
567: }
568: /* It's okay to return an empty array if no filters are registered */
569: }
570: /* }}} */
571:
572: /* {{{ proto bool stream_filter_register(string filtername, string classname)
573: Registers a custom filter handler class */
574: PHP_FUNCTION(stream_filter_register)
575: {
576: char *filtername, *classname;
577: int filtername_len, classname_len;
578: struct php_user_filter_data *fdat;
579:
580: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &filtername, &filtername_len,
581: &classname, &classname_len) == FAILURE) {
582: RETURN_FALSE;
583: }
584:
585: RETVAL_FALSE;
586:
587: if (!filtername_len) {
588: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Filter name cannot be empty");
589: return;
590: }
591:
592: if (!classname_len) {
593: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Class name cannot be empty");
594: return;
595: }
596:
597: if (!BG(user_filter_map)) {
598: BG(user_filter_map) = (HashTable*) emalloc(sizeof(HashTable));
599: zend_hash_init(BG(user_filter_map), 5, NULL, (dtor_func_t) filter_item_dtor, 0);
600: }
601:
602: fdat = ecalloc(1, sizeof(struct php_user_filter_data) + classname_len);
603: memcpy(fdat->classname, classname, classname_len);
604:
605: if (zend_hash_add(BG(user_filter_map), filtername, filtername_len + 1, (void*)fdat,
606: sizeof(*fdat) + classname_len, NULL) == SUCCESS &&
607: php_stream_filter_register_factory_volatile(filtername, &user_filter_factory TSRMLS_CC) == SUCCESS) {
608: RETVAL_TRUE;
609: }
610:
611: efree(fdat);
612: }
613: /* }}} */
614:
615:
616: /*
617: * Local variables:
618: * tab-width: 4
619: * c-basic-offset: 4
620: * End:
621: * vim600: sw=4 ts=4 fdm=marker
622: * vim<600: sw=4 ts=4
623: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to user_filters.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / standard