Back to index

php5  5.3.10
Classes | Defines | Typedefs | Functions | Variables
filter.c File Reference
#include "php_filter.h"
#include "filter_private.h"

Go to the source code of this file.

Classes

struct  filter_list_entry

Defines

#define PARSE_ENV   4
#define PARSE_SERVER   5
#define PARSE_SESSION   6
#define PARSE_REQUEST   99
#define VAR_ARRAY_COPY_DTOR(a)
#define PARSE_CASE(s, a, t)

Typedefs

typedef struct filter_list_entry filter_list_entry

Functions

static unsigned int php_sapi_filter (int arg, char *var, char **val, unsigned int val_len, unsigned int *new_val_len TSRMLS_DC)
static unsigned int php_sapi_filter_init (TSRMLS_D)
static PHP_INI_MH (UpdateDefaultFilter)
static PHP_INI_MH (OnUpdateFlags)
static void php_filter_init_globals (zend_filter_globals *filter_globals)
 PHP_MINIT_FUNCTION (filter)
 PHP_MSHUTDOWN_FUNCTION (filter)
 PHP_RSHUTDOWN_FUNCTION (filter)
 PHP_MINFO_FUNCTION (filter)
static filter_list_entry php_find_filter (long id)
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_recursive (zval **value, long filter, long flags, zval *options, char *charset, zend_bool copy TSRMLS_DC)
static zval * php_filter_get_storage (long arg TSRMLS_DC)
 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_array_handler (zval *input, zval **op, zval *return_value, zend_bool add_empty TSRMLS_DC)
 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_id)

Variables

static const filter_list_entry filter_list []
static const zend_function_entry filter_functions []
zend_module_entry filter_module_entry

Define Documentation

#define PARSE_CASE (   s,
  a,
 
)
Value:
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]; \
                     break;
#define PARSE_ENV   4

Definition at line 68 of file filter.c.

#define PARSE_REQUEST   99

Definition at line 203 of file filter.c.

#define PARSE_SERVER   5

Definition at line 72 of file filter.c.

#define PARSE_SESSION   6

Definition at line 76 of file filter.c.

#define VAR_ARRAY_COPY_DTOR (   a)
Value:
if (IF_G(a)) {               \
              zval_ptr_dtor(&IF_G(a)); \
              IF_G(a) = NULL;          \
       }

Definition at line 297 of file filter.c.


Typedef Documentation


Function Documentation

static void php_filter_array_handler ( zval *  input,
zval **  op,
zval *  return_value,
zend_bool add_empty  TSRMLS_DC 
) [static]

Definition at line 694 of file filter.c.

{
       char *arg_key;
       uint arg_key_len;
       ulong index;
       HashPosition pos;
       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) {
              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) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Numeric keys are not allowed in the definition array");
                            zval_dtor(return_value);
                            RETURN_FALSE;
                     }
                     if (arg_key_len < 2) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty 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) {
                            if (add_empty) {
                                   add_assoc_null_ex(return_value, arg_key, arg_key_len);
                            }
                     } else {
                            zval *nval;

                            ALLOC_ZVAL(nval);
                            MAKE_COPY_ZVAL(tmp, nval);

                            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);
                     }
              }
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void php_filter_call ( zval **  filtered,
long  filter,
zval **  filter_args,
const int  copy,
long filter_flags  TSRMLS_DC 
) [static]

Definition at line 604 of file filter.c.

