PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/standard - user_filters.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 199 246 80.9 %
Date: 2014-07-27 Functions: 14 15 93.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2013 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             : 
      54         107 : PHP_FUNCTION(user_filter_nop)
      55             : {
      56         107 : }
      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          23 : static ZEND_RSRC_DTOR_FUNC(php_bucket_dtor)
      80             : {
      81          23 :         php_stream_bucket *bucket = (php_stream_bucket *)rsrc->ptr;
      82          23 :         if (bucket) {
      83          23 :                 php_stream_bucket_delref(bucket TSRMLS_CC);
      84          23 :                 bucket = NULL;
      85             :         }
      86          23 : }
      87             : 
      88       19341 : PHP_MINIT_FUNCTION(user_filters)
      89             : {
      90             :         zend_class_entry *php_user_filter;
      91             :         /* init the filter class ancestor */
      92       19341 :         INIT_CLASS_ENTRY(user_filter_class_entry, "php_user_filter", user_filter_class_funcs);
      93       19341 :         if ((php_user_filter = zend_register_internal_class(&user_filter_class_entry TSRMLS_CC)) == NULL) {
      94           0 :                 return FAILURE;
      95             :         }
      96       19341 :         zend_declare_property_string(php_user_filter, "filtername", sizeof("filtername")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
      97       19341 :         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       19341 :         le_userfilters = zend_register_list_destructors_ex(NULL, NULL, PHP_STREAM_FILTER_RES_NAME, 0);
     102             : 
     103       19341 :         if (le_userfilters == FAILURE) {
     104           0 :                 return FAILURE;
     105             :         }
     106             : 
     107             :         /* Filters will dispose of their brigades */
     108       19341 :         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       19341 :         le_bucket = zend_register_list_destructors_ex(php_bucket_dtor, NULL, PHP_STREAM_BUCKET_RES_NAME, module_number);
     111             :         
     112       19341 :         if (le_bucket_brigade == FAILURE) {
     113           0 :                 return FAILURE;
     114             :         }
     115             : 
     116       19341 :         REGISTER_LONG_CONSTANT("PSFS_PASS_ON",                        PSFS_PASS_ON,                   CONST_CS | CONST_PERSISTENT);
     117       19341 :         REGISTER_LONG_CONSTANT("PSFS_FEED_ME",                        PSFS_FEED_ME,                   CONST_CS | CONST_PERSISTENT);
     118       19341 :         REGISTER_LONG_CONSTANT("PSFS_ERR_FATAL",              PSFS_ERR_FATAL,                 CONST_CS | CONST_PERSISTENT);
     119             : 
     120       19341 :         REGISTER_LONG_CONSTANT("PSFS_FLAG_NORMAL",            PSFS_FLAG_NORMAL,               CONST_CS | CONST_PERSISTENT);
     121       19341 :         REGISTER_LONG_CONSTANT("PSFS_FLAG_FLUSH_INC", PSFS_FLAG_FLUSH_INC,    CONST_CS | CONST_PERSISTENT);
     122       19341 :         REGISTER_LONG_CONSTANT("PSFS_FLAG_FLUSH_CLOSE",       PSFS_FLAG_FLUSH_CLOSE,  CONST_CS | CONST_PERSISTENT);
     123             :         
     124       19341 :         return SUCCESS;
     125             : }
     126             : 
     127       19362 : PHP_RSHUTDOWN_FUNCTION(user_filters)
     128             : {
     129       19362 :         if (BG(user_filter_map)) {
     130           9 :                 zend_hash_destroy(BG(user_filter_map));
     131           9 :                 efree(BG(user_filter_map));
     132           9 :                 BG(user_filter_map) = NULL;
     133             :         }
     134             : 
     135       19362 :         return SUCCESS;
     136             : }
     137             : 
     138          57 : static void userfilter_dtor(php_stream_filter *thisfilter TSRMLS_DC)
     139             : {
     140          57 :         zval *obj = (zval*)thisfilter->abstract;
     141             :         zval func_name;
     142          57 :         zval *retval = NULL;
     143             : 
     144          57 :         if (obj == NULL) {
     145             :                 /* If there's no object associated then there's nothing to dispose of */
     146           0 :                 return;
     147             :         }
     148             : 
     149          57 :         ZVAL_STRINGL(&func_name, "onclose", sizeof("onclose")-1, 0);
     150             : 
     151          57 :         call_user_function_ex(NULL,
     152             :                         &obj,
     153             :                         &func_name,
     154             :                         &retval,
     155             :                         0, NULL,
     156             :                         0, NULL TSRMLS_CC);
     157             : 
     158          57 :         if (retval)
     159          55 :                 zval_ptr_dtor(&retval);
     160             : 
     161             :         /* kill the object */
     162          57 :         zval_ptr_dtor(&obj);
     163             : }
     164             : 
     165          57 : 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          57 :         int ret = PSFS_ERR_FATAL;
     175          57 :         zval *obj = (zval*)thisfilter->abstract;
     176             :         zval func_name;
     177          57 :         zval *retval = NULL;
     178             :         zval **args[4];
     179             :         zval *zclosing, *zconsumed, *zin, *zout, *zstream;
     180             :         zval zpropname;
     181             :         int call_result;
     182             : 
     183          57 :         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          57 :                 ALLOC_INIT_ZVAL(zstream);
     186          57 :                 php_stream_to_zval(stream, zstream);
     187          57 :                 zval_copy_ctor(zstream);
     188          57 :                 add_property_zval(obj, "stream", zstream);
     189             :                 /* add_property_zval increments the refcount which is unwanted here */
     190          57 :                 zval_ptr_dtor(&zstream);
     191             :         }
     192             : 
     193          57 :         ZVAL_STRINGL(&func_name, "filter", sizeof("filter")-1, 0);
     194             : 
     195             :         /* Setup calling arguments */
     196          57 :         ALLOC_INIT_ZVAL(zin);
     197          57 :         ZEND_REGISTER_RESOURCE(zin, buckets_in, le_bucket_brigade);
     198          57 :         args[0] = &zin;
     199             : 
     200          57 :         ALLOC_INIT_ZVAL(zout);
     201          57 :         ZEND_REGISTER_RESOURCE(zout, buckets_out, le_bucket_brigade);
     202          57 :         args[1] = &zout;
     203             : 
     204          57 :         ALLOC_INIT_ZVAL(zconsumed);
     205          57 :         if (bytes_consumed) {
     206          25 :                 ZVAL_LONG(zconsumed, *bytes_consumed);
     207             :         } else {
     208          32 :                 ZVAL_NULL(zconsumed);
     209             :         }
     210          57 :         args[2] = &zconsumed;
     211             : 
     212          57 :         ALLOC_INIT_ZVAL(zclosing);
     213          57 :         ZVAL_BOOL(zclosing, flags & PSFS_FLAG_FLUSH_CLOSE);
     214          57 :         args[3] = &zclosing;
     215             : 
     216          57 :         call_result = call_user_function_ex(NULL,
     217             :                         &obj,
     218             :                         &func_name,
     219             :                         &retval,
     220             :                         4, args,
     221             :                         0, NULL TSRMLS_CC);
     222             : 
     223         114 :         if (call_result == SUCCESS && retval != NULL) {
     224          57 :                 convert_to_long(retval);
     225          57 :                 ret = Z_LVAL_P(retval);
     226           0 :         } else if (call_result == FAILURE) {
     227           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to call filter function");
     228             :         }
     229             : 
     230          57 :         if (bytes_consumed) {
     231          25 :                 *bytes_consumed = Z_LVAL_P(zconsumed);
     232             :         }
     233             : 
     234          57 :         if (retval) {
     235          57 :                 zval_ptr_dtor(&retval);
     236             :         }
     237             : 
     238          57 :         if (buckets_in->head) {
     239          11 :                 php_stream_bucket *bucket = buckets_in->head;
     240             : 
     241          11 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unprocessed filter buckets remaining on input brigade");
     242          33 :                 while ((bucket = buckets_in->head)) {
     243             :                         /* Remove unconsumed buckets from the brigade */
     244          11 :                         php_stream_bucket_unlink(bucket TSRMLS_CC);
     245          11 :                         php_stream_bucket_delref(bucket TSRMLS_CC);
     246             :                 }
     247             :         }
     248          57 :         if (ret != PSFS_PASS_ON) {
     249          39 :                 php_stream_bucket *bucket = buckets_out->head;
     250          84 :                 while (bucket != NULL) {
     251           6 :                         php_stream_bucket_unlink(bucket TSRMLS_CC);
     252           6 :                         php_stream_bucket_delref(bucket TSRMLS_CC);
     253           6 :                         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          57 :         INIT_ZVAL(zpropname);
     261          57 :         ZVAL_STRINGL(&zpropname, "stream", sizeof("stream")-1, 0);
     262          57 :         Z_OBJ_HANDLER_P(obj, unset_property)(obj, &zpropname TSRMLS_CC);
     263             : 
     264          57 :         zval_ptr_dtor(&zclosing);
     265          57 :         zval_ptr_dtor(&zconsumed);
     266          57 :         zval_ptr_dtor(&zout);
     267          57 :         zval_ptr_dtor(&zin);
     268             : 
     269          57 :         return ret;
     270             : }
     271             : 
     272             : static php_stream_filter_ops userfilter_ops = {
     273             :         userfilter_filter,
     274             :         userfilter_dtor,
     275             :         "user-filter"
     276             : };
     277             : 
     278          57 : static php_stream_filter *user_filter_factory_create(const char *filtername,
     279             :                 zval *filterparams, int persistent TSRMLS_DC)
     280             : {
     281          57 :         struct php_user_filter_data *fdat = NULL;
     282             :         php_stream_filter *filter;
     283             :         zval *obj, *zfilter;
     284             :         zval func_name;
     285          57 :         zval *retval = NULL;
     286             :         int len;
     287             :         
     288             :         /* some sanity checks */
     289          57 :         if (persistent) {
     290           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING,
     291             :                                 "cannot use a user-space filter with a persistent stream");
     292           0 :                 return NULL;
     293             :         }
     294             : 
     295          57 :         len = strlen(filtername);
     296             : 
     297             :         /* determine the classname/class entry */
     298          57 :         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           0 :                 if ((period = strrchr(filtername, '.'))) {
     307           0 :                         char *wildcard = emalloc(len + 3);
     308             : 
     309             :                         /* Search for wildcard matches instead */
     310           0 :                         memcpy(wildcard, filtername, len + 1); /* copy \0 */
     311           0 :                         period = wildcard + (period - filtername);
     312           0 :                         while (period) {
     313           0 :                                 *period = '\0';
     314           0 :                                 strncat(wildcard, ".*", 2);
     315           0 :                                 if (SUCCESS == zend_hash_find(BG(user_filter_map), wildcard, strlen(wildcard) + 1, (void**)&fdat)) {
     316           0 :                                         period = NULL;
     317             :                                 } else {
     318           0 :                                         *period = '\0';
     319           0 :                                         period = strrchr(wildcard, '.');
     320             :                                 }
     321             :                         }
     322           0 :                         efree(wildcard);
     323             :                 }
     324           0 :                 if (fdat == NULL) {
     325           0 :                         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           0 :                         return NULL;
     328             :                 }
     329             :         }
     330             : 
     331             :         /* bind the classname to the actual class */
     332          57 :         if (fdat->ce == NULL) {
     333          12 :                 if (FAILURE == zend_lookup_class(fdat->classname, strlen(fdat->classname),
     334          12 :                                         (zend_class_entry ***)&fdat->ce TSRMLS_CC)) {
     335           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING,
     336             :                                         "user-filter \"%s\" requires class \"%s\", but that class is not defined",
     337           0 :                                         filtername, fdat->classname);
     338           0 :                         return NULL;
     339             :                 }
     340          12 :                 fdat->ce = *(zend_class_entry**)fdat->ce;
     341             : 
     342             :         }
     343             : 
     344          57 :         filter = php_stream_filter_alloc(&userfilter_ops, NULL, 0);
     345          57 :         if (filter == NULL) {
     346           0 :                 return NULL;
     347             :         }
     348             : 
     349             :         /* create the object */
     350          57 :         ALLOC_ZVAL(obj);
     351          57 :         object_init_ex(obj, fdat->ce);
     352          57 :         Z_SET_REFCOUNT_P(obj, 1);
     353          57 :         Z_SET_ISREF_P(obj);
     354             : 
     355             :         /* filtername */
     356          57 :         add_property_string(obj, "filtername", (char*)filtername, 1);
     357             :         
     358             :         /* and the parameters, if any */
     359          57 :         if (filterparams) {
     360           1 :                 add_property_zval(obj, "params", filterparams);
     361             :         } else {
     362          56 :                 add_property_null(obj, "params");
     363             :         }
     364             : 
     365             :         /* invoke the constructor */
     366          57 :         ZVAL_STRINGL(&func_name, "oncreate", sizeof("oncreate")-1, 0);
     367             : 
     368          57 :         call_user_function_ex(NULL,
     369             :                         &obj,
     370             :                         &func_name,
     371             :                         &retval,
     372             :                         0, NULL,
     373             :                         0, NULL TSRMLS_CC);
     374             : 
     375          57 :         if (retval) {
     376          55 :                 if (Z_TYPE_P(retval) == IS_BOOL && Z_LVAL_P(retval) == 0) {
     377             :                         /* User reported filter creation error "return false;" */
     378           0 :                         zval_ptr_dtor(&retval);
     379             : 
     380             :                         /* Kill the filter (safely) */
     381           0 :                         filter->abstract = NULL;
     382           0 :                         php_stream_filter_free(filter TSRMLS_CC);
     383             : 
     384             :                         /* Kill the object */
     385           0 :                         zval_ptr_dtor(&obj);
     386             : 
     387             :                         /* Report failure to filter_alloc */
     388           0 :                         return NULL;
     389             :                 }                       
     390          55 :                 zval_ptr_dtor(&retval);
     391             :         }
     392             : 
     393             :         /* set the filter property, this will be used during cleanup */
     394          57 :         ALLOC_INIT_ZVAL(zfilter);
     395          57 :         ZEND_REGISTER_RESOURCE(zfilter, filter, le_userfilters);
     396          57 :         filter->abstract = obj;
     397          57 :         add_property_zval(obj, "filter", zfilter);
     398             :         /* add_property_zval increments the refcount which is unwanted here */
     399          57 :         zval_ptr_dtor(&zfilter);
     400             : 
     401          57 :         return filter;
     402             : }
     403             : 
     404             : static php_stream_filter_factory user_filter_factory = {
     405             :         user_filter_factory_create
     406             : };
     407             : 
     408          13 : static void filter_item_dtor(struct php_user_filter_data *fdat)
     409             : {
     410          13 : }
     411             : 
     412             : /* {{{ proto object stream_bucket_make_writeable(resource brigade)
     413             :    Return a bucket object from the brigade for operating on */
     414          40 : PHP_FUNCTION(stream_bucket_make_writeable)
     415             : {
     416             :         zval *zbrigade, *zbucket;
     417             :         php_stream_bucket_brigade *brigade;
     418             :         php_stream_bucket *bucket;
     419             : 
     420          40 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zbrigade) == FAILURE) {
     421           0 :                 RETURN_FALSE;
     422             :         }
     423             : 
     424          40 :         ZEND_FETCH_RESOURCE(brigade, php_stream_bucket_brigade *, &zbrigade, -1, PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade); 
     425             : 
     426          40 :         ZVAL_NULL(return_value);
     427             : 
     428          40 :         if (brigade->head && (bucket = php_stream_bucket_make_writeable(brigade->head TSRMLS_CC))) {
     429          13 :                 ALLOC_INIT_ZVAL(zbucket);
     430          13 :                 ZEND_REGISTER_RESOURCE(zbucket, bucket, le_bucket);
     431          13 :                 object_init(return_value);
     432          13 :                 add_property_zval(return_value, "bucket", zbucket);
     433             :                 /* add_property_zval increments the refcount which is unwanted here */
     434          13 :                 zval_ptr_dtor(&zbucket);
     435          13 :                 add_property_stringl(return_value, "data", bucket->buf, bucket->buflen, 1);
     436          13 :                 add_property_long(return_value, "datalen", bucket->buflen);
     437             :         }
     438             : }
     439             : /* }}} */
     440             : 
     441             : /* {{{ php_stream_bucket_attach */
     442          17 : 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          17 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zo", &zbrigade, &zobject) == FAILURE) {
     450           0 :                 RETURN_FALSE;
     451             :         }
     452             : 
     453          17 :         if (FAILURE == zend_hash_find(Z_OBJPROP_P(zobject), "bucket", 7, (void**)&pzbucket)) {
     454           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Object has no bucket property");
     455           0 :                 RETURN_FALSE;
     456             :         }
     457             : 
     458          17 :         ZEND_FETCH_RESOURCE(brigade, php_stream_bucket_brigade *, &zbrigade, -1, PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade);
     459          17 :         ZEND_FETCH_RESOURCE(bucket, php_stream_bucket *, pzbucket, -1, PHP_STREAM_BUCKET_RES_NAME, le_bucket);
     460             : 
     461          17 :         if (SUCCESS == zend_hash_find(Z_OBJPROP_P(zobject), "data", 5, (void**)&pzdata) && (*pzdata)->type == IS_STRING) {
     462          17 :                 if (!bucket->own_buf) {
     463           0 :                         bucket = php_stream_bucket_make_writeable(bucket TSRMLS_CC);
     464             :                 }
     465          17 :                 if ((int)bucket->buflen != Z_STRLEN_PP(pzdata)) {
     466           0 :                         bucket->buf = perealloc(bucket->buf, Z_STRLEN_PP(pzdata), bucket->is_persistent);
     467           0 :                         bucket->buflen = Z_STRLEN_PP(pzdata);
     468             :                 }
     469          17 :                 memcpy(bucket->buf, Z_STRVAL_PP(pzdata), bucket->buflen);
     470             :         }
     471             : 
     472          17 :         if (append) {
     473          17 :                 php_stream_bucket_append(brigade, bucket TSRMLS_CC);
     474             :         } else {
     475           0 :                 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          17 :         if (bucket->refcount == 1) {
     481          16 :                 bucket->refcount++;
     482             :         }
     483             : }
     484             : /* }}} */
     485             : 
     486             : /* {{{ proto void stream_bucket_prepend(resource brigade, resource bucket)
     487             :    Prepend bucket to brigade */
     488           0 : PHP_FUNCTION(stream_bucket_prepend)
     489             : {
     490           0 :         php_stream_bucket_attach(0, INTERNAL_FUNCTION_PARAM_PASSTHRU);
     491           0 : }
     492             : /* }}} */
     493             : 
     494             : /* {{{ proto void stream_bucket_append(resource brigade, resource bucket)
     495             :    Append bucket to brigade */
     496          17 : PHP_FUNCTION(stream_bucket_append)
     497             : {
     498          17 :         php_stream_bucket_attach(1, INTERNAL_FUNCTION_PARAM_PASSTHRU);
     499          17 : }
     500             : /* }}} */
     501             : 
     502             : /* {{{ proto resource stream_bucket_new(resource stream, string buffer)
     503             :    Create a new bucket for use on the current stream */
     504          10 : 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          10 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &zstream, &buffer, &buffer_len) == FAILURE) {
     514           0 :                 RETURN_FALSE;
     515             :         }
     516             : 
     517          10 :         php_stream_from_zval(stream, &zstream);
     518             : 
     519          10 :         if (!(pbuffer = pemalloc(buffer_len, php_stream_is_persistent(stream)))) {
     520           0 :                 RETURN_FALSE;
     521             :         }
     522             : 
     523          10 :         memcpy(pbuffer, buffer, buffer_len);
     524             : 
     525          10 :         bucket = php_stream_bucket_new(stream, pbuffer, buffer_len, 1, php_stream_is_persistent(stream) TSRMLS_CC);
     526             :         
     527          10 :         if (bucket == NULL) {
     528           0 :                 RETURN_FALSE;
     529             :         }
     530             : 
     531          10 :         ALLOC_INIT_ZVAL(zbucket);
     532          10 :         ZEND_REGISTER_RESOURCE(zbucket, bucket, le_bucket);
     533          10 :         object_init(return_value);
     534          10 :         add_property_zval(return_value, "bucket", zbucket);
     535             :         /* add_property_zval increments the refcount which is unwanted here */
     536          10 :         zval_ptr_dtor(&zbucket);
     537          10 :         add_property_stringl(return_value, "data", bucket->buf, bucket->buflen, 1);
     538          10 :         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           6 : PHP_FUNCTION(stream_get_filters)
     545             : {
     546             :         char *filter_name;
     547           6 :         int key_flags, filter_name_len = 0;
     548             :         HashTable *filters_hash;
     549             :         ulong num_key;
     550             : 
     551           6 :         if (zend_parse_parameters_none() == FAILURE) {
     552           0 :                 return;
     553             :         }
     554             : 
     555           6 :         array_init(return_value);
     556             : 
     557           6 :         filters_hash = php_get_stream_filters_hash();
     558             : 
     559           6 :         if (filters_hash) {
     560          84 :                 for(zend_hash_internal_pointer_reset(filters_hash);
     561          78 :                         (key_flags = zend_hash_get_current_key_ex(filters_hash, &filter_name, &filter_name_len, &num_key, 0, NULL)) != HASH_KEY_NON_EXISTANT;
     562          72 :                         zend_hash_move_forward(filters_hash))
     563          72 :                                 if (key_flags == HASH_KEY_IS_STRING) {
     564          72 :                                         add_next_index_stringl(return_value, filter_name, filter_name_len - 1, 1);
     565             :                                 }
     566             :         }
     567             :         /* It's okay to return an empty array if no filters are registered */
     568             : }
     569             : /* }}} */       
     570             : 
     571             : /* {{{ proto bool stream_filter_register(string filtername, string classname)
     572             :    Registers a custom filter handler class */
     573          18 : PHP_FUNCTION(stream_filter_register)
     574             : {
     575             :         char *filtername, *classname;
     576             :         int filtername_len, classname_len;
     577             :         struct php_user_filter_data *fdat;
     578             :         
     579          18 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &filtername, &filtername_len,
     580             :                                 &classname, &classname_len) == FAILURE) {
     581           2 :                 RETURN_FALSE;
     582             :         }
     583             : 
     584          16 :         RETVAL_FALSE;
     585             : 
     586          16 :         if (!filtername_len) {
     587           2 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Filter name cannot be empty");
     588           2 :                 return;
     589             :         }
     590             : 
     591          14 :         if (!classname_len) {
     592           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Class name cannot be empty");
     593           1 :                 return;
     594             :         }
     595             : 
     596          13 :         if (!BG(user_filter_map)) {
     597           9 :                 BG(user_filter_map) = (HashTable*) emalloc(sizeof(HashTable));
     598           9 :                 zend_hash_init(BG(user_filter_map), 5, NULL, (dtor_func_t) filter_item_dtor, 0);
     599             :         }
     600             : 
     601          13 :         fdat = ecalloc(1, sizeof(struct php_user_filter_data) + classname_len);
     602          13 :         memcpy(fdat->classname, classname, classname_len);
     603             : 
     604          39 :         if (zend_hash_add(BG(user_filter_map), filtername, filtername_len + 1, (void*)fdat,
     605          26 :                                 sizeof(*fdat) + classname_len, NULL) == SUCCESS &&
     606          13 :                         php_stream_filter_register_factory_volatile(filtername, &user_filter_factory TSRMLS_CC) == SUCCESS) {
     607          13 :                 RETVAL_TRUE;
     608             :         }
     609             : 
     610          13 :         efree(fdat);
     611             : }
     612             : /* }}} */
     613             : 
     614             : 
     615             : /*
     616             :  * Local variables:
     617             :  * tab-width: 4
     618             :  * c-basic-offset: 4
     619             :  * End:
     620             :  * vim600: sw=4 ts=4 fdm=marker
     621             :  * vim<600: sw=4 ts=4
     622             :  */

Generated by: LCOV version 1.10

Generated at Sun, 27 Jul 2014 12:58:37 +0000 (17 hours ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.