]> granicus.if.org Git - php/commitdiff
Refactored filter
authorXinchen Hui <laruence@php.net>
Wed, 7 May 2014 08:52:58 +0000 (16:52 +0800)
committerXinchen Hui <laruence@php.net>
Wed, 7 May 2014 08:52:58 +0000 (16:52 +0800)
ext/filter/callback_filter.c
ext/filter/filter.c
ext/filter/filter_private.h
ext/filter/logical_filters.c
ext/filter/php_filter.h
ext/filter/sanitizing_filters.c
ext/pdo_mysql/tests/common.phpt
ext/pdo_mysql/tests/config.inc
main/php_variables.c

index 37c0631d6f52803174612130f155e6b3d782f0f6..49410dbfe695a85b84faaa49086d765813879098 100644 (file)
 
 void php_filter_callback(PHP_INPUT_FILTER_PARAM_DECL)
 {
-       zval *retval_ptr;
-       zval ***args;
+       zval retval;
+       zval *args;
        int status;
 
        if (!option_array || !zend_is_callable(option_array, IS_CALLABLE_CHECK_NO_ACCESS, NULL TSRMLS_CC)) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "First argument is expected to be a valid callback");
-               zval_dtor(value);
-               Z_TYPE_P(value) = IS_NULL;
+               zval_ptr_dtor(value);
+               ZVAL_NULL(value);
                return;
        }
 
-       args = safe_emalloc(sizeof(zval **), 1, 0);
-       args[0] = &value;
-       
-       status = call_user_function_ex(EG(function_table), NULL, option_array, &retval_ptr, 1, args, 0, NULL TSRMLS_CC);
+       args = safe_emalloc(sizeof(zval), 1, 0);
+       ZVAL_COPY(&args[0], value);
+       status = call_user_function_ex(EG(function_table), NULL, option_array, &retval, 1, args, 0, NULL TSRMLS_CC);
 
-       if (status == SUCCESS && retval_ptr != NULL) {
-               if (retval_ptr != value) {
-                       zval_dtor(value);
-                       ZVAL_COPY_VALUE(value, retval_ptr);
-//???                  COPY_PZVAL_TO_ZVAL(*value, retval_ptr);
-               } else {
-                       zval_ptr_dtor(&retval_ptr);
-               }
+       if (status == SUCCESS && !Z_ISUNDEF(retval)) {
+               zval_ptr_dtor(value);
+               ZVAL_COPY_VALUE(value, &retval);
        } else {
-               zval_dtor(value);
-               Z_TYPE_P(value) = IS_NULL;
+               zval_ptr_dtor(value);
+               ZVAL_NULL(value);
        }
 
+       zval_ptr_dtor(&args[0]);
        efree(args);
 }
 
index 9007a36c87ef82b3bd23f17a1f14ba6d1a256136..f77dcb3473932327d0a808a15c7b8af8dc4159d6 100644 (file)
@@ -191,12 +191,12 @@ PHP_INI_END()
 
 static void php_filter_init_globals(zend_filter_globals *filter_globals) /* {{{ */
 {
-       filter_globals->post_array = NULL;
-       filter_globals->get_array = NULL;
-       filter_globals->cookie_array = NULL;
-       filter_globals->env_array = NULL;
-       filter_globals->server_array = NULL;
-       filter_globals->session_array = NULL;
+       ZVAL_UNDEF(&filter_globals->post_array);
+       ZVAL_UNDEF(&filter_globals->get_array);
+       ZVAL_UNDEF(&filter_globals->cookie_array);
+       ZVAL_UNDEF(&filter_globals->env_array);
+       ZVAL_UNDEF(&filter_globals->server_array);
+       ZVAL_UNDEF(&filter_globals->session_array);
        filter_globals->default_filter = FILTER_DEFAULT;
 }
 /* }}} */
@@ -297,9 +297,9 @@ PHP_MSHUTDOWN_FUNCTION(filter)
 /* {{{ PHP_RSHUTDOWN_FUNCTION
  */
 #define VAR_ARRAY_COPY_DTOR(a)   \