{
       zval  *options = NULL;
       zval **option;
       char  *charset = NULL;

       if (filter_args && Z_TYPE_PP(filter_args) != IS_ARRAY) {
              long lval;

              PHP_FILTER_GET_LONG_OPT(filter_args, lval);

              if (filter != -1) { /* handler for array apply */
                     /* filter_args is the filter_flags */
                     filter_flags = lval;

                     if (!(filter_flags & FILTER_REQUIRE_ARRAY ||  filter_flags & FILTER_FORCE_ARRAY)) {
                            filter_flags |= FILTER_REQUIRE_SCALAR;
                     }
              } else {
                     filter = lval;
              }
       } else if (filter_args) {
              if (zend_hash_find(HASH_OF(*filter_args), "filter", sizeof("filter"), (void **)&option) == SUCCESS) {
                     PHP_FILTER_GET_LONG_OPT(option, filter);
              }

              if (zend_hash_find(HASH_OF(*filter_args), "flags", sizeof("flags"), (void **)&option) == SUCCESS) {
                     PHP_FILTER_GET_LONG_OPT(option, filter_flags);

                     if (!(filter_flags & FILTER_REQUIRE_ARRAY ||  filter_flags & FILTER_FORCE_ARRAY)) {
                            filter_flags |= FILTER_REQUIRE_SCALAR;
                     }
              }

              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 {
                            options = *option;
                            filter_flags = 0;
                     }
              }
       }

       if (Z_TYPE_PP(filtered) == IS_ARRAY) {
              if (filter_flags & FILTER_REQUIRE_SCALAR) {
                     if (copy) {
                            SEPARATE_ZVAL(filtered);
                     }
                     zval_dtor(*filtered);
                     if (filter_flags & FILTER_NULL_ON_FAILURE) {
                            ZVAL_NULL(*filtered);
                     } else {
                            ZVAL_FALSE(*filtered);
                     }
                     return;
              }
              php_zval_filter_recursive(filtered, filter, filter_flags, options, charset, copy TSRMLS_CC);
              return;
       }
       if (filter_flags & FILTER_REQUIRE_ARRAY) {
              if (copy) {
                     SEPARATE_ZVAL(filtered);
              }
              zval_dtor(*filtered);
              if (filter_flags & FILTER_NULL_ON_FAILURE) {
                     ZVAL_NULL(*filtered);
              } else {
                     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);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static zval* php_filter_get_storage ( long arg  TSRMLS_DC) [static]

Definition at line 538 of file filter.c.

{
       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);
                     break;
              case PARSE_POST:
                     array_ptr = IF_G(post_array);
                     break;
              case PARSE_COOKIE:
                     array_ptr = IF_G(cookie_array);
                     break;
              case PARSE_SERVER:
                     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);
                     }
                     array_ptr = IF_G(env_array) ? IF_G(env_array) : PG(http_globals)[TRACK_VARS_ENV];
                     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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void php_filter_init_globals ( zend_filter_globals *  filter_globals) [static]

Definition at line 191 of file filter.c.

{
       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;
       filter_globals->default_filter = FILTER_DEFAULT;
}

Here is the caller graph for this function:

static filter_list_entry php_find_filter ( long  id) [static]

Definition at line 328 of file filter.c.

{
       int i, size = sizeof(filter_list) / sizeof(filter_list_entry);

       for (i = 0; i < size; ++i) {
              if (filter_list[i].id == id) {
                     return filter_list[i];
              }
       }
       /* Fallback to "string" filter */
       for (i = 0; i < size; ++i) {
              if (filter_list[i].id == FILTER_DEFAULT) {
                     return filter_list[i];
              }
       }
       /* To shut up GCC */
       return filter_list[0];
}

Here is the caller graph for this function:

PHP_FUNCTION ( filter_has_var  )

Definition at line 583 of file filter.c.

{
       long        arg;
       char       *var;
       int         var_len;
       zval       *array_ptr = NULL;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &arg, &var, &var_len) == 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)) {
              RETURN_TRUE;
       }

       RETURN_FALSE;
}

Here is the call graph for this function:

PHP_FUNCTION ( filter_input  )

Definition at line 751 of file filter.c.

{
       long   fetch_from, filter = FILTER_DEFAULT;
       zval **filter_args = NULL, **tmp;
       zval  *input = NULL;
       char *var;
       int var_len;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls|lZ", &fetch_from, &var, &var_len, &filter, &filter_args) == FAILURE) {
              return;
       }

       if (!PHP_FILTER_ID_EXISTS(filter)) {
              RETURN_FALSE;
       }

       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) {
              long filter_flags = 0;
              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) {
                            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);
                            return;
                     }
              }

              /* The FILTER_NULL_ON_FAILURE flag inverts the usual return values of
               * the function: normally when validation fails false is returned, and
               * when the input value doesn't exist NULL is returned. With the flag
               * set, NULL and false should be returned, respectively. Ergo, although
               * the code below looks incorrect, it's actually right. */
              if (filter_flags & FILTER_NULL_ON_FAILURE) {
                     RETURN_FALSE;
              } else {
                     RETURN_NULL();
              }
       }

       MAKE_COPY_ZVAL(tmp, return_value);

       php_filter_call(&return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR TSRMLS_CC);
}

Here is the call graph for this function:

PHP_FUNCTION ( filter_var  )

Definition at line 809 of file filter.c.

{
       long filter = FILTER_DEFAULT;
       zval **filter_args = NULL, *data;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/|lZ", &data, &filter, &filter_args) == FAILURE) {
              return;
       }

       if (!PHP_FILTER_ID_EXISTS(filter)) {
              RETURN_FALSE;
       }

       MAKE_COPY_ZVAL(&data, return_value);

       php_filter_call(&return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR TSRMLS_CC);
}

