| Authors: Rasmus Lerdorf <rasmus@php.net> |
| Derick Rethans <derick@php.net> |
| Pierre-A. Joye <pierre@php.net> |
+ | Ilia Alshanetsky <iliaa@php.net> |
+----------------------------------------------------------------------+
*/
{ "stripped", FILTER_SANITIZE_STRING, php_filter_string },
{ "encoded", FILTER_SANITIZE_ENCODED, php_filter_encoded },
{ "special_chars", FILTER_SANITIZE_SPECIAL_CHARS, php_filter_special_chars },
- { "unsafe_raw", FILTER_UNSAFE_RAW, php_filter_unsafe_raw },
+ { "unsafe_raw", FILTER_UNSAFE_RAW, php_filter_unsafe_raw },
{ "email", FILTER_SANITIZE_EMAIL, php_filter_email },
{ "url", FILTER_SANITIZE_URL, php_filter_url },
{ "number_int", FILTER_SANITIZE_NUMBER_INT, php_filter_number_int },
#define PARSE_SESSION 6
#endif
-#ifndef PARSE_DATA
-#define PARSE_DATA 7
-#endif
-
static unsigned int php_sapi_filter(int arg, char *var, char **val, unsigned int val_len, unsigned int *new_val_len TSRMLS_DC);
/* {{{ filter_functions[]
*/
zend_function_entry filter_functions[] = {
- PHP_FE(input_get, NULL)
- PHP_FE(input_get_args, NULL)
- PHP_FE(input_filters_list, NULL)
- PHP_FE(input_has_variable, NULL)
- PHP_FE(input_name_to_filter, NULL)
- PHP_FE(filter_data, NULL)
+ PHP_FE(filter_input, NULL)
+ PHP_FE(filter_var, NULL)
+ PHP_FE(filter_input_array, NULL)
+ PHP_FE(filter_var_array, NULL)
+ PHP_FE(filter_list, NULL)
+ PHP_FE(filter_has_var, NULL)
+ PHP_FE(filter_id, NULL)
{NULL, NULL, NULL}
};
/* }}} */
REGISTER_INI_ENTRIES();
REGISTER_LONG_CONSTANT("INPUT_POST", PARSE_POST, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("INPUT_GET", PARSE_GET, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("INPUT_GET", PARSE_GET, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("INPUT_COOKIE", PARSE_COOKIE, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("INPUT_ENV", PARSE_ENV, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("INPUT_ENV", PARSE_ENV, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("INPUT_SERVER", PARSE_SERVER, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("INPUT_SESSION", PARSE_SESSION, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("INPUT_DATA", PARSE_DATA, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("INPUT_REQUEST", PARSE_SESSION, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("FILTER_FLAG_NONE", FILTER_FLAG_NONE, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("FILTER_FLAG_SCALAR", FILTER_FLAG_SCALAR, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("FILTER_FLAG_ARRAY", FILTER_FLAG_ARRAY, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("FILTER_REQUIRE_SCALAR", FILTER_REQUIRE_SCALAR, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("FILTER_REQUIRE_ARRAY", FILTER_REQUIRE_ARRAY, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("FILTER_FORCE_ARRAY", FILTER_FORCE_ARRAY, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("FILTER_VALIDATE_INT", FILTER_VALIDATE_INT, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("FILTER_VALIDATE_BOOLEAN", FILTER_VALIDATE_BOOLEAN, CONST_CS | CONST_PERSISTENT);
zval_ptr_dtor(&IF_G(a)); \
IF_G(a) = NULL; \
}
+
PHP_RSHUTDOWN_FUNCTION(filter)
{
VAR_ARRAY_COPY_DTOR(get_array)
static void php_zval_filter_recursive(zval **value, long filter, long flags, zval *options, char *charset, zend_bool copy TSRMLS_DC) /* {{{ */
{
- zval **element;
- HashPosition pos;
-
if (Z_TYPE_PP(value) == IS_ARRAY) {
+ zval **element;
+ HashPosition pos;
+
+ if (Z_ARRVAL_PP(value)->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)) {
- php_zval_filter_recursive(element, filter, flags, options, charset, copy TSRMLS_CC);
+
+ if (Z_TYPE_PP(element) == IS_ARRAY) {
+ Z_ARRVAL_PP(element)->nApplyCount++;
+ php_zval_filter_recursive(element, filter, flags, options, charset, copy TSRMLS_CC);
+ Z_ARRVAL_PP(element)->nApplyCount--;
+ } else {
+ php_zval_filter(element, filter, flags, options, charset, copy TSRMLS_CC);
+ }
}
} else {
php_zval_filter(value, filter, flags, options, charset, copy TSRMLS_CC);
}
/* }}} */
-static zval * php_filter_get_storage(long arg TSRMLS_DC) /* {{{ */
+/* {{{ */
+static zval *php_filter_get_storage(long arg TSRMLS_DC)
{
- zval * array_ptr = NULL;
+ zval *array_ptr = NULL;
zend_bool jit_initialization = (PG(auto_globals_jit) && !PG(register_globals) && !PG(register_long_arrays));
+
switch (arg) {
case PARSE_GET:
array_ptr = IF_G(get_array);
array_ptr = IF_G(cookie_array);
break;
case PARSE_SERVER:
- if(jit_initialization) zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
+ if (jit_initialization) {
+ zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
+ }
array_ptr = IF_G(server_array);
break;
case PARSE_ENV:
- if(jit_initialization) zend_is_auto_global("_ENV", sizeof("_ENV")-1 TSRMLS_CC);
+ if (jit_initialization) {
+ zend_is_auto_global("_ENV", sizeof("_ENV")-1 TSRMLS_CC);
+ }
array_ptr = IF_G(env_array);
break;
+ case PARSE_SESSION:
+ /* FIXME: Implement session source */
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "INPUT_SESSION is not yet implemented");
+ break;
+ case PARSE_REQUEST:
+ /* FIXME: Implement request source */
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "INPUT_REQUEST is not yet implemented");
+ break;
}
return array_ptr;
}
/* }}} */
-/* {{{ proto mixed input_has_variable(constant type, string variable_name)
+/* {{{ proto mixed filter_has_var(constant type, string variable_name)
* Returns true if the variable with the name 'name' exists in source.
*/
-PHP_FUNCTION(input_has_variable)
+PHP_FUNCTION(filter_has_var)
{
long arg;
char *var;
int var_len;
zval **tmp;
zval *array_ptr = NULL;
- HashTable *hash_ptr;
- int found = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &arg, &var, &var_len) == FAILURE) {
- return;
- }
-
- array_ptr = php_filter_get_storage(arg TSRMLS_CC);
-
- if (!array_ptr) {
RETURN_FALSE;
}
- if (!found) {
- hash_ptr = HASH_OF(array_ptr);
+ array_ptr = php_filter_get_storage(arg TSRMLS_CC);
- if (hash_ptr && zend_hash_find(hash_ptr, var, var_len + 1, (void **)&tmp) == SUCCESS) {
- RETURN_TRUE;
- }
+ if (array_ptr && HASH_OF(array_ptr) && zend_hash_find(HASH_OF(array_ptr), var, var_len + 1, (void **)&tmp) == SUCCESS) {
+ RETURN_TRUE;
}
RETURN_FALSE;
}
/* }}} */
-/* {{{ proto mixed input_get(constant type, string variable_name [, int filter [, mixed flags [, string charset]]])
- * Returns the filtered variable 'name'* from source `type`.
- */
-PHP_FUNCTION(input_get)
-{
- long arg, filter = FILTER_DEFAULT;
- char *var, *charset = NULL;
- int var_len, charset_len;
- zval **flags = NULL;
- zval **tmp;
- zval *array_ptr = NULL, *array_ptr2 = NULL, *array_ptr3 = NULL;
- HashTable *hash_ptr;
- int found = 0;
- long filter_flags = 0;
- zval *options = NULL;
-
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls|lZs", &arg, &var, &var_len, &filter, &flags, &charset, &charset_len) == FAILURE) {
- return;
- }
-
- if (flags) {
- switch (Z_TYPE_PP(flags)) {
- case IS_ARRAY:
- options = *flags;
- break;
- case IS_STRING:
- case IS_BOOL:
- case IS_LONG:
- convert_to_long_ex(flags);
- filter_flags = Z_LVAL_PP(flags);
- options = NULL;
- break;
+static void php_filter_call(zval **filtered, long filter, zval **filter_args, const int copy, long filter_flags)
+{
+ zval *options = NULL;
+ zval **option;
+ char *charset = NULL;
+
+ if (filter_args && Z_TYPE_PP(filter_args) != IS_ARRAY) {
+ convert_to_long_ex(filter_args);
+ if (filter != -1) { /* handler for array apply */
+ /* filter_args is the filter_flags */
+ filter_flags = Z_LVAL_PP(filter_args);
+ } else {
+ filter = Z_LVAL_PP(filter_args);
+ }
+ } else if (filter_args) {
+ if (zend_hash_find(HASH_OF(*filter_args), "filter", sizeof("filter"), (void **)&option) == SUCCESS) {
+ convert_to_long(*option);
+ filter = Z_LVAL_PP(option);
}
- }
-
- switch(arg) {
- case PARSE_GET:
- case PARSE_POST:
- case PARSE_COOKIE:
- case PARSE_SERVER:
- case PARSE_ENV:
- array_ptr = php_filter_get_storage(arg TSRMLS_CC);
- break;
- case PARSE_SESSION:
- /* FIXME: Implement session source */
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "INPUT_SESSION not implemented");
- break;
+ if (zend_hash_find(HASH_OF(*filter_args), "flags", sizeof("flags"), (void **)&option) == SUCCESS) {
+ convert_to_long(*option);
+ filter_flags = Z_LVAL_PP(option);
+ }
- case PARSE_REQUEST:
- /* FIXME: Implement request source */
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "INPUT_REQUEST not implemented");
- return;
- if (PG(variables_order)) {
- zval **a_ptr = &array_ptr;
- char *p, *variables_order = PG(variables_order);
-
- for (p = variables_order; p && *p; p++) {
- switch (*p) {
- case 'p':
- case 'P':
- if (IF_G(default_filter) != FILTER_UNSAFE_RAW) {
- *a_ptr = IF_G(post_array);
- } else {
- *a_ptr = PG(http_globals)[TRACK_VARS_POST];
- }
- break;
- case 'g':
- case 'G':
- if (IF_G(default_filter) != FILTER_UNSAFE_RAW) {
- *a_ptr = IF_G(get_array);
- } else {
- *a_ptr = PG(http_globals)[TRACK_VARS_GET];
- }
- break;
- case 'c':
- case 'C':
- if (IF_G(default_filter) != FILTER_UNSAFE_RAW) {
- *a_ptr = IF_G(cookie_array);
- } else {
- *a_ptr = PG(http_globals)[TRACK_VARS_COOKIE];
- }
- break;
- }
- if (array_ptr && !array_ptr2) {
- a_ptr = &array_ptr2;
- continue;
- }
- if (array_ptr2 && !array_ptr3) {
- a_ptr = &array_ptr3;
- }
+ if (zend_hash_find(HASH_OF(*filter_args), "options", sizeof("options"), (void **)&option) == SUCCESS) {
+ if (filter != FILTER_CALLBACK) {
+ if (Z_TYPE_PP(option) == IS_ARRAY) {
+ options = *option;
}
} else {
- array_ptr = php_filter_get_storage(PARSE_GET TSRMLS_CC);
+ options = *option;
+ filter_flags = 0;
}
+ }
}
- if (!array_ptr) {
- RETURN_FALSE;
- }
-
- if (array_ptr3) {
- hash_ptr = HASH_OF(array_ptr3);
- if (hash_ptr && zend_hash_find(hash_ptr, var, var_len + 1, (void **)&tmp) == SUCCESS) {
- *return_value = **tmp;
- found = 1;
+ if (Z_TYPE_PP(filtered) == IS_ARRAY) {
+ if (filter_flags & FILTER_REQUIRE_SCALAR) {
+ if (copy) {
+ SEPARATE_ZVAL(filtered);
+ }
+ zval_dtor(*filtered);
+ ZVAL_FALSE(*filtered);
+ return;
}
+ php_zval_filter_recursive(filtered, filter, filter_flags, options, charset, copy TSRMLS_CC);
+ return;
}
-
- if (array_ptr2 && !found) {
- hash_ptr = HASH_OF(array_ptr2);
- if (hash_ptr && zend_hash_find(hash_ptr, var, var_len + 1, (void **)&tmp) == SUCCESS) {
- *return_value = **tmp;
- found = 1;
+ if (filter_flags & FILTER_REQUIRE_ARRAY) {
+ if (copy) {
+ SEPARATE_ZVAL(filtered);
}
+ zval_dtor(*filtered);
+ ZVAL_FALSE(*filtered);
+ return;
}
- if (!found) {
- hash_ptr = HASH_OF(array_ptr);
+ php_zval_filter(filtered, filter, filter_flags, options, charset, copy TSRMLS_CC);
+ if (filter_flags & FILTER_FORCE_ARRAY) {
+ zval *temp_array;
- if (hash_ptr && zend_hash_find(hash_ptr, var, var_len + 1, (void **)&tmp) == SUCCESS) {
- *return_value = **tmp;
- found = 1;
- }
+ ALLOC_INIT_ZVAL(temp_array);
+ array_init(temp_array);
+ add_next_index_zval(temp_array, *filtered);
+ *filtered = temp_array;
}
+}
- if (found) {
- zval **option;
+static void php_filter_array_handler(zval *input, zval **op, zval *return_value)
+{
+ char *arg_key;
+ uint arg_key_len;
+ ulong index;
+ HashPosition pos;
+ zval **tmp, **arg_elm;
+
+ if (!op) {
+ SEPARATE_ZVAL(&input);
+ *return_value = *input;
+ php_filter_call(&return_value, FILTER_DEFAULT, NULL, 0, FILTER_REQUIRE_ARRAY);
+ } else if (Z_TYPE_PP(op) == IS_LONG) {
+ SEPARATE_ZVAL(&input);
+ *return_value = *input;
+ php_filter_call(&return_value, Z_LVAL_PP(op), NULL, 0, FILTER_REQUIRE_ARRAY);
+ } else if (Z_TYPE_PP(op) == IS_ARRAY) {
+ array_init(return_value);
- if (options && filter_flags==0 &&
- zend_hash_find(HASH_OF(options), "flags", sizeof("flags"), (void **)&option) == SUCCESS) {
- switch (Z_TYPE_PP(option)) {
- case IS_ARRAY:
- break;
- default:
- convert_to_long(*option);
- filter_flags = Z_LVAL_PP(option);
- break;
- }
- } else {
- filter_flags = filter_flags | FILTER_FLAG_SCALAR;
- }
+ 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) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Numeric keys are not allowed in the definition array.");
+ zval_dtor(return_value);
+ RETURN_FALSE;
+ }
+ if (zend_hash_find(Z_ARRVAL_P(input), arg_key, arg_key_len, (void **)&tmp) != SUCCESS) {
+ add_assoc_null_ex(return_value, arg_key, arg_key_len);
+ } else {
+ zval *nval;
- zval_copy_ctor(return_value); /* Watch out for empty strings */
+ ALLOC_ZVAL(nval);
+ *nval = **tmp;
+ zval_copy_ctor(nval);
+ INIT_PZVAL(nval);
- if (Z_TYPE_P(return_value) == IS_ARRAY && !(filter_flags & FILTER_FLAG_ARRAY)) {
- zval_dtor(return_value);
- ZVAL_BOOL(return_value, 0);
+ php_filter_call(&nval, -1, arg_elm, 0, FILTER_REQUIRE_SCALAR);
+ add_assoc_zval_ex(return_value, arg_key, arg_key_len, nval);
+ }
}
-
- php_zval_filter_recursive(&return_value, filter, filter_flags, options, charset, 1 TSRMLS_CC);
} else {
- RETURN_NULL();
+ RETURN_FALSE;
}
}
-/* }}} */
-/* {{{ proto mixed input_get_args(constant type, array definition, [, array data])
- * Returns an array with all arguments defined in 'definition'. INPUT_DATA will use the data given as last argument.
+
+/* {{{ proto mixed filter_input(constant type, string variable_name [, long filter [, mixed options]])
+ * Returns the filtered variable 'name'* from source `type`.
*/
-PHP_FUNCTION(input_get_args)
+PHP_FUNCTION(filter_input)
{
- long filter = FILTER_DEFAULT;
- char *charset = NULL;
- zval **tmp, ** option;
- int filter_flags = FILTER_FLAG_SCALAR;
- zval *options = NULL, *temparray = NULL;
-
- zval *args_array, *values = NULL;
- HashTable *args_hash;
- HashPosition pos;
-
- HashTable * g_hash;
+ long fetch_from, filter = FILTER_DEFAULT;
+ zval **filter_args = NULL, **data=NULL, **tmp;
+ zval *input = NULL;
- long args_from = 0;
- long elm_count;
- char *key;
- unsigned int key_len;
- unsigned long index;
- zend_bool copy = 0;
-
- /* pointers to the zval array GET, POST,... */
- zval *array_ptr = NULL;
- zval **element;
-
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la|a/", &args_from, &args_array, &values) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lZ|lZ", &fetch_from, &data, &filter, &filter_args) == FAILURE) {
RETURN_FALSE;
}
- args_hash = HASH_OF(args_array);
- elm_count = zend_hash_num_elements(args_hash);
+ input = php_filter_get_storage(fetch_from TSRMLS_CC);
- if (elm_count < 1) {
- RETURN_NULL();
+ if (!input || !HASH_OF(input) || zend_hash_find(HASH_OF(input), Z_STRVAL_PP(data), Z_STRLEN_PP(data) + 1, (void **)&tmp) != SUCCESS) {
+ RETURN_FALSE;
}
- switch (args_from) {
- case PARSE_GET:
- case PARSE_POST:
- case PARSE_COOKIE:
- case PARSE_SERVER:
- case PARSE_ENV:
- array_ptr = php_filter_get_storage(args_from TSRMLS_CC);
- break;
-
- case PARSE_DATA:
- array_ptr = values;
- copy = 1;
- break;
-
- case PARSE_SESSION:
- /* FIXME: Implement session source */
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "INPUT_SESSION not implemented");
- break;
+ *return_value = **tmp;
+ zval_copy_ctor(return_value); /* Watch out for empty strings */
- case PARSE_REQUEST:
- /* FIXME: Implement session source */
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "INPUT_REQUEST not implemented");
- return;
- break;
+ php_filter_call(&return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR);
+}
+/* }}} */
- default:
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown INPUT method");
- return;
- break;
- }
+/* {{{ proto mixed filter_var(mixed variable [, long filter [, mixed options]])
+ * Returns the filtered version of the vriable.
+ */
+PHP_FUNCTION(filter_var)
+{
+ long filter = FILTER_DEFAULT;
+ zval **filter_args = NULL, *data;
- if (!array_ptr) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/|lZ", &data, &filter, &filter_args) == FAILURE) {
RETURN_FALSE;
- } else {
- g_hash = HASH_OF(array_ptr);
- if (g_hash) {
- zend_hash_internal_pointer_reset(g_hash);
- }
- array_init(return_value);
}
- for (zend_hash_internal_pointer_reset_ex(args_hash, &pos);
- zend_hash_get_current_data_ex(args_hash, (void **) &element, &pos) == SUCCESS;
- zend_hash_move_forward_ex(args_hash, &pos)) {
+ *return_value = *data;
+ zval_copy_ctor(data);
- if (zend_hash_get_current_key_ex(args_hash, &key, &key_len, &index, 0, &pos) != HASH_KEY_IS_STRING) {
- zval_dtor(return_value);
- RETURN_FALSE;
- }
-
- if (g_hash && zend_hash_find(g_hash, key, key_len, (void **)&tmp) == SUCCESS) {
- if (Z_TYPE_PP(element) != IS_ARRAY) {
- convert_to_long(*element);
- filter = Z_LVAL_PP(element);
- filter_flags = FILTER_FLAG_SCALAR;
-
- if ((filter_flags & FILTER_FLAG_SCALAR) && Z_TYPE_PP(tmp) == IS_ARRAY) {
- /* asked for scalar and found an array do not test further */
- add_assoc_bool(return_value, key, 0);
- continue;
- }
-
- } else {
- if (zend_hash_find(HASH_OF(*element), "filter", sizeof("filter"), (void **)&option) == SUCCESS) {
- convert_to_long(*option);
- filter = Z_LVAL_PP(option);
- }
+ php_filter_call(&return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR);
+}
+/* }}} */
- if (zend_hash_find(HASH_OF(*element), "options", sizeof("options"), (void **)&option) == SUCCESS) {
- if (Z_TYPE_PP(option) == IS_ARRAY) {
- options = *option;
- }
- } else {
- options = NULL;
- }
+/* {{{ proto mixed filter_input_array(constant type, [, mixed options]])
+ * Returns an array with all arguments defined in 'definition'.
+ */
+PHP_FUNCTION(filter_input_array)
+{
+ long fetch_from;
+ zval *array_input = NULL, **op = NULL;
- if (zend_hash_find(HASH_OF(*element), "flags", sizeof("flags"), (void **)&option) == SUCCESS) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|Z", &fetch_from, &op) == FAILURE) {
+ RETURN_FALSE;
+ }
- switch (Z_TYPE_PP(option)) {
- case IS_ARRAY:
- break;
- default:
- convert_to_long(*option);
- filter_flags = Z_LVAL_PP(option);
- break;
- }
- } else {
- filter_flags = FILTER_FLAG_SCALAR;
- }
+ array_input = php_filter_get_storage(fetch_from TSRMLS_CC);
- if ((filter_flags & FILTER_FLAG_SCALAR) && Z_TYPE_PP(tmp) == IS_ARRAY) {
- /* asked for scalar and found an array do not test further */
- add_assoc_bool(return_value, key, 0);
- continue;
- }
+ if (!array_input || !HASH_OF(array_input)) {
+ RETURN_FALSE;
+ }
- if (zend_hash_find(HASH_OF(*element), "charset", sizeof("charset"), (void **)&option) == SUCCESS) {
- convert_to_string(*option);
- charset = Z_STRVAL_PP(option);
- }
- }
+ php_filter_array_handler(array_input, op, return_value);
+}
+/* }}} */
- if (filter_flags & FILTER_FLAG_ARRAY) {
- php_zval_filter_recursive(tmp, filter, filter_flags, options, charset, copy TSRMLS_CC);
+/* {{{ proto mixed filter_var_array(array data, [, mixed options]])
+ * Returns an array with all arguments defined in 'definition'.
+ */
+PHP_FUNCTION(filter_var_array)
+{
+ zval *array_input = NULL, **op = NULL;
- /* ARRAY always returns an array */
- if (Z_TYPE_PP(tmp) != IS_ARRAY) {
- ALLOC_INIT_ZVAL(temparray);
- array_init(temparray);
- add_next_index_zval(temparray, *tmp);
- *tmp = temparray;
- }
- } else {
- php_zval_filter(tmp, filter, filter_flags, options, charset, copy TSRMLS_CC);
- }
- zval_add_ref(tmp);
- add_assoc_zval(return_value, key, *tmp);
- } else {
- add_assoc_null(return_value, key);
- }
- filter = FILTER_DEFAULT;
- filter_flags = FILTER_FLAG_SCALAR;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|Z", &array_input, &op) == FAILURE) {
+ RETURN_FALSE;
}
+
+ php_filter_array_handler(array_input, op, return_value);
}
/* }}} */
-/* {{{ proto input_filters_list()
+/* {{{ proto filter_list()
* Returns a list of all supported filters */
-PHP_FUNCTION(input_filters_list)
+PHP_FUNCTION(filter_list)
{
int i, size = sizeof(filter_list) / sizeof(filter_list_entry);
+ if (ZEND_NUM_ARGS()) {
+ WRONG_PARAM_COUNT;
+ }
+
array_init(return_value);
for (i = 0; i < size; ++i) {
add_next_index_string(return_value, (char *)filter_list[i].name, 1);
}
/* }}} */
-/* {{{ proto input_name_to_filter(string filtername)
+/* {{{ proto filter_id(string filtername)
* Returns the filter ID belonging to a named filter */
-PHP_FUNCTION(input_name_to_filter)
+PHP_FUNCTION(filter_id)
{
int i, filter_len;
int size = sizeof(filter_list) / sizeof(filter_list_entry);
RETURN_LONG(filter_list[i].id);
}
}
- RETURN_NULL();
-}
-/* }}} */
-/* {{{ proto filter_data(mixed variable, int filter [, mixed filter_options [, string charset ]])
- * Returns the filterd variable (scalar or array can be used).
- */
-PHP_FUNCTION(filter_data)
-{
- long filter = FILTER_DEFAULT;
- char *charset = NULL;
- int charset_len;
- zval *var, **flags = NULL;
- int filter_flags = 0;
- zval *options = NULL;
-
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/l|Zs", &var, &filter, &flags, &charset, &charset_len) == FAILURE) {
- return;
- }
-
- if (filter != FILTER_CALLBACK) {
- if (flags) {
- switch (Z_TYPE_PP(flags)) {
- case IS_ARRAY:
- options = *flags;
- break;
-
- case IS_STRING:
- case IS_BOOL:
- case IS_LONG:
- convert_to_long_ex(flags);
- filter_flags = Z_LVAL_PP(flags);
- options = NULL;
- break;
- }
- }
- } else {
- if (flags) {
- switch (Z_TYPE_PP(flags)) {
- case IS_ARRAY:
- case IS_STRING:
- options = *flags;
- break;
-
- default:
- convert_to_string_ex(flags);
- options = *flags;
- break;
- }
- }
- }
- php_zval_filter_recursive(&var, filter, filter_flags, options, charset, 1 TSRMLS_CC);
- RETURN_ZVAL(var, 1, 0);
+ RETURN_FALSE;
}
/* }}} */
#define FILTER_FLAG_NONE 0x0000
-#define FILTER_FLAG_ARRAY 0x1000000
-#define FILTER_FLAG_SCALAR 0x2000000
+#define FILTER_REQUIRE_ARRAY 0x1000000
+#define FILTER_REQUIRE_SCALAR 0x2000000
+
+#define FILTER_FORCE_ARRAY 0x4000000
#define FILTER_FLAG_ALLOW_OCTAL 0x0001
#define FILTER_FLAG_ALLOW_HEX 0x0002
{
zval **option_val;
long min_range, max_range, option_flags;
- int min_range_set, max_range_set, option_flags_set;
+ int min_range_set, max_range_set;
int allow_octal = 0, allow_hex = 0;
int len, error = 0;
long ctx_value;
/* Parse options */
FETCH_LONG_OPTION(min_range, "min_range");
FETCH_LONG_OPTION(max_range, "max_range");
- FETCH_LONG_OPTION(option_flags, "flags");
+ option_flags = flags;
len = Z_STRLEN_P(value);
return;
}
- if (option_flags_set && (option_flags & FILTER_FLAG_ALLOW_OCTAL)) {
+ if (option_flags & FILTER_FLAG_ALLOW_OCTAL) {
allow_octal = 1;
}
- if (option_flags_set && (option_flags & FILTER_FLAG_ALLOW_HEX)) {
+ if (option_flags & FILTER_FLAG_ALLOW_HEX) {
allow_hex = 1;
}
PHP_RSHUTDOWN_FUNCTION(filter);
PHP_MINFO_FUNCTION(filter);
-PHP_FUNCTION(input_get);
-PHP_FUNCTION(input_get_args);
-PHP_FUNCTION(input_filters_list);
-PHP_FUNCTION(input_has_variable);
-PHP_FUNCTION(input_name_to_filter);
-PHP_FUNCTION(filter_data);
+PHP_FUNCTION(filter_input);
+PHP_FUNCTION(filter_var);
+PHP_FUNCTION(filter_input_array);
+PHP_FUNCTION(filter_var_array);
+PHP_FUNCTION(filter_list);
+PHP_FUNCTION(filter_has_var);
+PHP_FUNCTION(filter_id);
ZEND_BEGIN_MODULE_GLOBALS(filter)
zval *post_array;
foo=<b>abc</b>
--FILE--
<?php
-echo input_get(INPUT_POST, 'foo', FILTER_SANITIZE_STRIPPED);
+echo filter_input(INPUT_POST, 'foo', FILTER_SANITIZE_STRIPPED);
?>
--EXPECT--
abc
--TEST--
-input_filters_list()
+filter_list()
--FILE--
<?php
-var_dump(input_filters_list());
-var_dump(input_filters_list(array()));
+var_dump(filter_list());
+var_dump(filter_list(array()));
echo "Done\n";
?>
[17]=>
string(8) "callback"
}
-array(18) {
- [0]=>
- string(3) "int"
- [1]=>
- string(7) "boolean"
- [2]=>
- string(5) "float"
- [3]=>
- string(15) "validate_regexp"
- [4]=>
- string(12) "validate_url"
- [5]=>
- string(14) "validate_email"
- [6]=>
- string(11) "validate_ip"
- [7]=>
- string(6) "string"
- [8]=>
- string(8) "stripped"
- [9]=>
- string(7) "encoded"
- [10]=>
- string(13) "special_chars"
- [11]=>
- string(10) "unsafe_raw"
- [12]=>
- string(5) "email"
- [13]=>
- string(3) "url"
- [14]=>
- string(10) "number_int"
- [15]=>
- string(12) "number_float"
- [16]=>
- string(12) "magic_quotes"
- [17]=>
- string(8) "callback"
-}
+
+Warning: Wrong parameter count for filter_list() in /home4/php_dev/php52/ext/filter/tests/008.php on line 4
+NULL
Done
--TEST--
-input_name_to_filter()
+filter_id()
--FILE--
<?php
-var_dump(input_name_to_filter("stripped"));
-var_dump(input_name_to_filter("string"));
-var_dump(input_name_to_filter("url"));
-var_dump(input_name_to_filter("int"));
-var_dump(input_name_to_filter("none"));
-var_dump(input_name_to_filter(array()));
-var_dump(input_name_to_filter(-1));
-var_dump(input_name_to_filter(0,0,0));
+var_dump(filter_id("stripped"));
+var_dump(filter_id("string"));
+var_dump(filter_id("url"));
+var_dump(filter_id("int"));
+var_dump(filter_id("none"));
+var_dump(filter_id(array()));
+var_dump(filter_id(-1));
+var_dump(filter_id(0,0,0));
echo "Done\n";
?>
int(513)
int(518)
int(257)
-NULL
+bool(false)
-Warning: input_name_to_filter() expects parameter 1 to be string, array given in %s on line %d
-NULL
+Warning: filter_id() expects parameter 1 to be string, array given in %s on line %d
NULL
+bool(false)
-Warning: input_name_to_filter() expects exactly 1 parameter, 3 given in %s on line %d
+Warning: filter_id() expects exactly 1 parameter, 3 given in %s on line %d
NULL
Done
--TEST--
-filter_data()
+filter_var()
--FILE--
<?php
-var_dump(filter_data(array(1,"1","", "-23234", "text", "asdf234asdfgs", array()), FILTER_VALIDATE_INT));
-var_dump(filter_data(array(1.2,"1.7","", "-23234.123", "text", "asdf234.2asdfgs", array()), FILTER_VALIDATE_FLOAT));
-var_dump(filter_data(1, array()));
-var_dump(filter_data(1, FILTER_SANITIZE_STRING, 1));
-var_dump(filter_data(1, FILTER_SANITIZE_STRING, 0));
-var_dump(filter_data(1, FILTER_SANITIZE_STRING, array()));
-var_dump(filter_data(1, -1, array(123)));
-var_dump(filter_data(1, 0, array()));
+var_dump(filter_var(array(1,"1","", "-23234", "text", "asdf234asdfgs", array()), FILTER_VALIDATE_INT, FILTER_REQUIRE_ARRAY));
+var_dump(filter_var(array(1.2,"1.7","", "-23234.123", "text", "asdf234.2asdfgs", array()), FILTER_VALIDATE_FLOAT, FILTER_REQUIRE_ARRAY));
+var_dump(filter_var(1, array()));
+var_dump(filter_var(1, FILTER_SANITIZE_STRING, 1));
+var_dump(filter_var(1, FILTER_SANITIZE_STRING, 0));
+var_dump(filter_var(1, FILTER_SANITIZE_STRING, array()));
+var_dump(filter_var(1, -1, array(123)));
+var_dump(filter_var(1, 0, array()));
echo "Done\n";
?>
}
}
-Warning: filter_data() expects parameter 2 to be long, array given in %s on line %d
-NULL
+Warning: filter_var() expects parameter 2 to be long, array given in %s on line %d
+bool(false)
string(1) "1"
string(1) "1"
string(1) "1"
--TEST--
-input_get()
+filter_input()
--FILE--
<?php
-var_dump(input_get(INPUT_GET, "test"));
-var_dump(input_get(INPUT_POST, "test"));
-var_dump(input_get(INPUT_COOKIE, ""));
+var_dump(filter_input(INPUT_GET, "test"));
+var_dump(filter_input(INPUT_POST, "test"));
+var_dump(filter_input(INPUT_COOKIE, ""));
echo "Done\n";
?>
--TEST--
-filter_data() and flags
+filter_var() and flags
--FILE--
<?php
-var_dump(filter_data(" 234", FILTER_VALIDATE_INT));
-var_dump(filter_data("234 ", FILTER_VALIDATE_INT));
-var_dump(filter_data(" 234 ", FILTER_VALIDATE_INT));
-var_dump(filter_data("0xff", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
-var_dump(filter_data("0Xff", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
-var_dump(filter_data("0xFF", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
-var_dump(filter_data("0XFF", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
-var_dump(filter_data("07", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
-var_dump(filter_data("0xff0000", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
-var_dump(filter_data("0666", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
-var_dump(filter_data("08", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
-var_dump(filter_data("00", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
-var_dump(filter_data("000", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
+var_dump(filter_var(" 234", FILTER_VALIDATE_INT));
+var_dump(filter_var("234 ", FILTER_VALIDATE_INT));
+var_dump(filter_var(" 234 ", FILTER_VALIDATE_INT));
+var_dump(filter_var("0xff", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
+var_dump(filter_var("0Xff", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
+var_dump(filter_var("0xFF", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
+var_dump(filter_var("0XFF", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
+var_dump(filter_var("07", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
+var_dump(filter_var("0xff0000", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
+var_dump(filter_var("0666", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
+var_dump(filter_var("08", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
+var_dump(filter_var("00", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
+var_dump(filter_var("000", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
-var_dump(filter_data("-0xff", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
-var_dump(filter_data("-0Xff", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
-var_dump(filter_data("-0xFF", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
-var_dump(filter_data("-0XFF", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
-var_dump(filter_data("-07", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
-var_dump(filter_data("-0xff0000", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
-var_dump(filter_data("-0666", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
+var_dump(filter_var("-0xff", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
+var_dump(filter_var("-0Xff", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
+var_dump(filter_var("-0xFF", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
+var_dump(filter_var("-0XFF", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
+var_dump(filter_var("-07", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
+var_dump(filter_var("-0xff0000", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_HEX)));
+var_dump(filter_var("-0666", FILTER_VALIDATE_INT, array("flags"=>FILTER_FLAG_ALLOW_OCTAL)));
-var_dump(filter_data("6", FILTER_VALIDATE_INT, array("min_range"=>1, "max_range"=>7)));
-var_dump(filter_data("6", FILTER_VALIDATE_INT, array("min_range"=>0, "max_range"=>5)));
-var_dump(filter_data(-1, FILTER_VALIDATE_INT, array("min_range"=>1, "max_range"=>7)));
-var_dump(filter_data(-1, FILTER_VALIDATE_INT, array("min_range"=>-4, "max_range"=>7)));
+var_dump(filter_var("6", FILTER_VALIDATE_INT, array("options" => array("min_range"=>1, "max_range"=>7))));
+var_dump(filter_var("6", FILTER_VALIDATE_INT, array("options" => array("min_range"=>0, "max_range"=>5))));
+var_dump(filter_var(-1, FILTER_VALIDATE_INT, array("options" => array("min_range"=>1, "max_range"=>7))));
+var_dump(filter_var(-1, FILTER_VALIDATE_INT, array("options" => array("min_range"=>-4, "max_range"=>7))));
-var_dump(filter_data("", FILTER_VALIDATE_INT, array("min_range"=>-4, "max_range"=>7)));
-var_dump(filter_data("", FILTER_VALIDATE_INT, array("min_range"=>2, "max_range"=>7)));
-var_dump(filter_data("", FILTER_VALIDATE_INT, array("min_range"=>-5, "max_range"=>-3)));
-var_dump(filter_data(345, FILTER_VALIDATE_INT, array("min_range"=>500, "max_range"=>100)));
-var_dump(filter_data("0ff", FILTER_VALIDATE_INT));
-var_dump(filter_data("010", FILTER_VALIDATE_INT));
+var_dump(filter_var("", FILTER_VALIDATE_INT, array("options" => array("min_range"=>-4, "max_range"=>7))));
+var_dump(filter_var("", FILTER_VALIDATE_INT, array("options" => array("min_range"=>2, "max_range"=>7))));
+var_dump(filter_var("", FILTER_VALIDATE_INT, array("options" => array("min_range"=>-5, "max_range"=>-3))));
+var_dump(filter_var(345, FILTER_VALIDATE_INT, array("options" => array("min_range"=>500, "max_range"=>100))));
+var_dump(filter_var("0ff", FILTER_VALIDATE_INT));
+var_dump(filter_var("010", FILTER_VALIDATE_INT));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_VALIDATE_BOOLEAN
+filter_var() and FILTER_VALIDATE_BOOLEAN
--FILE--
<?php
$t = new test;
-var_dump(filter_data("no", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data(NULL, FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data($t, FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data(array(1,2,3,0,array("", "123")), FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("yes", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("true", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("false", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("off", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("on", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("0", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("1", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("NONE", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data(-1, FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("000000", FILTER_VALIDATE_BOOLEAN));
-var_dump(filter_data("111111", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("no", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var(NULL, FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var($t, FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var(array(1,2,3,0,array("", "123")), FILTER_VALIDATE_BOOLEAN, FILTER_REQUIRE_ARRAY));
+var_dump(filter_var("yes", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("true", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("false", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("off", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("on", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("0", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("1", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("NONE", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var(-1, FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("000000", FILTER_VALIDATE_BOOLEAN));
+var_dump(filter_var("111111", FILTER_VALIDATE_BOOLEAN));
echo "Done\n";
--TEST--
-filter_data() and FILTER_VALIDATE_URL
+filter_var() and FILTER_VALIDATE_URL
--FILE--
<?php
array(),
);
foreach ($values as $value) {
- var_dump(filter_data($value, FILTER_VALIDATE_URL));
+ var_dump(filter_var($value, FILTER_VALIDATE_URL));
}
-var_dump(filter_data("qwe", FILTER_VALIDATE_URL, FILTER_FLAG_SCHEME_REQUIRED));
-var_dump(filter_data("http://qwe", FILTER_VALIDATE_URL, FILTER_FLAG_SCHEME_REQUIRED));
-var_dump(filter_data("http://", FILTER_VALIDATE_URL, FILTER_FLAG_HOST_REQUIRED));
-var_dump(filter_data("/tmp/test", FILTER_VALIDATE_URL, FILTER_FLAG_HOST_REQUIRED));
-var_dump(filter_data("http://www.example.com", FILTER_VALIDATE_URL, FILTER_FLAG_HOST_REQUIRED));
-var_dump(filter_data("http://www.example.com", FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED));
-var_dump(filter_data("http://www.example.com/path/at/the/server/", FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED));
-var_dump(filter_data("http://www.example.com/index.html", FILTER_VALIDATE_URL, FILTER_FLAG_QUERY_REQUIRED));
-var_dump(filter_data("http://www.example.com/index.php?a=b&c=d", FILTER_VALIDATE_URL, FILTER_FLAG_QUERY_REQUIRED));
+var_dump(filter_var("qwe", FILTER_VALIDATE_URL, FILTER_FLAG_SCHEME_REQUIRED));
+var_dump(filter_var("http://qwe", FILTER_VALIDATE_URL, FILTER_FLAG_SCHEME_REQUIRED));
+var_dump(filter_var("http://", FILTER_VALIDATE_URL, FILTER_FLAG_HOST_REQUIRED));
+var_dump(filter_var("/tmp/test", FILTER_VALIDATE_URL, FILTER_FLAG_HOST_REQUIRED));
+var_dump(filter_var("http://www.example.com", FILTER_VALIDATE_URL, FILTER_FLAG_HOST_REQUIRED));
+var_dump(filter_var("http://www.example.com", FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED));
+var_dump(filter_var("http://www.example.com/path/at/the/server/", FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED));
+var_dump(filter_var("http://www.example.com/index.html", FILTER_VALIDATE_URL, FILTER_FLAG_QUERY_REQUIRED));
+var_dump(filter_var("http://www.example.com/index.php?a=b&c=d", FILTER_VALIDATE_URL, FILTER_FLAG_QUERY_REQUIRED));
echo "Done\n";
?>
string(4) "http"
string(0) ""
string(2) "-1"
-array(0) {
-}
+bool(false)
bool(false)
string(10) "http://qwe"
bool(false)
--TEST--
-filter_data() and FILTER_VALIDATE_EMAIL
+filter_var() and FILTER_VALIDATE_EMAIL
--FILE--
<?php
$values = Array(
'QWERTYUIOPASDFGHJKLZXCVBNM@QWERTYUIOPASDFGHJKLZXCVBNM.NET',
);
foreach ($values as $value) {
- var_dump(filter_data($value, FILTER_VALIDATE_EMAIL));
+ var_dump(filter_var($value, FILTER_VALIDATE_EMAIL));
}
echo "Done\n";
--TEST--
-filter_data() and FILTER_VALIDATE_REGEXP
+filter_var() and FILTER_VALIDATE_REGEXP
--FILE--
<?php
-var_dump(filter_data("data", FILTER_VALIDATE_REGEXP, array("regexp"=>'/.*/')));
-var_dump(filter_data("data", FILTER_VALIDATE_REGEXP, array("regexp"=>'/^b(.*)/')));
-var_dump(filter_data("data", FILTER_VALIDATE_REGEXP, array("regexp"=>'/^d(.*)/')));
-var_dump(filter_data("data", FILTER_VALIDATE_REGEXP, array("regexp"=>'/blah/')));
-var_dump(filter_data("data", FILTER_VALIDATE_REGEXP, array("regexp"=>'/\[/')));
-var_dump(filter_data("data", FILTER_VALIDATE_REGEXP));
+var_dump(filter_var("data", FILTER_VALIDATE_REGEXP, array("options"=>array("regexp"=>'/.*/'))));
+var_dump(filter_var("data", FILTER_VALIDATE_REGEXP, array("options"=>array("regexp"=>'/^b(.*)/'))));
+var_dump(filter_var("data", FILTER_VALIDATE_REGEXP, array("options"=>array("regexp"=>'/^d(.*)/'))));
+var_dump(filter_var("data", FILTER_VALIDATE_REGEXP, array("options"=>array("regexp"=>'/blah/'))));
+var_dump(filter_var("data", FILTER_VALIDATE_REGEXP, array("options"=>array("regexp"=>'/\[/'))));
+var_dump(filter_var("data", FILTER_VALIDATE_REGEXP));
echo "Done\n";
?>
bool(false)
bool(false)
-Warning: filter_data(): 'regexp' option missing in %s on line %d
+Warning: filter_var(): 'regexp' option missing in %s on line %d
bool(false)
Done
--TEST--
-filter_data() and FILTER_VALIDATE_IP
+filter_var() and FILTER_VALIDATE_IP
--FILE--
<?php
-var_dump(filter_data("192.168.0.1", FILTER_VALIDATE_IP));
-var_dump(filter_data("192.168.0.1.1", FILTER_VALIDATE_IP));
-var_dump(filter_data("::1", FILTER_VALIDATE_IP));
-var_dump(filter_data("fe00::0", FILTER_VALIDATE_IP));
-var_dump(filter_data("::123456", FILTER_VALIDATE_IP));
-var_dump(filter_data("::1::b", FILTER_VALIDATE_IP));
-var_dump(filter_data("127.0.0.1", FILTER_VALIDATE_IP));
-var_dump(filter_data("192.168.0.1", FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE));
-var_dump(filter_data("192.0.34.166", FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE));
-var_dump(filter_data("127.0.0.1", FILTER_VALIDATE_IP, FILTER_FLAG_NO_RES_RANGE));
-var_dump(filter_data("192.0.0.1", FILTER_VALIDATE_IP, FILTER_FLAG_NO_RES_RANGE));
-var_dump(filter_data("192.0.34.166", FILTER_VALIDATE_IP));
-var_dump(filter_data("256.1237.123.1", FILTER_VALIDATE_IP));
-var_dump(filter_data("255.255.255.255", FILTER_VALIDATE_IP));
-var_dump(filter_data("255.255.255.255", FILTER_VALIDATE_IP, FILTER_FLAG_NO_RES_RANGE));
-var_dump(filter_data("", FILTER_VALIDATE_IP));
-var_dump(filter_data(-1, FILTER_VALIDATE_IP));
-var_dump(filter_data("::1", FILTER_VALIDATE_IP, FILTER_FLAG_IPV4));
-var_dump(filter_data("127.0.0.1", FILTER_VALIDATE_IP, FILTER_FLAG_IPV6));
-var_dump(filter_data("::1", FILTER_VALIDATE_IP, FILTER_FLAG_IPV6));
-var_dump(filter_data("127.0.0.1", FILTER_VALIDATE_IP, FILTER_FLAG_IPV4));
+var_dump(filter_var("192.168.0.1", FILTER_VALIDATE_IP));
+var_dump(filter_var("192.168.0.1.1", FILTER_VALIDATE_IP));
+var_dump(filter_var("::1", FILTER_VALIDATE_IP));
+var_dump(filter_var("fe00::0", FILTER_VALIDATE_IP));
+var_dump(filter_var("::123456", FILTER_VALIDATE_IP));
+var_dump(filter_var("::1::b", FILTER_VALIDATE_IP));
+var_dump(filter_var("127.0.0.1", FILTER_VALIDATE_IP));
+var_dump(filter_var("192.168.0.1", FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE));
+var_dump(filter_var("192.0.34.166", FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE));
+var_dump(filter_var("127.0.0.1", FILTER_VALIDATE_IP, FILTER_FLAG_NO_RES_RANGE));
+var_dump(filter_var("192.0.0.1", FILTER_VALIDATE_IP, FILTER_FLAG_NO_RES_RANGE));
+var_dump(filter_var("192.0.34.166", FILTER_VALIDATE_IP));
+var_dump(filter_var("256.1237.123.1", FILTER_VALIDATE_IP));
+var_dump(filter_var("255.255.255.255", FILTER_VALIDATE_IP));
+var_dump(filter_var("255.255.255.255", FILTER_VALIDATE_IP, FILTER_FLAG_NO_RES_RANGE));
+var_dump(filter_var("", FILTER_VALIDATE_IP));
+var_dump(filter_var(-1, FILTER_VALIDATE_IP));
+var_dump(filter_var("::1", FILTER_VALIDATE_IP, FILTER_FLAG_IPV4));
+var_dump(filter_var("127.0.0.1", FILTER_VALIDATE_IP, FILTER_FLAG_IPV6));
+var_dump(filter_var("::1", FILTER_VALIDATE_IP, FILTER_FLAG_IPV6));
+var_dump(filter_var("127.0.0.1", FILTER_VALIDATE_IP, FILTER_FLAG_IPV4));
echo "Done\n";
?>
--EXPECT--
--TEST--
-filter_data() & FILTER_VALIDATE_IP and weird data
+filter_var() & FILTER_VALIDATE_IP and weird data
--FILE--
<?php
-var_dump(filter_data("....", FILTER_VALIDATE_IP));
-var_dump(filter_data("...", FILTER_VALIDATE_IP));
-var_dump(filter_data("..", FILTER_VALIDATE_IP));
-var_dump(filter_data(".", FILTER_VALIDATE_IP));
-var_dump(filter_data("1.1.1.1", FILTER_VALIDATE_IP));
+var_dump(filter_var("....", FILTER_VALIDATE_IP));
+var_dump(filter_var("...", FILTER_VALIDATE_IP));
+var_dump(filter_var("..", FILTER_VALIDATE_IP));
+var_dump(filter_var(".", FILTER_VALIDATE_IP));
+var_dump(filter_var("1.1.1.1", FILTER_VALIDATE_IP));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_SANITIZE_MAGIC_QUOTES
+filter_var() and FILTER_SANITIZE_MAGIC_QUOTES
--FILE--
<?php
-var_dump(filter_data("test'asd'asd'' asd\'\"asdfasdf", FILTER_SANITIZE_MAGIC_QUOTES));
-var_dump(filter_data("'", FILTER_SANITIZE_MAGIC_QUOTES));
-var_dump(filter_data("", FILTER_SANITIZE_MAGIC_QUOTES));
-var_dump(filter_data(-1, FILTER_SANITIZE_MAGIC_QUOTES));
+var_dump(filter_var("test'asd'asd'' asd\'\"asdfasdf", FILTER_SANITIZE_MAGIC_QUOTES));
+var_dump(filter_var("'", FILTER_SANITIZE_MAGIC_QUOTES));
+var_dump(filter_var("", FILTER_SANITIZE_MAGIC_QUOTES));
+var_dump(filter_var(-1, FILTER_SANITIZE_MAGIC_QUOTES));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_SANITIZE_NUMBER_*
+filter_var() and FILTER_SANITIZE_NUMBER_*
--FILE--
<?php
-var_dump(filter_data("qwertyu123456dfghj", FILTER_SANITIZE_NUMBER_INT));
-var_dump(filter_data("asd123123.asd123.23", FILTER_SANITIZE_NUMBER_INT));
-var_dump(filter_data("123,23", FILTER_SANITIZE_NUMBER_INT));
-var_dump(filter_data("", FILTER_SANITIZE_NUMBER_INT));
-var_dump(filter_data("0", FILTER_SANITIZE_NUMBER_INT));
-var_dump(filter_data("asd123.2asd", FILTER_SANITIZE_NUMBER_INT));
-var_dump(filter_data("qwertyuiop", FILTER_SANITIZE_NUMBER_INT));
-var_dump(filter_data("123.4", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
-var_dump(filter_data("123,4", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
-var_dump(filter_data("123.4", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_THOUSAND));
-var_dump(filter_data("123,4", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_THOUSAND));
-var_dump(filter_data("123.4e", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_SCIENTIFIC));
-var_dump(filter_data("123,4E", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_SCIENTIFIC));
-var_dump(filter_data("qwe123,4qwe", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
-var_dump(filter_data("werty65456.34", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
-var_dump(filter_data("234.56fsfd", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
-var_dump(filter_data("", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
+var_dump(filter_var("qwertyu123456dfghj", FILTER_SANITIZE_NUMBER_INT));
+var_dump(filter_var("asd123123.asd123.23", FILTER_SANITIZE_NUMBER_INT));
+var_dump(filter_var("123,23", FILTER_SANITIZE_NUMBER_INT));
+var_dump(filter_var("", FILTER_SANITIZE_NUMBER_INT));
+var_dump(filter_var("0", FILTER_SANITIZE_NUMBER_INT));
+var_dump(filter_var("asd123.2asd", FILTER_SANITIZE_NUMBER_INT));
+var_dump(filter_var("qwertyuiop", FILTER_SANITIZE_NUMBER_INT));
+var_dump(filter_var("123.4", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
+var_dump(filter_var("123,4", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
+var_dump(filter_var("123.4", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_THOUSAND));
+var_dump(filter_var("123,4", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_THOUSAND));
+var_dump(filter_var("123.4e", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_SCIENTIFIC));
+var_dump(filter_var("123,4E", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_SCIENTIFIC));
+var_dump(filter_var("qwe123,4qwe", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
+var_dump(filter_var("werty65456.34", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
+var_dump(filter_var("234.56fsfd", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
+var_dump(filter_var("", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_SANITIZE_EMAIL
+filter_var() and FILTER_SANITIZE_EMAIL
--FILE--
<?php
-var_dump(filter_data("a@b.c", FILTER_SANITIZE_EMAIL));
-var_dump(filter_data("a[!@#$%^&*()@a@#$%^&*(.com@#$%^&*(", FILTER_SANITIZE_EMAIL));
-var_dump(filter_data("white space here \ \ \" som more", FILTER_SANITIZE_EMAIL));
-var_dump(filter_data("", FILTER_SANITIZE_EMAIL));
-var_dump(filter_data("123456789000000", FILTER_SANITIZE_EMAIL));
+var_dump(filter_var("a@b.c", FILTER_SANITIZE_EMAIL));
+var_dump(filter_var("a[!@#$%^&*()@a@#$%^&*(.com@#$%^&*(", FILTER_SANITIZE_EMAIL));
+var_dump(filter_var("white space here \ \ \" som more", FILTER_SANITIZE_EMAIL));
+var_dump(filter_var("", FILTER_SANITIZE_EMAIL));
+var_dump(filter_var("123456789000000", FILTER_SANITIZE_EMAIL));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_UNSAFE_RAW
+filter_var() and FILTER_UNSAFE_RAW
--FILE--
<?php
-var_dump(filter_
data("}\"<p>test para</p>", FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP));
-var_dump(filter_data("a[!@#<b>$%^&*()@a@#$%^&*(.<br>com@#$%^&*(", FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP));
-var_dump(filter_data("white space here \ \ \" some more", FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP));
-var_dump(filter_data("", FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP));
-var_dump(filter_data(" 123456789000000 <qwertyuiop> ", FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP));
+var_dump(filter_
var("}\"<p>test para</p>", FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP));
+var_dump(filter_var("a[!@#<b>$%^&*()@a@#$%^&*(.<br>com@#$%^&*(", FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP));
+var_dump(filter_var("white space here \ \ \" some more", FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP));
+var_dump(filter_var("", FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP));
+var_dump(filter_var(" 123456789000000 <qwertyuiop> ", FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_SANITIZE_ENCODED
+filter_var() and FILTER_SANITIZE_ENCODED
--FILE--
<?php
-var_dump(filter_data("\"<br>blah</ph>", FILTER_SANITIZE_ENCODED));
-var_dump(filter_data("", FILTER_SANITIZE_ENCODED));
-var_dump(filter_data(" text here ", FILTER_SANITIZE_ENCODED));
-var_dump(filter_data("!@#$%^&*()QWERTYUIOP{ASDFGHJKL:\"ZXCVBNM<>?", FILTER_SANITIZE_ENCODED));
+var_dump(filter_var("\"<br>blah</ph>", FILTER_SANITIZE_ENCODED));
+var_dump(filter_var("", FILTER_SANITIZE_ENCODED));
+var_dump(filter_var(" text here ", FILTER_SANITIZE_ENCODED));
+var_dump(filter_var("!@#$%^&*()QWERTYUIOP{ASDFGHJKL:\"ZXCVBNM<>?", FILTER_SANITIZE_ENCODED));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_SANITIZE_STRING
+filter_var() and FILTER_SANITIZE_STRING
--FILE--
<?php
-var_dump(filter_data("", FILTER_SANITIZE_STRING));
-var_dump(filter_data("<>", FILTER_SANITIZE_STRING));
-var_dump(filter_data("<>!@#$%^&*()'\"", FILTER_SANITIZE_STRING, FILTER_FLAG_NO_ENCODE_QUOTES));
-var_dump(filter_data("<>!@#$%^&*()'\"", FILTER_SANITIZE_STRING, FILTER_FLAG_ENCODE_AMP));
-var_dump(filter_data("<>`1234567890", FILTER_SANITIZE_STRING));
-var_dump(filter_data("`123`", FILTER_SANITIZE_STRING));
-var_dump(filter_data(".", FILTER_SANITIZE_STRING));
+var_dump(filter_var("", FILTER_SANITIZE_STRING));
+var_dump(filter_var("<>", FILTER_SANITIZE_STRING));
+var_dump(filter_var("<>!@#$%^&*()'\"", FILTER_SANITIZE_STRING, FILTER_FLAG_NO_ENCODE_QUOTES));
+var_dump(filter_var("<>!@#$%^&*()'\"", FILTER_SANITIZE_STRING, FILTER_FLAG_ENCODE_AMP));
+var_dump(filter_var("<>`1234567890", FILTER_SANITIZE_STRING));
+var_dump(filter_var("`123`", FILTER_SANITIZE_STRING));
+var_dump(filter_var(".", FILTER_SANITIZE_STRING));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_SANITIZE_STRIPPED
+filter_var() and FILTER_SANITIZE_STRIPPED
--FILE--
<?php
-var_dump(filter_
data("<p>Let me <font color=\"#000000\">see</font> you <br /><b>Stripped</b> down to the bone</p>", FILTER_SANITIZE_STRIPPED));
-var_dump(filter_
data("!@#$%^&*()><<>+_\"'<br><p /><li />", FILTER_SANITIZE_STRIPPED));
-var_dump(filter_data("", FILTER_SANITIZE_STRIPPED));
+var_dump(filter_
var("<p>Let me <font color=\"#000000\">see</font> you <br /><b>Stripped</b> down to the bone</p>", FILTER_SANITIZE_STRIPPED));
+var_dump(filter_
var("!@#$%^&*()><<>+_\"'<br><p /><li />", FILTER_SANITIZE_STRIPPED));
+var_dump(filter_var("", FILTER_SANITIZE_STRIPPED));
-var_dump(filter_
data("<p>Let me <font color=\"#000000\">see</font> you <br /><b>Stripped</b> down to the bone</p>", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_LOW));
-var_dump(filter_
data("!@#$%^&*()><<>+_\"'<br><p /><li />", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_LOW));
-var_dump(filter_data("", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_LOW));
+var_dump(filter_
var("<p>Let me <font color=\"#000000\">see</font> you <br /><b>Stripped</b> down to the bone</p>", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_LOW));
+var_dump(filter_
var("!@#$%^&*()><<>+_\"'<br><p /><li />", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_LOW));
+var_dump(filter_var("", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_LOW));
-var_dump(filter_
data("<p>Let me <font color=\"#000000\">see</font> you <br /><b>Stripped</b> down to the bone</p>", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_HIGH));
-var_dump(filter_
data("!@#$%^&*()><<>+_\"'<br><p /><li />", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_HIGH));
-var_dump(filter_data("", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_HIGH));
+var_dump(filter_
var("<p>Let me <font color=\"#000000\">see</font> you <br /><b>Stripped</b> down to the bone</p>", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_HIGH));
+var_dump(filter_
var("!@#$%^&*()><<>+_\"'<br><p /><li />", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_HIGH));
+var_dump(filter_var("", FILTER_SANITIZE_STRIPPED, FILTER_FLAG_STRIP_HIGH));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_SANITIZE_ENCODED
+filter_var() and FILTER_SANITIZE_ENCODED
--FILE--
<?php
-var_dump(filter_data("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_ENCODED));
-var_dump(filter_data("<data&sons>", FILTER_SANITIZE_ENCODED));
-var_dump(filter_data("", FILTER_SANITIZE_ENCODED));
+var_dump(filter_var("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_ENCODED));
+var_dump(filter_var("<data&sons>", FILTER_SANITIZE_ENCODED));
+var_dump(filter_var("", FILTER_SANITIZE_ENCODED));
-var_dump(filter_data("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_LOW));
-var_dump(filter_data("<data&sons>", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_LOW));
-var_dump(filter_data("", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_LOW));
+var_dump(filter_var("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_LOW));
+var_dump(filter_var("<data&sons>", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_LOW));
+var_dump(filter_var("", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_LOW));
-var_dump(filter_data("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_HIGH));
-var_dump(filter_data("<data&sons>", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_HIGH));
-var_dump(filter_data("", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_HIGH));
+var_dump(filter_var("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_HIGH));
+var_dump(filter_var("<data&sons>", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_HIGH));
+var_dump(filter_var("", FILTER_SANITIZE_ENCODED, FILTER_FLAG_ENCODE_HIGH));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_SANITIZE_SPECIAL_CHARS
+filter_var() and FILTER_SANITIZE_SPECIAL_CHARS
--FILE--
<?php
-var_dump(filter_data("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_SPECIAL_CHARS));
-var_dump(filter_data("<data&sons>", FILTER_SANITIZE_SPECIAL_CHARS));
-var_dump(filter_data("", FILTER_SANITIZE_SPECIAL_CHARS));
+var_dump(filter_var("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_SPECIAL_CHARS));
+var_dump(filter_var("<data&sons>", FILTER_SANITIZE_SPECIAL_CHARS));
+var_dump(filter_var("", FILTER_SANITIZE_SPECIAL_CHARS));
-var_dump(filter_data("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_LOW));
-var_dump(filter_data("<data&sons>", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_LOW));
-var_dump(filter_data("", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_LOW));
+var_dump(filter_var("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_LOW));
+var_dump(filter_var("<data&sons>", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_LOW));
+var_dump(filter_var("", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_LOW));
-var_dump(filter_data("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_HIGH));
-var_dump(filter_data("<data&sons>", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_HIGH));
-var_dump(filter_data("", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_HIGH));
+var_dump(filter_var("?><!@#$%^&*()}{~Qwertyuilfdsasdfgmnbvcxcvbn", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_HIGH));
+var_dump(filter_var("<data&sons>", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_HIGH));
+var_dump(filter_var("", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_HIGH));
-var_dump(filter_data("кириллица", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_HIGH));
-var_dump(filter_data("кириллица", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_LOW));
+var_dump(filter_var("кириллица", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_HIGH));
+var_dump(filter_var("кириллица", FILTER_SANITIZE_SPECIAL_CHARS, FILTER_FLAG_ENCODE_LOW));
echo "Done\n";
?>
--TEST--
-filter_data() and FILTER_CALLBACK
+filter_var() and FILTER_CALLBACK
--FILE--
<?php
return strtoupper($var);
}
-var_dump(filter_data("data", FILTER_CALLBACK, "test"));
-var_dump(filter_data("~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?\"}{:", FILTER_CALLBACK, "test"));
-var_dump(filter_data("", FILTER_CALLBACK, "test"));
-var_dump(filter_data("qwe", FILTER_CALLBACK, "no such func"));
-var_dump(filter_data("qwe", FILTER_CALLBACK, ""));
-var_dump(filter_data("qwe", FILTER_CALLBACK));
+var_dump(filter_var("data", FILTER_CALLBACK, array("options"=>"test")));
+var_dump(filter_var("~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?\"}{:", FILTER_CALLBACK, array("options"=>"test")));
+var_dump(filter_var("", FILTER_CALLBACK, array("options"=>"test")));
+var_dump(filter_var("qwe", FILTER_CALLBACK, array("options"=>"no such func")));
+var_dump(filter_var("qwe", FILTER_CALLBACK, array("options"=>"")));
+var_dump(filter_var("qwe", FILTER_CALLBACK));
/* Simple class method callback */
class test_class {
}
}
-var_dump(filter_data("dAtA", FILTER_CALLBACK, array("test_class", "test")));
-var_dump(filter_data("~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?\"}{:", FILTER_CALLBACK, array("test_class","test")));
-var_dump(filter_data("", FILTER_CALLBACK, array("test_class","test")));
+var_dump(filter_var("dAtA", FILTER_CALLBACK, array("options"=>array("test_class", "test"))));
+var_dump(filter_var("~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?\"}{:", FILTER_CALLBACK, array("options"=>array("test_class","test"))));
+var_dump(filter_var("", FILTER_CALLBACK, array("options"=>array("test_class","test"))));
/* empty function without return value */
function test1($var) {
}
-var_dump(filter_data("data", FILTER_CALLBACK, "test1"));
-var_dump(filter_data("~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?\"}{:", FILTER_CALLBACK, "test1"));
-var_dump(filter_data("", FILTER_CALLBACK, "test1"));
+var_dump(filter_var("data", FILTER_CALLBACK, array("options"=>"test1")));
+var_dump(filter_var("~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?\"}{:", FILTER_CALLBACK, array("options"=>"test1")));
+var_dump(filter_var("", FILTER_CALLBACK, array("options"=>"test1")));
/* attempting to change data by reference */
function test2(&$var) {
$var = 1;
}
-var_dump(filter_data("data", FILTER_CALLBACK, "test2"));
-var_dump(filter_data("~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?\"}{:", FILTER_CALLBACK, "test2"));
-var_dump(filter_data("", FILTER_CALLBACK, "test2"));
+var_dump(filter_var("data", FILTER_CALLBACK, array("options"=>"test2")));
+var_dump(filter_var("~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?\"}{:", FILTER_CALLBACK, array("options"=>"test2")));
+var_dump(filter_var("", FILTER_CALLBACK, array("options"=>"test2")));
/* unsetting data */
function test3(&$var) {
unset($var);
}
-var_dump(filter_data("data", FILTER_CALLBACK, "test3"));
-var_dump(filter_data("~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?\"}{:", FILTER_CALLBACK, "test3"));
-var_dump(filter_data("", FILTER_CALLBACK, "test3"));
+var_dump(filter_var("data", FILTER_CALLBACK, array("options"=>"test3")));
+var_dump(filter_var("~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?\"}{:", FILTER_CALLBACK, array("options"=>"test3")));
+var_dump(filter_var("", FILTER_CALLBACK, array("options"=>"test3")));
/* unset data and return value */
function test4(&$var) {
return 1;
}
-var_dump(filter_data("data", FILTER_CALLBACK, "test4"));
+var_dump(filter_var("data", FILTER_CALLBACK, array("options"=>"test4")));
/* thrown exception in the callback */
function test5(&$var) {
}
try {
- var_dump(filter_data("data", FILTER_CALLBACK, "test5"));
+ var_dump(filter_var("data", FILTER_CALLBACK, array("options"=>"test5")));
} catch (Exception $e) {
var_dump($e->getMessage());
}
string(46) "~!@#$%^&*()_QWERTYUIOPASDFGHJKLZXCVBNM<>>?"}{:"
string(0) ""
-Warning: filter_data(): First argument is expected to be a valid callback in %s on line %d
+Warning: filter_var(): First argument is expected to be a valid callback in %s on line %d
NULL
-Warning: filter_data(): First argument is expected to be a valid callback in %s on line %d
+Warning: filter_var(): First argument is expected to be a valid callback in %s on line %d
NULL
-Warning: filter_data(): First argument is expected to be a valid callback in %s on line %d
+Warning: filter_var(): First argument is expected to be a valid callback in %s on line %d
NULL
string(4) "data"
string(46) "~!@#$%^&*()_qwertyuiopasdfghjklzxcvbnm<>>?"}{:"
--TEST--
-filter_data() and IPv6
+filter_var() and IPv6
--FILE--
<?php
$ipv6_test = array(
"::FFFF:129.144.52.38" => true
);
foreach ($ipv6_test as $ip => $exp) {
- $out = filter_data($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6);
+ $out = filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6);
$out = (int) ($out === false ? 0 : 1);
if ($exp != $out) {
echo "$ip failed\n";
--TEST--
-filter_data() and FLOAT
+filter_var() and FLOAT
--FILE--
<?php
);
foreach ($floats as $float) {
- $out = filter_data($float, FILTER_VALIDATE_FLOAT);
+ $out = filter_var($float, FILTER_VALIDATE_FLOAT);
var_dump($out);
}
echo "\ncustom decimal:\n";
foreach ($floats as $float => $dec) {
- $out = filter_data($float, FILTER_VALIDATE_FLOAT, array('decimal' => $dec));
+ $out = filter_var($float, FILTER_VALIDATE_FLOAT, array("options"=>array('decimal' => $dec)));
var_dump($out);
}
float(1.234)
float(1.234)
-Warning: filter_data(): decimal separator must be one char in %s on line %d
+Warning: filter_var(): decimal separator must be one char in %s on line %d
bool(false)
bool(false)
$args = array(
'product_id' => FILTER_SANITIZE_ENCODED,
'component' => array(//'filter' => FILTER_VALIDATE_INT,
- 'flags' => FILTER_FLAG_ARRAY,
+ 'flags' => FILTER_FORCE_ARRAY,
'options' => array("min_range"=>1, "max_range"=>10)
),
'versions' => array(
'filter' => FILTER_SANITIZE_ENCODED,
- 'flags' => FILTER_FLAG_SCALAR,
+ 'flags' => FILTER_REQUIRE_SCALAR,
),
'doesnotexist' => FILTER_VALIDATE_INT,
'testscalar' => FILTER_VALIDATE_INT,
'testarray' => array(
'filter' => FILTER_VALIDATE_INT,
- 'flags' => FILTER_FLAG_ARRAY,
+ 'flags' => FILTER_FORCE_ARRAY,
)
);
-$myinputs = input_get_args(INPUT_DATA, $args, $data);
+$myinputs = filter_var_array($data, $args);
var_dump($myinputs);
?>
--EXPECT--
--TEST--
-Test all filters returned by input_filters_list()
+Test all filters returned by filter_list()
--FILE--
<?php
include dirname(__FILE__) . '/033_run.inc';
);
-foreach(input_filters_list() as $filter) {
+foreach(filter_list() as $filter) {
if($filter=="validate_regexp") {
- foreach($data as $k=>$d) $result[$k] = filter_data($d,input_name_to_filter($filter),array("regexp"=>'/^O.*/'));
+ foreach($data as $k=>$d) $result[$k] = filter_var($d,filter_id($filter),array("options"=>array("regexp"=>'/^O.*/')));
} else {
- foreach($data as $k=>$d) $result[$k] = filter_data($d,input_name_to_filter($filter),"test");
+ foreach($data as $k=>$d) $result[$k] = filter_var($d,filter_id($filter),array("options"=>"test"));
}
printf("%-20s",$filter);
printf("%-5s",$result[0]);
);
foreach($booleans as $val=>$exp) {
- $res =filter_data($val, FILTER_VALIDATE_BOOLEAN);
+ $res =filter_var($val, FILTER_VALIDATE_BOOLEAN);
if ($res !== $exp) {
echo "$val failed,'$exp' expect, '$res' received.\n";
}
--TEST--
-GET/POST/REQUEST Test with input_get
+GET/POST/REQUEST Test with input_filter
--POST--
d=379
--GET--
ar[elm1]=1234&ar[elm2]=0660&a=0234
--FILE--
<?php
-$ret = input_get(INPUT_GET, 'a', FILTER_VALIDATE_INT);
+$ret = filter_input(INPUT_GET, 'a', FILTER_VALIDATE_INT);
var_dump($ret);
-$ret = input_get(INPUT_GET, 'a', FILTER_VALIDATE_INT, array('flags'=>FILTER_FLAG_ALLOW_OCTAL));
+$ret = filter_input(INPUT_GET, 'a', FILTER_VALIDATE_INT, array('flags'=>FILTER_FLAG_ALLOW_OCTAL));
var_dump($ret);
-$ret = input_get(INPUT_GET, 'ar', FILTER_VALIDATE_INT, array('flags'=>FILTER_FLAG_ARRAY));
+$ret = filter_input(INPUT_GET, 'ar', FILTER_VALIDATE_INT, array('flags'=>FILTER_REQUIRE_ARRAY));
var_dump($ret);
-$ret = input_get(INPUT_GET, 'ar', FILTER_VALIDATE_INT, array('flags'=>FILTER_FLAG_ALLOW_OCTAL|FILTER_FLAG_ARRAY));
+$ret = filter_input(INPUT_GET, 'ar', FILTER_VALIDATE_INT, array('flags'=>FILTER_FLAG_ALLOW_OCTAL|FILTER_REQUIRE_ARRAY));
var_dump($ret);
-
?>
--EXPECT--
bool(false)
$args["test1"] = FILTER_VALIDATE_INT;
$args["test2"] = FILTER_VALIDATE_INT;
-$ret = input_get_args(INPUT_DATA, $args, $data);
+$ret = filter_var_array($data, $args);
var_dump($ret);
var_dump($data); //should be separated, i.e. not reference anymore. looks like we can't change this, or it'd change the original zval instead..
var_dump($var); //should be still string(1) "1"
--FILE--
<?php
function myfunc($val) {
- return $val . _ . 'callback';
+ return $val . '_callback';
}
-echo input_get(INPUT_GET, 'a', FILTER_CALLBACK, 'myfunc');
+echo filter_input(INPUT_GET, 'a', FILTER_CALLBACK, array("options"=>'myfunc'));
echo "\n";
-echo input_get(INPUT_GET, 'b', FILTER_VALIDATE_INT);
+echo filter_input(INPUT_GET, 'b', FILTER_VALIDATE_INT);
echo "\n";
$data = "data";
-echo filter_data($data, FILTER_CALLBACK, 'myfunc');
+echo filter_var($data, FILTER_CALLBACK, array("options"=>'myfunc'));
echo "\n";
-$res = input_get_args(INPUT_GET, array(
+$res = filter_input_array(INPUT_GET, array(
'a' => array(
'filter' => FILTER_CALLBACK,
'options' => 'myfunc'
$args = array(
'product_id' => FILTER_SANITIZE_ENCODED,
- 'component' => array('flags' => FILTER_FLAG_ARRAY,
+ 'component' => array('flags' => FILTER_FORCE_ARRAY,
'options' => array("min_range"=>1, "max_range"=>10)
),
'versions' => array(
'filter' => FILTER_SANITIZE_ENCODED,
- 'flags' => FILTER_FLAG_SCALAR,
+ 'flags' => FILTER_REQUIRE_SCALAR,
),
'doesnotexist' => FILTER_VALIDATE_INT,
'testscalar' => FILTER_VALIDATE_INT,
'testarray' => array(
'filter' => FILTER_VALIDATE_INT,
- 'flags' => FILTER_FLAG_ARRAY,
+ 'flags' => FILTER_FORCE_ARRAY,
)
);
-$out = input_get_args(INPUT_DATA, $args, $data);
+$out = filter_var_array($data, $args);
var_dump($out);
?>
--EXPECTF--
'02.324'
);
foreach ($data as $val) {
- $res = filter_data($val, FILTER_VALIDATE_FLOAT);
+ $res = filter_var($val, FILTER_VALIDATE_FLOAT);
var_dump($res);
}
echo "\n";
'E-2',
'+E2'
);
-$out = filter_data($data, FILTER_VALIDATE_FLOAT);
+$out = filter_var($data, FILTER_VALIDATE_FLOAT, FILTER_REQUIRE_ARRAY);
var_dump($out);
?>
--EXPECTF--
<?php
$var="3".chr(0)."foo";
-var_dump(filter_data($var, FILTER_VALIDATE_INT));
+var_dump(filter_var($var, FILTER_VALIDATE_INT));
$var="3".chr(0)."foo";
-var_dump(filter_data($var, FILTER_VALIDATE_FLOAT));
+var_dump(filter_var($var, FILTER_VALIDATE_FLOAT));
?>
--EXPECTF--
bool(false)
--TEST--
-Simple filter_data() tests
+Simple filter_var() tests
--FILE--
<?php
/* Integer */
-$data = "-123"; var_dump(filter_data($data, FILTER_VALIDATE_INT));
-$data = "0"; var_dump(filter_data($data, FILTER_VALIDATE_INT));
-$data = "123"; var_dump(filter_data($data, FILTER_VALIDATE_INT));
-$data = -123; var_dump(filter_data($data, FILTER_VALIDATE_INT));
-$data = 0; var_dump(filter_data($data, FILTER_VALIDATE_INT));
-$data = 123; var_dump(filter_data($data, FILTER_VALIDATE_INT));
-$data = ""; var_dump(filter_data($data, FILTER_VALIDATE_INT));
+$data = "-123"; var_dump(filter_var($data, FILTER_VALIDATE_INT));
+$data = "0"; var_dump(filter_var($data, FILTER_VALIDATE_INT));
+$data = "123"; var_dump(filter_var($data, FILTER_VALIDATE_INT));
+$data = -123; var_dump(filter_var($data, FILTER_VALIDATE_INT));
+$data = 0; var_dump(filter_var($data, FILTER_VALIDATE_INT));
+$data = 123; var_dump(filter_var($data, FILTER_VALIDATE_INT));
+$data = ""; var_dump(filter_var($data, FILTER_VALIDATE_INT));
echo "\n";
/* Float */
-$data = "-0.123"; var_dump(filter_data($data, FILTER_VALIDATE_FLOAT));
-$data = "0.00"; var_dump(filter_data($data, FILTER_VALIDATE_FLOAT));
-$data = "1.23"; var_dump(filter_data($data, FILTER_VALIDATE_FLOAT));
-$data = -1.23; var_dump(filter_data($data, FILTER_VALIDATE_FLOAT));
-$data = 0.0; var_dump(filter_data($data, FILTER_VALIDATE_FLOAT));
-$data = 1.23; var_dump(filter_data($data, FILTER_VALIDATE_FLOAT));
-$data = ""; var_dump(filter_data($data, FILTER_VALIDATE_FLOAT));
+$data = "-0.123"; var_dump(filter_var($data, FILTER_VALIDATE_FLOAT));
+$data = "0.00"; var_dump(filter_var($data, FILTER_VALIDATE_FLOAT));
+$data = "1.23"; var_dump(filter_var($data, FILTER_VALIDATE_FLOAT));
+$data = -1.23; var_dump(filter_var($data, FILTER_VALIDATE_FLOAT));
+$data = 0.0; var_dump(filter_var($data, FILTER_VALIDATE_FLOAT));
+$data = 1.23; var_dump(filter_var($data, FILTER_VALIDATE_FLOAT));
+$data = ""; var_dump(filter_var($data, FILTER_VALIDATE_FLOAT));
echo "\n";
/* Boolean */
-$data = "on"; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = "off"; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = "yes"; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = "no"; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = "true"; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = "false"; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = "1"; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = "0"; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = 1; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = 0; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = true; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = false; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
-$data = ""; var_dump(filter_data($data, FILTER_VALIDATE_BOOLEAN));
+$data = "on"; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = "off"; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = "yes"; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = "no"; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = "true"; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = "false"; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = "1"; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = "0"; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = 1; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = 0; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = true; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = false; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
+$data = ""; var_dump(filter_var($data, FILTER_VALIDATE_BOOLEAN));
?>
--EXPECT--
projects / php / commitdiff