-       if (IF_G(a)) {               \
+       if (!Z_ISUNDEF(IF_G(a))) {   \
                zval_ptr_dtor(&IF_G(a)); \
-               IF_G(a) = NULL;          \
+               ZVAL_UNDEF(&IF_G(a));    \
        }
 
 PHP_RSHUTDOWN_FUNCTION(filter)
@@ -349,16 +349,16 @@ static filter_list_entry php_find_filter(long id) /* {{{ */
 
 static unsigned int php_sapi_filter_init(TSRMLS_D)
 {
-       IF_G(get_array) = NULL;
-       IF_G(post_array) = NULL;
-       IF_G(cookie_array) = NULL;
-       IF_G(server_array) = NULL;
-       IF_G(env_array) = NULL;
-       IF_G(session_array) = NULL;
+       ZVAL_UNDEF(&IF_G(get_array));
+       ZVAL_UNDEF(&IF_G(post_array));
+       ZVAL_UNDEF(&IF_G(cookie_array));
+       ZVAL_UNDEF(&IF_G(server_array));
+       ZVAL_UNDEF(&IF_G(env_array));
+       ZVAL_UNDEF(&IF_G(session_array));
        return SUCCESS;
 }
 
-static void php_zval_filter(zval **value, long filter, long flags, zval *options, char* charset, zend_bool copy TSRMLS_DC) /* {{{ */
+static void php_zval_filter(zval *value, long filter, long flags, zval *options, char* charset, zend_bool copy TSRMLS_DC) /* {{{ */
 {
        filter_list_entry  filter_func;
 
@@ -375,30 +375,28 @@ static void php_zval_filter(zval **value, long filter, long flags, zval *options
 
        /* #49274, fatal error with object without a toString method
          Fails nicely instead of getting a recovarable fatal error. */
-       if (Z_TYPE_PP(value) == IS_OBJECT) {
+       if (Z_TYPE_P(value) == IS_OBJECT) {
                zend_class_entry *ce;
 
-               ce = Z_OBJCE_PP(value);
+               ce = Z_OBJCE_P(value);
                if (!ce->__tostring) {
-                       ZVAL_FALSE(*value);
+                       ZVAL_FALSE(value);
                        return;
                }
        }
 
        /* Here be strings */
-       convert_to_string(*value);
-
-       filter_func.function(*value, flags, options, charset TSRMLS_CC);
-
-       if (
-               options && (Z_TYPE_P(options) == IS_ARRAY || Z_TYPE_P(options) == IS_OBJECT) &&
-               ((flags & FILTER_NULL_ON_FAILURE && Z_TYPE_PP(value) == IS_NULL) || 
-               (!(flags & FILTER_NULL_ON_FAILURE) && Z_TYPE_PP(value) == IS_BOOL && Z_LVAL_PP(value) == 0)) &&
-               zend_hash_exists(HASH_OF(options), "default", sizeof("default"))
-       ) {
-               zval **tmp; 
-               if (zend_hash_find(HASH_OF(options), "default", sizeof("default"), (void **)&tmp) == SUCCESS) {
-                       MAKE_COPY_ZVAL(tmp, *value);
+       convert_to_string(value);
+
+       filter_func.function(value, flags, options, charset TSRMLS_CC);
+
+       if (options && (Z_TYPE_P(options) == IS_ARRAY || Z_TYPE_P(options) == IS_OBJECT) &&
+               ((flags & FILTER_NULL_ON_FAILURE && Z_TYPE_P(value) == IS_NULL) || 
+               (!(flags & FILTER_NULL_ON_FAILURE) && Z_TYPE_P(value) == IS_FALSE)) &&
+               zend_hash_str_exists(HASH_OF(options), "default", sizeof("default") - 1)) {
+               zval *tmp; 
+               if ((tmp = zend_hash_str_find(HASH_OF(options), "default", sizeof("default") - 1)) != NULL) {
+                       ZVAL_COPY(value, tmp);
                }
        }
 }
@@ -412,17 +410,13 @@ static unsigned int php_sapi_filter(int arg, char *var, char **val, unsigned int
 
        assert(*val != NULL);
 
-#define PARSE_CASE(s,a,t)                    \
-               case s:                              \
-                       if (!IF_G(a)) {                  \
-                               ALLOC_ZVAL(array_ptr);       \
-                               array_init(array_ptr);       \
-                               INIT_PZVAL(array_ptr);       \
-                               IF_G(a) = array_ptr;         \
-                       } else {                         \
-                               array_ptr = IF_G(a);         \
-                       }                                \
-                       orig_array_ptr = PG(http_globals)[t]; \
+#define PARSE_CASE(s,a,t)                              \
+               case s:                                         \
+                       if (Z_ISUNDEF(IF_G(a))) {                       \
+                               array_init(&IF_G(a));                           \
+                       }                                                                               \
+                       array_ptr = &IF_G(a);                           \
+                       orig_array_ptr = &PG(http_globals)[t];  \
                        break;
 
        switch (arg) {
@@ -443,31 +437,24 @@ static unsigned int php_sapi_filter(int arg, char *var, char **val, unsigned int
         * to have the same (plain text) cookie name for the same path and we should not overwrite
         * more specific cookies with the less specific ones.
        */
-       if (arg == PARSE_COOKIE && orig_array_ptr && zend_symtable_exists(Z_ARRVAL_P(orig_array_ptr), var, strlen(var)+1)) {
+       if (arg == PARSE_COOKIE && orig_array_ptr &&
+                       zend_symtable_str_exists(Z_ARRVAL_P(orig_array_ptr), var, strlen(var))) {
                return 0;
        }
 
        if (array_ptr) {
                /* Store the RAW variable internally */
-               Z_STRLEN(raw_var) = val_len;
-               Z_STRVAL(raw_var) = estrndup(*val, val_len);
-               Z_TYPE(raw_var) = IS_STRING;
-
+               ZVAL_STRINGL(&raw_var, *val, val_len);
                php_register_variable_ex(var, &raw_var, array_ptr TSRMLS_CC);
        }
 
        if (val_len) {
                /* Register mangled variable */
-               Z_STRLEN(new_var) = val_len;
-               Z_TYPE(new_var) = IS_STRING;
-
                if (IF_G(default_filter) != FILTER_UNSAFE_RAW) {
-                       zval *tmp_new_var = &new_var;
-                       Z_STRVAL(new_var) = estrndup(*val, val_len);
-                       INIT_PZVAL(tmp_new_var);
-                       php_zval_filter(&tmp_new_var, IF_G(default_filter), IF_G(default_filter_flags), NULL, NULL/*charset*/, 0 TSRMLS_CC);
+                       ZVAL_STRINGL(&new_var, *val, val_len);
+                       php_zval_filter(&new_var, IF_G(default_filter), IF_G(default_filter_flags), NULL, NULL, 0 TSRMLS_CC);
                } else {
-                       Z_STRVAL(new_var) = estrndup(*val, val_len);
+                       ZVAL_STRINGL(&new_var, *val, val_len);
                }
        } else { /* empty string */
                ZVAL_EMPTY_STRING(&new_var);
@@ -487,36 +474,32 @@ static unsigned int php_sapi_filter(int arg, char *var, char **val, unsigned int
                } else {
                        *val = estrdup("");
                }
-               zval_dtor(&new_var);
+               zval_ptr_dtor(&new_var);
        }
 
        return retval;
 }
 /* }}} */
 
-static void php_zval_filter_recursive(zval **value, long filter, long flags, zval *options, char *charset, zend_bool copy TSRMLS_DC) /* {{{ */
+static void php_zval_filter_recursive(zval *value, long filter, long flags, zval *options, char *charset, zend_bool copy TSRMLS_DC) /* {{{ */
 {
-       if (Z_TYPE_PP(value) == IS_ARRAY) {
-               zval **element;
-               HashPosition pos;
+       if (Z_TYPE_P(value) == IS_ARRAY) {
+               zval *element;
 
-               if (Z_ARRVAL_PP(value)->nApplyCount > 1) {
+               if (Z_ARRVAL_P(value)->u.v.nApplyCount > 1) {
                        return;
                }
 
-               for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(value), &pos);
-                        zend_hash_get_current_data_ex(Z_ARRVAL_PP(value), (void **) &element, &pos) == SUCCESS;
-                        zend_hash_move_forward_ex(Z_ARRVAL_PP(value), &pos)
-               ) {
+               ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(value), element) {
                        SEPARATE_ZVAL_IF_NOT_REF(element);
-                       if (Z_TYPE_PP(element) == IS_ARRAY) {
-                               Z_ARRVAL_PP(element)->nApplyCount++;
+                       if (Z_TYPE_P(element) == IS_ARRAY) {
+                               Z_ARRVAL_P(element)->u.v.nApplyCount++;
                                php_zval_filter_recursive(element, filter, flags, options, charset, copy TSRMLS_CC);
-                               Z_ARRVAL_PP(element)->nApplyCount--;
+                               Z_ARRVAL_P(element)->u.v.nApplyCount--;
                        } else {
                                php_zval_filter(element, filter, flags, options, charset, copy TSRMLS_CC);
                        }
-               }
+               } ZEND_HASH_FOREACH_END();
        } else {
                php_zval_filter(value, filter, flags, options, charset, copy TSRMLS_CC);
        }
@@ -530,25 +513,29 @@ static zval *php_filter_get_storage(long arg TSRMLS_DC)/* {{{ */
 
        switch (arg) {
                case PARSE_GET:
-                       array_ptr = IF_G(get_array);
+                       array_ptr = &IF_G(get_array);
                        break;
                case PARSE_POST:
-                       array_ptr = IF_G(post_array);
+                       array_ptr = &IF_G(post_array);
                        break;
                case PARSE_COOKIE:
-                       array_ptr = IF_G(cookie_array);
+                       array_ptr = &IF_G(cookie_array);
                        break;
                case PARSE_SERVER:
                        if (PG(auto_globals_jit)) {
-                               zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
+                               zend_string *name = STR_INIT("_SERVER", sizeof("_SERVER") - 1, 0);
+                               zend_is_auto_global(name TSRMLS_CC);
+                               STR_RELEASE(name);
                        }
-                       array_ptr = IF_G(server_array);
+                       array_ptr = &IF_G(server_array);
                        break;
                case PARSE_ENV:
                        if (PG(auto_globals_jit)) {
-                               zend_is_auto_global("_ENV", sizeof("_ENV")-1 TSRMLS_CC);
+                               zend_string *name = STR_INIT("_ENV", sizeof("_ENV") - 1, 0);
+                               zend_is_auto_global(name TSRMLS_CC);
+                               STR_RELEASE(name);
                        }
-                       array_ptr = IF_G(env_array) ? IF_G(env_array) : PG(http_globals)[TRACK_VARS_ENV];
+                       array_ptr = &IF_G(env_array) ? &IF_G(env_array) : &PG(http_globals)[TRACK_VARS_ENV];
                        break;
                case PARSE_SESSION:
                        /* FIXME: Implement session source */
@@ -569,18 +556,17 @@ static zval *php_filter_get_storage(long arg TSRMLS_DC)/* {{{ */
  */
 PHP_FUNCTION(filter_has_var)
 {
-       long        arg;
-       char       *var;
-       int         var_len;
-       zval       *array_ptr = NULL;
+       long         arg;
+       zend_string *var;
+       zval        *array_ptr = NULL;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &arg, &var, &var_len) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lS", &arg, &var) == FAILURE) {
                RETURN_FALSE;
        }
 
        array_ptr = php_filter_get_storage(arg TSRMLS_CC);
 
-       if (array_ptr && HASH_OF(array_ptr) && zend_hash_exists(HASH_OF(array_ptr), var, var_len + 1)) {
+       if (array_ptr && HASH_OF(array_ptr) && zend_hash_exists(HASH_OF(array_ptr), var)) {
                RETURN_TRUE;
        }
 
@@ -588,13 +574,13 @@ PHP_FUNCTION(filter_has_var)
 }
 /* }}} */
 
-static void php_filter_call(zval **filtered, long filter, zval **filter_args, const int copy, long filter_flags TSRMLS_DC) /* {{{ */
+static void php_filter_call(zval *filtered, long filter, zval *filter_args, const int copy, long filter_flags TSRMLS_DC) /* {{{ */
 {
-       zval  *options = NULL;
-       zval **option;
-       char  *charset = NULL;
+       zval *options = NULL;
+       zval *option;
+       char *charset = NULL;
 
-       if (filter_args && Z_TYPE_PP(filter_args) != IS_ARRAY) {
+       if (filter_args && Z_TYPE_P(filter_args) != IS_ARRAY) {
                long lval;
 
                PHP_FILTER_GET_LONG_OPT(filter_args, lval);
@@ -610,11 +596,11 @@ static void php_filter_call(zval **filtered, long filter, zval **filter_args, co
                        filter = lval;
                }
        } else if (filter_args) {
-               if (zend_hash_find(HASH_OF(*filter_args), "filter", sizeof("filter"), (void **)&option) == SUCCESS) {
+               if ((option = zend_hash_str_find(HASH_OF(filter_args), "filter", sizeof("filter") - 1)) != NULL) {
                        PHP_FILTER_GET_LONG_OPT(option, filter);
                }
 
-               if (zend_hash_find(HASH_OF(*filter_args), "flags", sizeof("flags"), (void **)&option) == SUCCESS) {
+               if ((option = zend_hash_str_find(HASH_OF(filter_args), "flags", sizeof("flags") - 1)) != NULL) {
                        PHP_FILTER_GET_LONG_OPT(option, filter_flags);
 
                        if (!(filter_flags & FILTER_REQUIRE_ARRAY ||  filter_flags & FILTER_FORCE_ARRAY)) {
@@ -622,28 +608,28 @@ static void php_filter_call(zval **filtered, long filter, zval **filter_args, co
                        }
                }
 
-               if (zend_hash_find(HASH_OF(*filter_args), "options", sizeof("options"), (void **)&option) == SUCCESS) {
+               if ((option = zend_hash_str_find(HASH_OF(filter_args), "options", sizeof("options") - 1)) != NULL) {
                        if (filter != FILTER_CALLBACK) {
-                               if (Z_TYPE_PP(option) == IS_ARRAY) {
-                                       options = *option;
+                               if (Z_TYPE_P(option) == IS_ARRAY) {
+                                       options = option;
                                }
                        } else {
-                               options = *option;
+                               options = option;
                                filter_flags = 0;
                        }
                }
        }
 
-       if (Z_TYPE_PP(filtered) == IS_ARRAY) {
+       if (Z_TYPE_P(filtered) == IS_ARRAY) {
                if (filter_flags & FILTER_REQUIRE_SCALAR) {
                        if (copy) {
                                SEPARATE_ZVAL(filtered);
                        }
-                       zval_dtor(*filtered);
+                       zval_ptr_dtor(filtered);
                        if (filter_flags & FILTER_NULL_ON_FAILURE) {
-                               ZVAL_NULL(*filtered);
+                               ZVAL_NULL(filtered);
                        } else {
-                               ZVAL_FALSE(*filtered);
+                               ZVAL_FALSE(filtered);
                        }
                        return;
                }
@@ -654,78 +640,64 @@ static void php_filter_call(zval **filtered, long filter, zval **filter_args, co
                if (copy) {
                        SEPARATE_ZVAL(filtered);
                }
-               zval_dtor(*filtered);
+               zval_ptr_dtor(filtered);
                if (filter_flags & FILTER_NULL_ON_FAILURE) {
-                       ZVAL_NULL(*filtered);
+                       ZVAL_NULL(filtered);
                } else {
-                       ZVAL_FALSE(*filtered);
+                       ZVAL_FALSE(filtered);
                }
                return;
        }
 
        php_zval_filter(filtered, filter, filter_flags, options, charset, copy TSRMLS_CC);
        if (filter_flags & FILTER_FORCE_ARRAY) {
-               zval *tmp;
-
-               ALLOC_ZVAL(tmp);
-               MAKE_COPY_ZVAL(filtered, tmp);
-
-               zval_dtor(*filtered);
-
-               array_init(*filtered);
-               add_next_index_zval(*filtered, tmp);
+               zval tmp;
+               ZVAL_COPY_VALUE(&tmp, filtered);
+               array_init(filtered);
+               add_next_index_zval(filtered, &tmp);
        }
 }
 /* }}} */
 
-static void php_filter_array_handler(zval *input, zval **op, zval *return_value, zend_bool add_empty TSRMLS_DC) /* {{{ */
+static void php_filter_array_handler(zval *input, zval *op, zval *return_value, zend_bool add_empty TSRMLS_DC) /* {{{ */
 {
-       char *arg_key;
-       uint arg_key_len;
        ulong index;
-       HashPosition pos;
-       zval **tmp, **arg_elm;
+       zend_string *arg_key;
+       zval *tmp, *arg_elm;
 
        if (!op) {
-               zval_dtor(return_value);
-               MAKE_COPY_ZVAL(&input, return_value);
-               php_filter_call(&return_value, FILTER_DEFAULT, NULL, 0, FILTER_REQUIRE_ARRAY TSRMLS_CC);
-       } else if (Z_TYPE_PP(op) == IS_LONG) {
-               zval_dtor(return_value);
-               MAKE_COPY_ZVAL(&input, return_value);
-               php_filter_call(&return_value, Z_LVAL_PP(op), NULL, 0, FILTER_REQUIRE_ARRAY TSRMLS_CC);
-       } else if (Z_TYPE_PP(op) == IS_ARRAY) {
+               zval_ptr_dtor(return_value);
+               ZVAL_COPY(return_value, input);
+               php_filter_call(return_value, FILTER_DEFAULT, NULL, 0, FILTER_REQUIRE_ARRAY TSRMLS_CC);
+       } else if (Z_TYPE_P(op) == IS_LONG) {
+               zval_ptr_dtor(return_value);
+               ZVAL_COPY(return_value, input);
+               php_filter_call(return_value, Z_LVAL_P(op), NULL, 0, FILTER_REQUIRE_ARRAY TSRMLS_CC);
+       } else if (Z_TYPE_P(op) == IS_ARRAY) {
                array_init(return_value);
 
-               zend_hash_internal_pointer_reset(Z_ARRVAL_PP(op));
-               for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(op), &pos);
-                       zend_hash_get_current_data_ex(Z_ARRVAL_PP(op), (void **) &arg_elm, &pos) == SUCCESS;
-                       zend_hash_move_forward_ex(Z_ARRVAL_PP(op), &pos))
-               {
-                       if (zend_hash_get_current_key_ex(Z_ARRVAL_PP(op), &arg_key, &arg_key_len, &index, 0, &pos) != HASH_KEY_IS_STRING) {
+               ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(op), index, arg_key, arg_elm) {
+                       if (arg_key == NULL) {
                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Numeric keys are not allowed in the definition array");
-                               zval_dtor(return_value);
+                               zval_ptr_dtor(return_value);
                                RETURN_FALSE;
                        }
-                       if (arg_key_len < 2) {
+                       if (arg_key->len == 0) {
                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty keys are not allowed in the definition array");
-                               zval_dtor(return_value);
+                               zval_ptr_dtor(return_value);
                                RETURN_FALSE;
                        }
-                       if (zend_hash_find(Z_ARRVAL_P(input), arg_key, arg_key_len, (void **)&tmp) != SUCCESS) {
+                       if ((tmp = zend_hash_find(Z_ARRVAL_P(input), arg_key)) == NULL) {
                                if (add_empty) {
-                                       add_assoc_null_ex(return_value, arg_key, arg_key_len);
+                                       add_assoc_null_ex(return_value, arg_key->val, arg_key->len);
                                }
                        } else {
-                               zval *nval;
-
-                               ALLOC_ZVAL(nval);
-                               MAKE_COPY_ZVAL(tmp, nval);
-
+                               zval nval;
+                               ZVAL_DUP_DEREF(&nval, tmp);
                                php_filter_call(&nval, -1, arg_elm, 0, FILTER_REQUIRE_SCALAR TSRMLS_CC);
-                               add_assoc_zval_ex(return_value, arg_key, arg_key_len, nval);
+                               zend_hash_update(Z_ARRVAL_P(return_value), arg_key, &nval);
                        }
-               }
+               } ZEND_HASH_FOREACH_END();
        } else {
                RETURN_FALSE;
        }
@@ -737,13 +709,12 @@ static void php_filter_array_handler(zval *input, zval **op, zval *return_value,
  */
 PHP_FUNCTION(filter_input)
 {
-       long   fetch_from, filter = FILTER_DEFAULT;
-       zval **filter_args = NULL, **tmp;
-       zval  *input = NULL;
-       char *var;
-       int var_len;
+       long fetch_from, filter = FILTER_DEFAULT;
+       zval *filter_args = NULL, *tmp;
+       zval *input = NULL;
+       zend_string *var;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls|lZ", &fetch_from, &var, &var_len, &filter, &filter_args) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lS|lz", &fetch_from, &var, &filter, &filter_args) == FAILURE) {
                return;
        }
 
@@ -753,21 +724,20 @@ PHP_FUNCTION(filter_input)
 
        input = php_filter_get_storage(fetch_from TSRMLS_CC);
 
-       if (!input || !HASH_OF(input) || zend_hash_find(HASH_OF(input), var, var_len + 1, (void **)&tmp) != SUCCESS) {
+       if (!input || !HASH_OF(input) || (tmp = zend_hash_find(HASH_OF(input), var)) == NULL) {
                long filter_flags = 0;
-               zval **option, **opt, **def;
+               zval *option, *opt, *def;
                if (filter_args) {
-                       if (Z_TYPE_PP(filter_args) == IS_LONG) {
-                               filter_flags = Z_LVAL_PP(filter_args);
-                       } else if (Z_TYPE_PP(filter_args) == IS_ARRAY && zend_hash_find(HASH_OF(*filter_args), "flags", sizeof("flags"), (void **)&option) == SUCCESS) {
+                       if (Z_TYPE_P(filter_args) == IS_LONG) {
+                               filter_flags = Z_LVAL_P(filter_args);
+                       } else if (Z_TYPE_P(filter_args) == IS_ARRAY && (option = zend_hash_str_find(HASH_OF(filter_args), "flags", sizeof("flags") - 1)) != NULL) {
                                PHP_FILTER_GET_LONG_OPT(option, filter_flags);
                        }
-                       if (Z_TYPE_PP(filter_args) == IS_ARRAY && 
-                               zend_hash_find(HASH_OF(*filter_args), "options", sizeof("options"), (void **)&opt) == SUCCESS &&
-                               Z_TYPE_PP(opt) == IS_ARRAY &&
-                               zend_hash_find(HASH_OF(*opt), "default", sizeof("default"), (void **)&def) == SUCCESS
-                       ) {
-                               MAKE_COPY_ZVAL(def, return_value);
+                       if (Z_TYPE_P(filter_args) == IS_ARRAY && 
+                               (opt = zend_hash_str_find(HASH_OF(filter_args), "options", sizeof("options") - 1)) != NULL &&
+                               Z_TYPE_P(opt) == IS_ARRAY &&
+                               (def = zend_hash_str_find(HASH_OF(opt), "default", sizeof("default") - 1)) != NULL) {
+                               ZVAL_COPY(return_value, def);
                                return;
                        }
                }
@@ -784,9 +754,9 @@ PHP_FUNCTION(filter_input)
                }
        }
 
-       MAKE_COPY_ZVAL(tmp, return_value);
+       ZVAL_DUP(return_value, tmp);
 
-       php_filter_call(&return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR TSRMLS_CC);
+       php_filter_call(return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR TSRMLS_CC);
 }
 /* }}} */
 
@@ -796,9 +766,9 @@ PHP_FUNCTION(filter_input)
 PHP_FUNCTION(filter_var)
 {
        long filter = FILTER_DEFAULT;
-       zval **filter_args = NULL, *data;
+       zval *filter_args = NULL, *data;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/|lZ", &data, &filter, &filter_args) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/|lz", &data, &filter, &filter_args) == FAILURE) {
                return;
        }
 
@@ -806,9 +776,9 @@ PHP_FUNCTION(filter_var)
                RETURN_FALSE;
        }
 
-       MAKE_COPY_ZVAL(&data, return_value);
+       ZVAL_COPY(return_value, data);
 
-       php_filter_call(&return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR TSRMLS_CC);
+       php_filter_call(return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR TSRMLS_CC);
 }
 /* }}} */
 
@@ -818,17 +788,14 @@ PHP_FUNCTION(filter_var)
 PHP_FUNCTION(filter_input_array)
 {
        long    fetch_from;
-       zval   *array_input = NULL, **op = NULL;
+       zval   *array_input = NULL, *op = NULL;
        zend_bool add_empty = 1;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|Zb",  &fetch_from, &op, &add_empty) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|zb",  &fetch_from, &op, &add_empty) == FAILURE) {
                return;
        }
 
-       if (op
-               && (Z_TYPE_PP(op) != IS_ARRAY)
-               && (Z_TYPE_PP(op) == IS_LONG && !PHP_FILTER_ID_EXISTS(Z_LVAL_PP(op)))
-               ) {
+       if (op && (Z_TYPE_P(op) != IS_ARRAY) && (Z_TYPE_P(op) == IS_LONG && !PHP_FILTER_ID_EXISTS(Z_LVAL_P(op)))) {
                RETURN_FALSE;
        }
 
@@ -836,11 +803,11 @@ PHP_FUNCTION(filter_input_array)
 
        if (!array_input || !HASH_OF(array_input)) {
                long filter_flags = 0;
-               zval **option;
+               zval *option;
                if (op) {
-                       if (Z_TYPE_PP(op) == IS_LONG) {
-                               filter_flags = Z_LVAL_PP(op);
-                       } else if (Z_TYPE_PP(op) == IS_ARRAY && zend_hash_find(HASH_OF(*op), "flags", sizeof("flags"), (void **)&option) == SUCCESS) {
+                       if (Z_TYPE_P(op) == IS_LONG) {
+                               filter_flags = Z_LVAL_P(op);
+                       } else if (Z_TYPE_P(op) == IS_ARRAY && (option = zend_hash_str_find(HASH_OF(op), "flags", sizeof("flags") - 1)) != NULL) {
                                PHP_FILTER_GET_LONG_OPT(option, filter_flags);
                        }
                }
@@ -866,17 +833,14 @@ PHP_FUNCTION(filter_input_array)
  */
 PHP_FUNCTION(filter_var_array)
 {
-       zval *array_input = NULL, **op = NULL;
+       zval *array_input = NULL, *op = NULL;
        zend_bool add_empty = 1;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|Zb",  &array_input, &op, &add_empty) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|zb",  &array_input, &op, &add_empty) == FAILURE) {
                return;
        }
 
-       if (op
-               && (Z_TYPE_PP(op) != IS_ARRAY)
-               && (Z_TYPE_PP(op) == IS_LONG && !PHP_FILTER_ID_EXISTS(Z_LVAL_PP(op)))
-               ) {
+       if (op && (Z_TYPE_P(op) != IS_ARRAY) && (Z_TYPE_P(op) == IS_LONG && !PHP_FILTER_ID_EXISTS(Z_LVAL_P(op)))) {
                RETURN_FALSE;
        }
 
index fc596f02ca746565790ae4338cf0e713bface832..4eec7b9119002ccebd11d14e0b5698aefe9e9072 100644 (file)
 }
 
 #define PHP_FILTER_GET_LONG_OPT(zv, opt) { \
-       if (Z_TYPE_PP(zv) != IS_LONG) {                                                                      \
-               zval ___tmp = **zv;                                                                                 \
-               zval_copy_ctor(&___tmp);                                                                                    \
-               convert_to_long(&___tmp);                                                                                   \
-               opt = Z_LVAL(___tmp);                                                                                  \
-       } else {                                                                                                     \
-               opt = Z_LVAL_PP(zv);                                                                        \
-       }                                                                                                            \
+       if (Z_TYPE_P(zv) != IS_LONG) { \
+               zval ___tmp; \
+               ZVAL_DUP(&___tmp, zv); \
+               convert_to_long(&___tmp); \
+               opt = Z_LVAL(___tmp); \
+       } else { \
+               opt = Z_LVAL_P(zv); \
+       } \
 }
 
 #endif /* FILTER_PRIVATE_H */
index 923e6f6a393291b3a33fe492cfa6207fe8ae6d4b..e2c743fd13cf0e3b13ddce321aaa22808bdfc43f 100644 (file)
 
 
 /* {{{ FETCH_LONG_OPTION(var_name, option_name) */
-#define FETCH_LONG_OPTION(var_name, option_name)                                                                         \
-       var_name = 0;                                                                                                        \
-       var_name##_set = 0;                                                                                                  \
-       if (option_array) {                                                                                                  \
-               if (zend_hash_find(HASH_OF(option_array), option_name, sizeof(option_name), (void **) &option_val) == SUCCESS) { \
-                       PHP_FILTER_GET_LONG_OPT(option_val, var_name);                                                          \
-                       var_name##_set = 1;                                                                                          \
-               }                                                                                                                \
+#define FETCH_LONG_OPTION(var_name, option_name) \
+       var_name = 0; \
+       var_name##_set = 0; \
+       if (option_array) { \
+               if ((option_val = zend_hash_str_find(HASH_OF(option_array), option_name, sizeof(option_name) - 1)) != NULL) {   \
+                       PHP_FILTER_GET_LONG_OPT(option_val, var_name); \
+                       var_name##_set = 1; \
+               } \
        }
 /* }}} */
 
 /* {{{ FETCH_STRING_OPTION(var_name, option_name) */
-#define FETCH_STRING_OPTION(var_name, option_name)                                                                       \
-       var_name = NULL;                                                                                                     \
-       var_name##_set = 0;                                                                                                  \
-       var_name##_len = 0;                                                                                                  \
-       if (option_array) {                                                                                                  \
-               if (zend_hash_find(HASH_OF(option_array), option_name, sizeof(option_name), (void **) &option_val) == SUCCESS) { \
-                       if (Z_TYPE_PP(option_val) == IS_STRING) {                                                                    \
-                               var_name = Z_STRVAL_PP(option_val);                                                                      \
-                               var_name##_len = Z_STRLEN_PP(option_val);                                                                \
-                               var_name##_set = 1;                                                                                      \
-                       }                                                                                                            \
-               }                                                                                                                \
+#define FETCH_STRING_OPTION(var_name, option_name) \
+       var_name = NULL; \
+       var_name##_set = 0; \
+       var_name##_len = 0; \
+       if (option_array) { \
+               if ((option_val = zend_hash_str_find(HASH_OF(option_array), option_name, sizeof(option_name) - 1)) != NULL) { \
+                       if (Z_TYPE_P(option_val) == IS_STRING) { \
+                               var_name = Z_STRVAL_P(option_val); \
+                               var_name##_len = Z_STRLEN_P(option_val); \
+                               var_name##_set = 1; \
+                       } \
+               } \
+       }
+/* }}} */
+
+/* {{{ FETCH_STR_OPTION(var_name, option_name) */
+#define FETCH_STR_OPTION(var_name, option_name) \
+       var_name = NULL; \
+       var_name##_set = 0; \
+       if (option_array) { \
+               if ((option_val = zend_hash_str_find(HASH_OF(option_array), option_name, sizeof(option_name) - 1)) != NULL) { \
+                       if (Z_TYPE_P(option_val) == IS_STRING) { \
+                               var_name = Z_STR_P(option_val); \
+                               var_name##_set = 1; \
+                       } \
+               } \
        }
 /* }}} */
 
@@ -170,12 +184,12 @@ static int php_filter_parse_hex(const char *str, unsigned int str_len, long *ret
 
 void php_filter_int(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
 {
-       zval **option_val;
-       long   min_range, max_range, option_flags;
-       int    min_range_set, max_range_set;
-       int    allow_octal = 0, allow_hex = 0;
-       int        len, error = 0;
-       long   ctx_value;
+       zval *option_val;
+       long  min_range, max_range, option_flags;
+       int   min_range_set, max_range_set;
+       int   allow_octal = 0, allow_hex = 0;
+       int       len, error = 0;
+       long  ctx_value;
        char *p;
 
        /* Parse options */
@@ -226,9 +240,8 @@ void php_filter_int(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
        if (error > 0 || (min_range_set && (ctx_value < min_range)) || (max_range_set && (ctx_value > max_range))) {
                RETURN_VALIDATION_FAILED
        } else {
-               zval_dtor(value);
-               Z_TYPE_P(value) = IS_LONG;
-               Z_LVAL_P(value) = ctx_value;
+               zval_ptr_dtor(value);
+               ZVAL_LONG(value, ctx_value);
                return;
        }
 }
@@ -308,8 +321,7 @@ void php_filter_float(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
        int len;
        char *str, *end;
        char *num, *p;
-
-       zval **option_val;
+       zval *option_val;
        char *decimal;
        int decimal_set, decimal_len;
        char dec_sep = '.';
@@ -387,17 +399,15 @@ void php_filter_float(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
 
        switch (is_numeric_string(num, p - num, &lval, &dval, 0)) {
                case IS_LONG:
-                       zval_dtor(value);
-                       Z_TYPE_P(value) = IS_DOUBLE;
-                       Z_DVAL_P(value) = lval;
+                       zval_ptr_dtor(value);
+                       ZVAL_DOUBLE(value, lval);
                        break;
                case IS_DOUBLE:
                        if ((!dval && p - num > 1 && strpbrk(num, "123456789")) || !zend_finite(dval)) {
                                goto error;
                        }
-                       zval_dtor(value);
-                       Z_TYPE_P(value) = IS_DOUBLE;
-                       Z_DVAL_P(value) = dval;
+                       zval_ptr_dtor(value);
+                       ZVAL_DOUBLE(value, dval);
                        break;
                default:
 error:
@@ -410,21 +420,18 @@ error:
 
 void php_filter_validate_regexp(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
 {
-       zval **option_val;
-       char  *regexp;
-       int regexp_len;
-       long   option_flags;
-       int    regexp_set, option_flags_set;
-
-       pcre       *re = NULL;
+       zval *option_val;
+       zend_string *regexp;
+       long option_flags;
+       int regexp_set, option_flags_set;
+       pcre *re = NULL;
        pcre_extra *pcre_extra = NULL;
        int preg_options = 0;
-
-       int         ovector[3];
-       int         matches;
+       int ovector[3];
+       int matches;
 
        /* Parse options */
-       FETCH_STRING_OPTION(regexp, "regexp");
+       FETCH_STR_OPTION(regexp, "regexp");
        FETCH_LONG_OPTION(option_flags, "flags");
 
        if (!regexp_set) {
@@ -527,12 +534,12 @@ void php_filter_validate_email(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
         *
         */
        const char regexp[] = "/^(?!(?:(?:\\x22?\\x5C[\\x00-\\x7E]\\x22?)|(?:\\x22?[^\\x5C\\x22]\\x22?)){255,})(?!(?:(?:\\x22?\\x5C[\\x00-\\x7E]\\x22?)|(?:\\x22?[^\\x5C\\x22]\\x22?)){65,}@)(?:(?:[\\x21\\x23-\\x27\\x2A\\x2B\\x2D\\x2F-\\x39\\x3D\\x3F\\x5E-\\x7E]+)|(?:\\x22(?:[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x21\\x23-\\x5B\\x5D-\\x7F]|(?:\\x5C[\\x00-\\x7F]))*\\x22))(?:\\.(?:(?:[\\x21\\x23-\\x27\\x2A\\x2B\\x2D\\x2F-\\x39\\x3D\\x3F\\x5E-\\x7E]+)|(?:\\x22(?:[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x21\\x23-\\x5B\\x5D-\\x7F]|(?:\\x5C[\\x00-\\x7F]))*\\x22)))*@(?:(?:(?!.*[^.]{64,})(?:(?:(?:xn--)?[a-z0-9]+(?:-+[a-z0-9]+)*\\.){1,126}){1,}(?:(?:[a-z][a-z0-9]*)|(?:(?:xn--)[a-z0-9]+))(?:-+[a-z0-9]+)*)|(?:\\[(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){7})|(?:(?!(?:.*[a-f0-9][:\\]]){7,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?)))|(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){5}:)|(?:(?!(?:.*[a-f0-9]:){5,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3}:)?)))?(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))(?:\\.(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))){3}))\\]))$/iD";
-
        pcre       *re = NULL;
        pcre_extra *pcre_extra = NULL;
        int preg_options = 0;
        int         ovector[150]; /* Needs to be a multiple of 3 */
        int         matches;
+       zend_string *sregexp;
 
 
        /* The maximum length of an e-mail address is 320 octets, per RFC 2821. */
@@ -540,10 +547,13 @@ void php_filter_validate_email(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
                RETURN_VALIDATION_FAILED
        }
 
-       re = pcre_get_compiled_regex((char *)regexp, &pcre_extra, &preg_options TSRMLS_CC);
+       sregexp = STR_INIT(regexp, sizeof(regexp) - 1, 0);
+       re = pcre_get_compiled_regex(sregexp, &pcre_extra, &preg_options TSRMLS_CC);
        if (!re) {
+               STR_RELEASE(sregexp);
                RETURN_VALIDATION_FAILED
        }
+       STR_RELEASE(sregexp);
        matches = pcre_exec(re, NULL, Z_STRVAL_P(value), Z_STRLEN_P(value), 0, 0, ovector, 3);
 
        /* 0 means that the vector is too small to hold all the captured substring offsets */
@@ -787,7 +797,7 @@ void php_filter_validate_mac(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
        char separator;
        char *exp_separator;
        long ret = 0;
-       zval **option_val;
+       zval *option_val;
 
        FETCH_STRING_OPTION(exp_separator, "separator");
 
index 37ccdd23bb8931503492ce17b0379096218a48c9..9ebc18663b87391c248d9440c3308a086ab19503 100644 (file)
@@ -53,14 +53,14 @@ PHP_FUNCTION(filter_has_var);
 PHP_FUNCTION(filter_id);
 
 ZEND_BEGIN_MODULE_GLOBALS(filter)
-       zval *post_array;
-       zval *get_array;
-       zval *cookie_array;
-       zval *env_array;
-       zval *server_array;
-       zval *session_array;
-       long  default_filter;
-       long  default_filter_flags;
+       zval post_array;
+       zval get_array;
+       zval cookie_array;
+       zval env_array;
+       zval server_array;
+       zval session_array;
+       long default_filter;
+       long default_filter_flags;
 ZEND_END_MODULE_GLOBALS(filter)
 
 #ifdef ZTS
index 7d1e74830efce031852567dda3d9d476def1e931..638288a1eb05bb5bf9b8a64ac3ee4c2f4d050b7e 100644 (file)
@@ -51,9 +51,8 @@ static void php_filter_encode_html(zval *value, const unsigned char *chars)
        }
 
        smart_str_0(&str);
-       str_efree(Z_STRVAL_P(value));
-       Z_STRVAL_P(value) = str.c;
-       Z_STRLEN_P(value) = str.len;
+       zval_ptr_dtor(value);
+       ZVAL_STR(value, str.s);
 }
 
 static const unsigned char hexchars[] = "0123456789ABCDEF";
@@ -66,15 +65,16 @@ static const unsigned char hexchars[] = "0123456789ABCDEF";
 
 static void php_filter_encode_url(zval *value, const unsigned char* chars, const int char_len, int high, int low, int encode_nul)
 {
-       unsigned char *str, *p;
+       unsigned char *p;
        unsigned char tmp[256];
        unsigned char *s = (unsigned char *)chars;
        unsigned char *e = s + char_len;
+       zend_string *str;
 
        memset(tmp, 1, sizeof(tmp)-1);
 
        while (s < e) {
-               tmp[*s++] = 0;
+               tmp[*s++] = '\0';
        }
 /* XXX: This is not needed since these chars in the allowed list never include the high/low/null value
        if (encode_nul) {
@@ -87,8 +87,9 @@ static void php_filter_encode_url(zval *value, const unsigned char* chars, const
                memset(tmp, 1, 32);
        }
 */
-       p = str = (unsigned char *) safe_emalloc(3, Z_STRLEN_P(value), 1);
-       s = (unsigned char *)Z_STRVAL_P(value);
+       str = STR_ALLOC(3 * Z_STRLEN_P(value), 0);
+       p = str->val;
+       s = Z_STRVAL_P(value);
        e = s + Z_STRLEN_P(value);
 
        while (s < e) {
@@ -102,15 +103,16 @@ static void php_filter_encode_url(zval *value, const unsigned char* chars, const
                s++;    
        }
        *p = '\0';
-       str_efree(Z_STRVAL_P(value));
-       Z_STRVAL_P(value) = (char *)str;
-       Z_STRLEN_P(value) = p - str;
+       str->len = p - (unsigned char *)str->val;
+       zval_ptr_dtor(value);
+       ZVAL_STR(value, str);
 }
 
 static void php_filter_strip(zval *value, long flags)
 {
-       unsigned char *buf, *str;
+       unsigned char *str;
        int   i, c;
+       zend_string *buf;
        
        /* Optimization for if no strip flags are set */
        if (! ((flags & FILTER_FLAG_STRIP_LOW) || (flags & FILTER_FLAG_STRIP_HIGH)) ) {
@@ -118,22 +120,22 @@ static void php_filter_strip(zval *value, long flags)
        }
 
        str = (unsigned char *)Z_STRVAL_P(value);
-       buf = safe_emalloc(1, Z_STRLEN_P(value) + 1, 1);
+       buf = STR_ALLOC(Z_STRLEN_P(value) + 1, 0);
        c = 0;
        for (i = 0; i < Z_STRLEN_P(value); i++) {
                if ((str[i] > 127) && (flags & FILTER_FLAG_STRIP_HIGH)) {
                } else if ((str[i] < 32) && (flags & FILTER_FLAG_STRIP_LOW)) {
                } else if ((str[i] == '`') && (flags & FILTER_FLAG_STRIP_BACKTICK)) {
                } else {
-                       buf[c] = str[i];
+                       buf->val[c] = str[i];
                        ++c;
                }
        }
        /* update zval string data */
-       buf[c] = '\0';
-       str_efree(Z_STRVAL_P(value));
-       Z_STRVAL_P(value) = (char *)buf;
-       Z_STRLEN_P(value) = c;
+       buf->val[c] = '\0';
+       buf->len = c;
+       zval_ptr_dtor(value);
+       ZVAL_STR(value, buf);
 }
 /* }}} */
 
@@ -155,23 +157,24 @@ static void filter_map_update(filter_map *map, int flag, const unsigned char *al
 
 static void filter_map_apply(zval *value, filter_map *map)
 {
-       unsigned char *buf, *str;
+       unsigned char *str;
        int   i, c;
+       zend_string *buf;
        
        str = (unsigned char *)Z_STRVAL_P(value);
-       buf = safe_emalloc(1, Z_STRLEN_P(value) + 1, 1);
+       buf = STR_ALLOC(Z_STRLEN_P(value) + 1, 0);
        c = 0;
        for (i = 0; i < Z_STRLEN_P(value); i++) {
                if ((*map)[str[i]]) {
-                       buf[c] = str[i];
+                       buf->val[c] = str[i];
                        ++c;
                }
        }
        /* update zval string data */
-       buf[c] = '\0';
-       str_efree(Z_STRVAL_P(value));
-       Z_STRVAL_P(value) = (char *)buf;
-       Z_STRLEN_P(value) = c;
+       buf->val[c] = '\0';
+       buf->len = c;
+       zval_ptr_dtor(value);
+       ZVAL_STR(value, buf);
 }
 /* }}} */
 
@@ -249,8 +252,7 @@ void php_filter_special_chars(PHP_INPUT_FILTER_PARAM_DECL)
 /* {{{ php_filter_full_special_chars */
 void php_filter_full_special_chars(PHP_INPUT_FILTER_PARAM_DECL)
 {
-       char *buf;
-       size_t len;
+       zend_string *buf;
        int quotes;
        
        if (!(flags & FILTER_FLAG_NO_ENCODE_QUOTES)) {
@@ -258,10 +260,9 @@ void php_filter_full_special_chars(PHP_INPUT_FILTER_PARAM_DECL)
        } else {
                quotes = ENT_NOQUOTES;
        }
-       buf = php_escape_html_entities_ex(Z_STRVAL_P(value), Z_STRLEN_P(value), &len, 1, quotes, SG(default_charset), 0 TSRMLS_CC);
-       str_efree(Z_STRVAL_P(value));
-       Z_STRVAL_P(value) = buf;
-       Z_STRLEN_P(value) = len;
+       buf = php_escape_html_entities_ex(Z_STRVAL_P(value), Z_STRLEN_P(value), 1, quotes, SG(default_charset), 0 TSRMLS_CC);
+       zval_ptr_dtor(value);
+       ZVAL_STR(value, buf);
 }
 /* }}} */
 
@@ -292,8 +293,6 @@ void php_filter_unsafe_raw(PHP_INPUT_FILTER_PARAM_DECL)
 }
 /* }}} */
 
-
-
 /* {{{ php_filter_email */
 #define SAFE        "$-_.+"
 #define EXTRA       "!*'(),"
@@ -367,15 +366,13 @@ void php_filter_number_float(PHP_INPUT_FILTER_PARAM_DECL)
 /* {{{ php_filter_magic_quotes */
 void php_filter_magic_quotes(PHP_INPUT_FILTER_PARAM_DECL)
 {
-       char *buf;
-       int   len;
+       zend_string *buf;
        
        /* just call php_addslashes quotes */
-       buf = php_addslashes(Z_STRVAL_P(value), Z_STRLEN_P(value), &len, 0 TSRMLS_CC);
+       buf = php_addslashes(Z_STRVAL_P(value), Z_STRLEN_P(value), 0 TSRMLS_CC);
 
-       str_efree(Z_STRVAL_P(value));
-       Z_STRVAL_P(value) = buf;
-       Z_STRLEN_P(value) = len;
+       zval_ptr_dtor(value);
+       ZVAL_STR(value, buf);
 }
 /* }}} */
 
index f55d1f883b482ddba7d66363393aa6e7649b40e1..18c5c1b20dd89c33c8a98693d8eed24f9431bcde 100644 (file)
@@ -20,7 +20,7 @@ if (false !== getenv('PDO_MYSQL_TEST_DSN')) {
                $config['ENV']['PDOTEST_ATTR'] = getenv('PDO_MYSQL_TEST_ATTR');
        }
 } else {
-       $config['ENV']['PDOTEST_DSN'] = 'mysql:host=localhost;dbname=test';
+       $config['ENV']['PDOTEST_DSN'] = 'mysql:host=127.0.0.1;port=3308;dbname=test';
        $config['ENV']['PDOTEST_USER'] = 'root';
        $config['ENV']['PDOTEST_PASS'] = '';
 }
index 2530442c0eaabd753d69f71ff9d14984b3cdba26..cd8fb3e365a09f9b739e4a9c90159fb05c80022e 100644 (file)
@@ -1,7 +1,7 @@
 <?php
 /* Overrule global settings, if need be */
 
-if (false !== getenv('PDO_MYSQL_TEST_DSN')) {
+if (0 && false !== getenv('PDO_MYSQL_TEST_DSN')) {
        # user set them from their shell
        $config['ENV']['PDOTEST_DSN'] = getenv('PDO_MYSQL_TEST_DSN');
        $config['ENV']['PDOTEST_USER'] = getenv('PDO_MYSQL_TEST_USER');
@@ -10,7 +10,7 @@ if (false !== getenv('PDO_MYSQL_TEST_DSN')) {
                $config['ENV']['PDOTEST_ATTR'] = getenv('PDO_MYSQL_TEST_ATTR');
        }
 } else {
-       $config['ENV']['PDOTEST_DSN'] = 'mysql:host=localhost;dbname=test';
+       $config['ENV']['PDOTEST_DSN'] = 'mysql:host=127.0.0.1;port=3308;dbname=test';
        $config['ENV']['PDOTEST_USER'] = 'root';
        $config['ENV']['PDOTEST_PASS'] = '';
 }
@@ -21,8 +21,8 @@ foreach ($config['ENV'] as $k => $v) {
 
 /* MySQL specific settings */
 define('PDO_MYSQL_TEST_ENGINE', (false !== getenv('PDO_MYSQL_TEST_ENGINE')) ? getenv('PDO_MYSQL_TEST_ENGINE') : 'MyISAM');
-define('PDO_MYSQL_TEST_HOST', (false !== getenv('PDO_MYSQL_TEST_HOST')) ? getenv('PDO_MYSQL_TEST_HOST') : 'localhost');
-define('PDO_MYSQL_TEST_PORT', (false !== getenv('PDO_MYSQL_TEST_PORT')) ? getenv('PDO_MYSQL_TEST_PORT') : NULL);
+define('PDO_MYSQL_TEST_HOST', (false !== getenv('PDO_MYSQL_TEST_HOST')) ? getenv('PDO_MYSQL_TEST_HOST') : '127.0.0.1');
+define('PDO_MYSQL_TEST_PORT', (false !== getenv('PDO_MYSQL_TEST_PORT')) ? getenv('PDO_MYSQL_TEST_PORT') : 3308);
 define('PDO_MYSQL_TEST_DB', (false !== getenv('PDO_MYSQL_TEST_DB')) ? getenv('PDO_MYSQL_TEST_DB') : 'test');
 define('PDO_MYSQL_TEST_SOCKET', (false !== getenv('PDO_MYSQL_TEST_SOCKET')) ? getenv('PDO_MYSQL_TEST_SOCKET') : NULL);
 define('PDO_MYSQL_TEST_DSN', (false !== getenv('PDO_MYSQL_TEST_DSN')) ? getenv('PDO_MYSQL_TEST_DSN') : $config['ENV']['PDOTEST_DSN']);
@@ -49,4 +49,4 @@ if (!function_exists('sys_get_temp_dir')) {
                return FALSE;
        }
 }
-?>
\ No newline at end of file
+?>
index 547dbd5582cc83ee6e0255f0bcc27f11bbff6e5d..c67642c76f655112616d558eeeffc794d2d63e52 100644 (file)
@@ -635,13 +635,14 @@ static void php_autoglobal_merge(HashTable *dest, HashTable *src TSRMLS_DC)
                if (Z_TYPE_P(src_entry) != IS_ARRAY
                        || (key_type == HASH_KEY_IS_STRING && (dest_entry = zend_hash_find(dest, string_key)) == NULL)
                        || (key_type == HASH_KEY_IS_LONG && (dest_entry = zend_hash_index_find(dest, num_key)) == NULL)
-                       || Z_TYPE_P(dest_entry) != IS_ARRAY
-                       ) {
-                       Z_ADDREF_P(src_entry);
+                       || Z_TYPE_P(dest_entry) != IS_ARRAY) {
+                       if (Z_REFCOUNTED_P(src_entry)) {
+                               Z_ADDREF_P(src_entry);
+                       }
                        if (key_type == HASH_KEY_IS_STRING) {
                                if (!globals_check || string_key->len != sizeof("GLOBALS") || memcmp(string_key->val, "GLOBALS", sizeof("GLOBALS") - 1)) {
                                        zend_hash_update(dest, string_key, src_entry);
-                               } else {
+                               } else if (Z_REFCOUNTED_P(src_entry)) {
                                        Z_DELREF_P(src_entry);
                                }
                        } else {