Here is the call graph for this function:

PHP_FUNCTION ( filter_input_array  )

Definition at line 831 of file filter.c.

{
       long    fetch_from;
       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) {
              return;
       }

       if (op
              && (Z_TYPE_PP(op) != IS_ARRAY)
              && (Z_TYPE_PP(op) == IS_LONG && !PHP_FILTER_ID_EXISTS(Z_LVAL_PP(op)))
              ) {
              RETURN_FALSE;
       }

       array_input = php_filter_get_storage(fetch_from TSRMLS_CC);

       if (!array_input || !HASH_OF(array_input)) {
              long filter_flags = 0;
              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) {
                            PHP_FILTER_GET_LONG_OPT(option, filter_flags);
                     }
              }

              /* The FILTER_NULL_ON_FAILURE flag inverts the usual return values of
               * the function: normally when validation fails false is returned, and
               * when the input value doesn't exist NULL is returned. With the flag
               * set, NULL and false should be returned, respectively. Ergo, although
               * the code below looks incorrect, it's actually right. */
              if (filter_flags & FILTER_NULL_ON_FAILURE) {
                     RETURN_FALSE;
              } else {
                     RETURN_NULL();
              }
       }

       php_filter_array_handler(array_input, op, return_value, add_empty TSRMLS_CC);
}

Here is the call graph for this function:

PHP_FUNCTION ( filter_var_array  )

Definition at line 880 of file filter.c.

{
       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) {
              return;
       }

       if (op
              && (Z_TYPE_PP(op) != IS_ARRAY)
              && (Z_TYPE_PP(op) == IS_LONG && !PHP_FILTER_ID_EXISTS(Z_LVAL_PP(op)))
              ) {
              RETURN_FALSE;
       }

       php_filter_array_handler(array_input, op, return_value, add_empty TSRMLS_CC);
}

Here is the call graph for this function:

Definition at line 902 of file filter.c.

{
       int i, size = sizeof(filter_list) / sizeof(filter_list_entry);

       if (zend_parse_parameters_none() == FAILURE) {
              return;
       }

       array_init(return_value);
       for (i = 0; i < size; ++i) {
              add_next_index_string(return_value, (char *)filter_list[i].name, 1);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( filter_id  )

Definition at line 919 of file filter.c.

{
       int i, filter_len;
       int size = sizeof(filter_list) / sizeof(filter_list_entry);
       char *filter;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filter, &filter_len) == FAILURE) {
              return;
       }

       for (i = 0; i < size; ++i) {
              if (strcmp(filter_list[i].name, filter) == 0) {
                     RETURN_LONG(filter_list[i].id);
              }
       }

       RETURN_FALSE;
}

Here is the call graph for this function:

static PHP_INI_MH ( UpdateDefaultFilter  ) [static]

Definition at line 157 of file filter.c.

{
       int i, size = sizeof(filter_list) / sizeof(filter_list_entry);

       for (i = 0; i < size; ++i) {
              if ((strcasecmp(new_value, filter_list[i].name) == 0)) {
                     IF_G(default_filter) = filter_list[i].id;
                     return SUCCESS;
              }
       }
       /* Fallback to the default filter */
       IF_G(default_filter) = FILTER_DEFAULT;
       return SUCCESS;
}
static PHP_INI_MH ( OnUpdateFlags  ) [static]

Definition at line 175 of file filter.c.

{
       if (!new_value) {
              IF_G(default_filter_flags) = FILTER_FLAG_NO_ENCODE_QUOTES;
       } else {
              IF_G(default_filter_flags) = atoi(new_value);
       }
       return SUCCESS;
}
PHP_MINFO_FUNCTION ( filter  )

Definition at line 317 of file filter.c.

{
       php_info_print_table_start();
       php_info_print_table_row( 2, "Input Validation and Filtering", "enabled" );
       php_info_print_table_row( 2, "Revision", "$Revision: 321634 $");
       php_info_print_table_end();

       DISPLAY_INI_ENTRIES();
}

Here is the call graph for this function:

PHP_MINIT_FUNCTION ( filter  )

Definition at line 207 of file filter.c.

{
       ZEND_INIT_MODULE_GLOBALS(filter, php_filter_init_globals, 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_COOKIE",    PARSE_COOKIE,        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_REQUEST", PARSE_REQUEST,  CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("FILTER_FLAG_NONE", FILTER_FLAG_NONE, 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_NULL_ON_FAILURE", FILTER_NULL_ON_FAILURE, 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);
       REGISTER_LONG_CONSTANT("FILTER_VALIDATE_FLOAT", FILTER_VALIDATE_FLOAT, CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("FILTER_VALIDATE_REGEXP", FILTER_VALIDATE_REGEXP, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_VALIDATE_URL", FILTER_VALIDATE_URL, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_VALIDATE_EMAIL", FILTER_VALIDATE_EMAIL, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_VALIDATE_IP", FILTER_VALIDATE_IP, CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("FILTER_DEFAULT", FILTER_DEFAULT, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_UNSAFE_RAW", FILTER_UNSAFE_RAW, CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("FILTER_SANITIZE_STRING", FILTER_SANITIZE_STRING, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_SANITIZE_STRIPPED", FILTER_SANITIZE_STRING, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_SANITIZE_ENCODED", FILTER_SANITIZE_ENCODED, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_SANITIZE_SPECIAL_CHARS", FILTER_SANITIZE_SPECIAL_CHARS, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_SANITIZE_FULL_SPECIAL_CHARS", FILTER_SANITIZE_SPECIAL_CHARS, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_SANITIZE_EMAIL", FILTER_SANITIZE_EMAIL, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_SANITIZE_URL", FILTER_SANITIZE_URL, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_SANITIZE_NUMBER_INT", FILTER_SANITIZE_NUMBER_INT, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_SANITIZE_NUMBER_FLOAT", FILTER_SANITIZE_NUMBER_FLOAT, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_SANITIZE_MAGIC_QUOTES", FILTER_SANITIZE_MAGIC_QUOTES, CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("FILTER_CALLBACK", FILTER_CALLBACK, CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("FILTER_FLAG_ALLOW_OCTAL", FILTER_FLAG_ALLOW_OCTAL, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_ALLOW_HEX", FILTER_FLAG_ALLOW_HEX, CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("FILTER_FLAG_STRIP_LOW", FILTER_FLAG_STRIP_LOW, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_STRIP_HIGH", FILTER_FLAG_STRIP_HIGH, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_STRIP_BACKTICK", FILTER_FLAG_STRIP_BACKTICK, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_ENCODE_LOW", FILTER_FLAG_ENCODE_LOW, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_ENCODE_HIGH", FILTER_FLAG_ENCODE_HIGH, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_ENCODE_AMP", FILTER_FLAG_ENCODE_AMP, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_NO_ENCODE_QUOTES", FILTER_FLAG_NO_ENCODE_QUOTES, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_EMPTY_STRING_NULL", FILTER_FLAG_EMPTY_STRING_NULL, CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("FILTER_FLAG_ALLOW_FRACTION", FILTER_FLAG_ALLOW_FRACTION, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_ALLOW_THOUSAND", FILTER_FLAG_ALLOW_THOUSAND, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_ALLOW_SCIENTIFIC", FILTER_FLAG_ALLOW_SCIENTIFIC, CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("FILTER_FLAG_SCHEME_REQUIRED", FILTER_FLAG_SCHEME_REQUIRED, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_HOST_REQUIRED", FILTER_FLAG_HOST_REQUIRED, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_PATH_REQUIRED", FILTER_FLAG_PATH_REQUIRED, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_QUERY_REQUIRED", FILTER_FLAG_QUERY_REQUIRED, CONST_CS | CONST_PERSISTENT);

       REGISTER_LONG_CONSTANT("FILTER_FLAG_IPV4", FILTER_FLAG_IPV4, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_IPV6", FILTER_FLAG_IPV6, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_NO_RES_RANGE", FILTER_FLAG_NO_RES_RANGE, CONST_CS | CONST_PERSISTENT);
       REGISTER_LONG_CONSTANT("FILTER_FLAG_NO_PRIV_RANGE", FILTER_FLAG_NO_PRIV_RANGE, CONST_CS | CONST_PERSISTENT);

       sapi_register_input_filter(php_sapi_filter, php_sapi_filter_init);

       return SUCCESS;
}

Here is the call graph for this function:

PHP_MSHUTDOWN_FUNCTION ( filter  )

Definition at line 287 of file filter.c.

PHP_RSHUTDOWN_FUNCTION ( filter  )
static unsigned int php_sapi_filter ( int  arg,
char *  var,
char **  val,
unsigned int  val_len,
unsigned int *new_val_len  TSRMLS_DC 
) [static]

Definition at line 405 of file filter.c.

{
       zval  new_var, raw_var;
       zval *array_ptr = NULL, *orig_array_ptr = NULL;
       char *orig_var = NULL;
       int retval = 0;

       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]; \
                     break;

       switch (arg) {
              PARSE_CASE(PARSE_POST,    post_array,    TRACK_VARS_POST)
              PARSE_CASE(PARSE_GET,     get_array,     TRACK_VARS_GET)
              PARSE_CASE(PARSE_COOKIE,  cookie_array,  TRACK_VARS_COOKIE)
              PARSE_CASE(PARSE_SERVER,  server_array,  TRACK_VARS_SERVER)
              PARSE_CASE(PARSE_ENV,     env_array,     TRACK_VARS_ENV)

              case PARSE_STRING: /* PARSE_STRING is used by parse_str() function */
                     retval = 1;
                     break;
       }

       /* 
        * According to rfc2965, more specific paths are listed above the less specific ones.
        * If we encounter a duplicate cookie name, we should skip it, since it is not possible
        * 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)) {
              return 0;
       }

       if (array_ptr) {
              /* Make a copy of the variable name, as php_register_variable_ex seems to
               * modify it */
              orig_var = estrdup(var);

              /* Store the RAW variable internally */
              /* FIXME: Should not use php_register_variable_ex as that also registers
               * globals when register_globals is turned on */
              Z_STRLEN(raw_var) = val_len;
              Z_STRVAL(raw_var) = estrndup(*val, val_len);
              Z_TYPE(raw_var) = IS_STRING;

              php_register_variable_ex(var, &raw_var, array_ptr TSRMLS_CC);
       }

       if (val_len) {
              /* Register mangled variable */
              /* FIXME: Should not use php_register_variable_ex as that also registers
               * globals when register_globals is turned on */
              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);
              } else if (PG(magic_quotes_gpc) && !retval) { /* for PARSE_STRING php_register_variable_safe() will do the addslashes() */
                     Z_STRVAL(new_var) = php_addslashes(*val, Z_STRLEN(new_var), &Z_STRLEN(new_var), 0 TSRMLS_CC);
              } else {
                     Z_STRVAL(new_var) = estrndup(*val, val_len);
              }
       } else { /* empty string */
              ZVAL_EMPTY_STRING(&new_var);
       }

       if (orig_array_ptr) {
              php_register_variable_ex(orig_var, &new_var, orig_array_ptr TSRMLS_CC);
       }
       if (array_ptr) {
              efree(orig_var);
       }

       if (retval) {
              if (new_val_len) {
                     *new_val_len = Z_STRLEN(new_var);
              }
              efree(*val);
              if (Z_STRLEN(new_var)) {
                     *val = estrndup(Z_STRVAL(new_var), Z_STRLEN(new_var));
              } else {
                     *val = estrdup("");
              }
              zval_dtor(&new_var);
       }

       return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned int php_sapi_filter_init ( TSRMLS_D  ) [static]

Definition at line 348 of file filter.c.

Here is the caller graph for this function:

static void php_zval_filter ( zval **  value,
long  filter,
long  flags,
zval *  options,
char *  charset,
zend_bool copy  TSRMLS_DC 
) [static]

Definition at line 359 of file filter.c.

{
       filter_list_entry  filter_func;

       filter_func = php_find_filter(filter);

       if (!filter_func.id) {
              /* Find default filter */
              filter_func = php_find_filter(FILTER_DEFAULT);
       }

       if (copy) {
              SEPARATE_ZVAL(value);
       }

       /* #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) {
              zend_class_entry *ce;

              ce = Z_OBJCE_PP(value);
              if (!ce->__tostring) {
                     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);
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void php_zval_filter_recursive ( zval **  value,
long  filter,
long  flags,
zval *  options,
char *  charset,
zend_bool copy  TSRMLS_DC 
) [static]

Definition at line 509 of file filter.c.

{
       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)
              ) {
                     SEPARATE_ZVAL_IF_NOT_REF(element);
                     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);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Initial value:

Definition at line 123 of file filter.c.

const filter_list_entry filter_list[] [static]
zend_module_entry filter_module_entry
Initial value:
 {



       "filter",
       filter_functions,
       PHP_MINIT(filter),
       PHP_MSHUTDOWN(filter),
       NULL,
       PHP_RSHUTDOWN(filter),
       PHP_MINFO(filter),
       "0.11.0",
       STANDARD_MODULE_PROPERTIES
}

Definition at line 137 of file filter.c.