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

LCOV - code coverage report
Current view: top level - main - php_variables.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 358 396 90.4 %
Date: 2014-12-13 Functions: 20 22 90.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Rasmus Lerdorf <rasmus@lerdorf.on.ca>                       |
      16             :    |          Zeev Suraski <zeev@zend.com>                                |
      17             :    +----------------------------------------------------------------------+
      18             :  */
      19             : 
      20             : /* $Id$ */
      21             : 
      22             : #include <stdio.h>
      23             : #include "php.h"
      24             : #include "ext/standard/php_standard.h"
      25             : #include "ext/standard/credits.h"
      26             : #include "zend_smart_str.h"
      27             : #include "php_variables.h"
      28             : #include "php_globals.h"
      29             : #include "php_content_types.h"
      30             : #include "SAPI.h"
      31             : #include "zend_globals.h"
      32             : #ifdef PHP_WIN32
      33             : # include "win32/php_inttypes.h"
      34             : #endif
      35             : 
      36             : /* for systems that need to override reading of environment variables */
      37             : void _php_import_environment_variables(zval *array_ptr TSRMLS_DC);
      38             : PHPAPI void (*php_import_environment_variables)(zval *array_ptr TSRMLS_DC) = _php_import_environment_variables;
      39             : 
      40     1004332 : PHPAPI void php_register_variable(char *var, char *strval, zval *track_vars_array TSRMLS_DC)
      41             : {
      42     1004332 :         php_register_variable_safe(var, strval, strlen(strval), track_vars_array TSRMLS_CC);
      43     1004332 : }
      44             : 
      45             : /* binary-safe version */
      46     1004643 : PHPAPI void php_register_variable_safe(char *var, char *strval, size_t str_len, zval *track_vars_array TSRMLS_DC)
      47             : {
      48             :         zval new_entry;
      49             :         assert(strval != NULL);
      50             :         
      51             :         /* Prepare value */
      52     2009286 :         ZVAL_NEW_STR(&new_entry, zend_string_init(strval, str_len, 0));
      53     1004643 :         php_register_variable_ex(var, &new_entry, track_vars_array TSRMLS_CC);
      54     1004643 : }
      55             : 
      56     1248178 : PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars_array TSRMLS_DC)
      57             : {
      58     1248178 :         char *p = NULL;
      59     1248178 :         char *ip = NULL;                /* index pointer */
      60             :         char *index;
      61             :         char *var, *var_orig;
      62             :         size_t var_len, index_len;
      63             :         zval gpc_element, *gpc_element_p;
      64     1248178 :         zend_bool is_array = 0;
      65     1248178 :         HashTable *symtable1 = NULL;
      66             :         ALLOCA_FLAG(use_heap)
      67             : 
      68             :         assert(var_name != NULL);
      69             : 
      70     2496160 :         if (track_vars_array && Z_TYPE_P(track_vars_array) == IS_ARRAY) {
      71     1247982 :                 symtable1 = Z_ARRVAL_P(track_vars_array);
      72             :         }
      73             : 
      74     1248178 :         if (!symtable1) {
      75             :                 /* Nothing to do */
      76             :                 zval_dtor(val);
      77         196 :                 return;
      78             :         }
      79             : 
      80             : 
      81             :         /* ignore leading spaces in the variable name */
      82     2495974 :         while (*var_name && *var_name==' ') {
      83          10 :                 var_name++;
      84             :         }
      85             :         
      86             :         /*
      87             :          * Prepare variable name
      88             :          */
      89     1247982 :         var_len = strlen(var_name);
      90     1247982 :         var = var_orig = do_alloca(var_len + 1, use_heap);
      91     1247982 :         memcpy(var_orig, var_name, var_len + 1);
      92             : 
      93             :         /* ensure that we don't have spaces or dots in the variable name (not binary safe) */
      94    17667809 :         for (p = var; *p; p++) {
      95    16420994 :                 if (*p == ' ' || *p == '.') {
      96         798 :                         *p='_';
      97    16419398 :                 } else if (*p == '[') {
      98         369 :                         is_array = 1;
      99         369 :                         ip = p;
     100         369 :                         *p = 0;
     101         369 :                         break;
     102             :                 }
     103             :         }
     104     1247982 :         var_len = p - var;
     105             : 
     106     1247982 :         if (var_len==0) { /* empty variable name, or variable name with a space in it */
     107             :                 zval_dtor(val);
     108           0 :                 free_alloca(var_orig, use_heap);
     109           0 :                 return;
     110             :         }
     111             : 
     112             :         /* GLOBALS hijack attempt, reject parameter */
     113     1247984 :         if (symtable1 == &EG(symbol_table).ht &&
     114             :                 var_len == sizeof("GLOBALS")-1 &&
     115           2 :                 !memcmp(var, "GLOBALS", sizeof("GLOBALS")-1)) {
     116             :                 zval_dtor(val);
     117           0 :                 free_alloca(var_orig, use_heap);
     118           0 :                 return;
     119             :         }
     120             : 
     121     1247982 :         index = var;
     122     1247982 :         index_len = var_len;
     123             : 
     124     1247982 :         if (is_array) {
     125         369 :                 int nest_level = 0;
     126             :                 while (1) {
     127             :                         char *index_s;
     128         462 :                         size_t new_idx_len = 0;
     129             : 
     130         462 :                         if(++nest_level > PG(max_input_nesting_level)) {
     131             :                                 HashTable *ht;
     132             :                                 /* too many levels of nesting */
     133             : 
     134           8 :                                 if (track_vars_array) {
     135           8 :                                         ht = Z_ARRVAL_P(track_vars_array);
     136             :                                         zend_symtable_str_del(ht, var, var_len);
     137             :                                 }
     138             : 
     139             :                                 zval_dtor(val);
     140             : 
     141             :                                 /* do not output the error message to the screen,
     142             :                                  this helps us to to avoid "information disclosure" */
     143           8 :                                 if (!PG(display_errors)) {
     144           2 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variable nesting level exceeded " ZEND_LONG_FMT ". To increase the limit change max_input_nesting_level in php.ini.", PG(max_input_nesting_level));
     145             :                                 }
     146           8 :                                 free_alloca(var_orig, use_heap);
     147           8 :                                 return;
     148             :                         }
     149             : 
     150         454 :                         ip++;
     151         454 :                         index_s = ip;
     152         454 :                         if (isspace(*ip)) {
     153           0 :                                 ip++;
     154             :                         }
     155         454 :                         if (*ip==']') {
     156         122 :                                 index_s = NULL;
     157             :                         } else {
     158         332 :                                 ip = strchr(ip, ']');
     159         332 :                                 if (!ip) {
     160             :                                         /* PHP variables cannot contain '[' in their names, so we replace the character with a '_' */
     161           4 :                                         *(index_s - 1) = '_';
     162             : 
     163           4 :                                         index_len = 0;
     164           4 :                                         if (index) {
     165           4 :                                                 index_len = strlen(index);
     166             :                                         }
     167           4 :                                         goto plain_var;
     168             :                                         return;
     169             :                                 }
     170         328 :                                 *ip = 0;
     171         328 :                                 new_idx_len = strlen(index_s);  
     172             :                         }
     173             : 
     174         450 :                         if (!index) {
     175          38 :                                 array_init(&gpc_element);
     176          38 :                                 if ((gpc_element_p = zend_hash_next_index_insert(symtable1, &gpc_element)) == NULL) {
     177           0 :                                         zval_ptr_dtor(&gpc_element);
     178             :                                         zval_dtor(val);
     179           0 :                                         free_alloca(var_orig, use_heap);
     180           0 :                                         return;
     181             :                                 }
     182             :                         } else {
     183         412 :                                 gpc_element_p = zend_symtable_str_find(symtable1, index, index_len);
     184         412 :                                 if (!gpc_element_p) {
     185             :                                         zval tmp;
     186         127 :                                         array_init(&tmp);
     187         127 :                                         gpc_element_p = zend_symtable_str_update_ind(symtable1, index, index_len, &tmp);
     188             :                                 } else {
     189         285 :                                         if (Z_TYPE_P(gpc_element_p) == IS_INDIRECT) {
     190          18 :                                                 gpc_element_p = Z_INDIRECT_P(gpc_element_p);
     191             :                                         }
     192         285 :                                         if (Z_TYPE_P(gpc_element_p) != IS_ARRAY) {
     193           9 :                                                 zval_ptr_dtor(gpc_element_p);
     194           9 :                                                 array_init(gpc_element_p);
     195             :                                         }
     196             :                                 }
     197             :                         }
     198         450 :                         symtable1 = Z_ARRVAL_P(gpc_element_p);
     199             :                         /* ip pointed to the '[' character, now obtain the key */
     200         450 :                         index = index_s;
     201         450 :                         index_len = new_idx_len;
     202             : 
     203         450 :                         ip++;
     204         450 :                         if (*ip == '[') {
     205          93 :                                 is_array = 1;
     206          93 :                                 *ip = 0;
     207             :                         } else {
     208         357 :                                 goto plain_var;
     209             :                         }
     210          93 :                 }
     211             :         } else {
     212             : plain_var:
     213     1247974 :                 ZVAL_COPY_VALUE(&gpc_element, val);
     214     1247974 :                 if (!index) {
     215          80 :                         if ((gpc_element_p = zend_hash_next_index_insert(symtable1, &gpc_element)) == NULL) {
     216           0 :                                 zval_ptr_dtor(&gpc_element);
     217             :                         }
     218             :                 } else {
     219             :                         /* 
     220             :                          * According to rfc2965, more specific paths are listed above the less specific ones.
     221             :                          * If we encounter a duplicate cookie name, we should skip it, since it is not possible
     222             :                          * to have the same (plain text) cookie name for the same path and we should not overwrite
     223             :                          * more specific cookies with the less specific ones.
     224             :                          */
     225     2495016 :                         if (Z_TYPE(PG(http_globals)[TRACK_VARS_COOKIE]) != IS_UNDEF &&
     226     1247082 :                                 symtable1 == Z_ARRVAL(PG(http_globals)[TRACK_VARS_COOKIE]) &&
     227             :                                 zend_symtable_str_exists(symtable1, index, index_len)) {
     228           4 :                                 zval_ptr_dtor(&gpc_element);
     229             :                         } else {
     230     1247890 :                                 gpc_element_p = zend_symtable_str_update_ind(symtable1, index, index_len, &gpc_element);
     231             :                         }
     232             :                 }
     233             :         }
     234     1247974 :         free_alloca(var_orig, use_heap);
     235             : }
     236             : 
     237             : typedef struct post_var_data {
     238             :         smart_str str;
     239             :         char *ptr;
     240             :         char *end;
     241             :         uint64_t cnt;
     242             : } post_var_data_t;
     243             : 
     244         125 : static zend_bool add_post_var(zval *arr, post_var_data_t *var, zend_bool eof TSRMLS_DC)
     245             : {
     246             :         char *ksep, *vsep, *val;
     247             :         size_t klen, vlen;
     248             :         /* FIXME: string-size_t */
     249             :         size_t new_vlen;
     250             : 
     251         125 :         if (var->ptr >= var->end) {
     252          32 :                 return 0;
     253             :         }
     254             : 
     255          93 :         vsep = memchr(var->ptr, '&', var->end - var->ptr);
     256          93 :         if (!vsep) {
     257          64 :                 if (!eof) {
     258          32 :                         return 0;
     259             :                 } else {
     260          32 :                         vsep = var->end;
     261             :                 }
     262             :         }
     263             : 
     264          61 :         ksep = memchr(var->ptr, '=', vsep - var->ptr);
     265          61 :         if (ksep) {
     266          58 :                 *ksep = '\0';
     267             :                 /* "foo=bar&" or "foo=&" */
     268          58 :                 klen = ksep - var->ptr;
     269          58 :                 vlen = vsep - ++ksep;
     270             :         } else {
     271           3 :                 ksep = "";
     272             :                 /* "foo&" */
     273           3 :                 klen = vsep - var->ptr;
     274           3 :                 vlen = 0;
     275             :         }
     276             : 
     277          61 :         php_url_decode(var->ptr, klen);
     278             : 
     279          61 :         val = estrndup(ksep, vlen);
     280          61 :         if (vlen) {
     281          57 :                 vlen = php_url_decode(val, vlen);
     282             :         }
     283             : 
     284          61 :         if (sapi_module.input_filter(PARSE_POST, var->ptr, &val, vlen, &new_vlen TSRMLS_CC)) {
     285           0 :                 php_register_variable_safe(var->ptr, val, new_vlen, arr TSRMLS_CC);
     286             :         }
     287          61 :         efree(val);
     288             : 
     289          61 :         var->ptr = vsep + (vsep != var->end);
     290          61 :         return 1;
     291             : }
     292             : 
     293          64 : static inline int add_post_vars(zval *arr, post_var_data_t *vars, zend_bool eof TSRMLS_DC)
     294             : {
     295          64 :         uint64_t max_vars = PG(max_input_vars);
     296             : 
     297          64 :         vars->ptr = vars->str.s->val;
     298          64 :         vars->end = vars->str.s->val + vars->str.s->len;
     299         189 :         while (add_post_var(arr, vars, eof TSRMLS_CC)) {
     300          61 :                 if (++vars->cnt > max_vars) {
     301           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING,
     302             :                                         "Input variables exceeded %" PRIu64 ". "
     303             :                                         "To increase the limit change max_input_vars in php.ini.",
     304             :                                         max_vars);
     305           0 :                         return FAILURE;
     306             :                 }
     307             :         }
     308             : 
     309          64 :         if (!eof) {
     310          32 :                 memmove(vars->str.s->val, vars->ptr, vars->str.s->len = vars->end - vars->ptr);
     311             :         }
     312          64 :         return SUCCESS;
     313             : }
     314             : 
     315          32 : SAPI_API SAPI_POST_HANDLER_FUNC(php_std_post_handler)
     316             : {
     317          32 :         zval *arr = (zval *) arg;
     318          32 :         php_stream *s = SG(request_info).request_body;
     319             :         post_var_data_t post_data;
     320             : 
     321          32 :         if (s && SUCCESS == php_stream_rewind(s)) {
     322          32 :                 memset(&post_data, 0, sizeof(post_data));
     323             : 
     324          64 :                 while (!php_stream_eof(s)) {
     325          32 :                         char buf[BUFSIZ] = {0};
     326          32 :                         size_t len = php_stream_read(s, buf, BUFSIZ);
     327             : 
     328          32 :                         if (len && len != (size_t) -1) {
     329             :                                 smart_str_appendl(&post_data.str, buf, len);
     330             : 
     331          32 :                                 if (SUCCESS != add_post_vars(arr, &post_data, 0 TSRMLS_CC)) {
     332             :                                         smart_str_free(&post_data.str);
     333           0 :                                         return;
     334             :                                 }
     335             :                         }
     336             : 
     337          32 :                         if (len != BUFSIZ){
     338          32 :                                 break;
     339             :                         }
     340             :                 }
     341             : 
     342          32 :                 if (post_data.str.s) {
     343          32 :                         add_post_vars(arr, &post_data, 1 TSRMLS_CC);
     344             :                         smart_str_free(&post_data.str);
     345             :                 }
     346             :         }
     347             : }
     348             : 
     349           0 : SAPI_API SAPI_INPUT_FILTER_FUNC(php_default_input_filter)
     350             : {
     351             :         /* TODO: check .ini setting here and apply user-defined input filter */
     352           0 :         if(new_val_len) *new_val_len = val_len;
     353           0 :         return 1;
     354             : }
     355             : 
     356       41234 : SAPI_API SAPI_TREAT_DATA_FUNC(php_default_treat_data)
     357             : {
     358       41234 :         char *res = NULL, *var, *val, *separator = NULL;
     359             :         const char *c_var;
     360             :         zval array;
     361       41234 :         int free_buffer = 0;
     362       41234 :         char *strtok_buf = NULL;
     363       41234 :         zend_long count = 0;
     364             :         
     365       41234 :         ZVAL_UNDEF(&array);
     366       41234 :         switch (arg) {
     367             :                 case PARSE_POST:
     368             :                 case PARSE_GET:
     369             :                 case PARSE_COOKIE:
     370       41206 :                         array_init(&array);
     371       41206 :                         switch (arg) {
     372             :                                 case PARSE_POST:
     373          74 :                                         zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_POST]);
     374          74 :                                         ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_POST], &array);
     375          74 :                                         break;
     376             :                                 case PARSE_GET:
     377       20567 :                                         zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_GET]);
     378       20567 :                                         ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_GET], &array);
     379       20567 :                                         break;
     380             :                                 case PARSE_COOKIE:
     381       20565 :                                         zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_COOKIE]);
     382       20565 :                                         ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_COOKIE], &array);
     383             :                                         break;
     384             :                         }
     385       41206 :                         break;
     386             :                 default:
     387          28 :                         ZVAL_COPY_VALUE(&array, destArray);
     388             :                         break;
     389             :         }
     390             : 
     391       41234 :         if (arg == PARSE_POST) {
     392          74 :                 sapi_handle_post(&array TSRMLS_CC);
     393          74 :                 return;
     394             :         }
     395             : 
     396       41160 :         if (arg == PARSE_GET) {         /* GET data */
     397       20567 :                 c_var = SG(request_info).query_string;
     398       20782 :                 if (c_var && *c_var) {
     399         215 :                         res = (char *) estrdup(c_var);
     400         215 :                         free_buffer = 1;
     401             :                 } else {
     402       20352 :                         free_buffer = 0;
     403             :                 }
     404       20593 :         } else if (arg == PARSE_COOKIE) {               /* Cookie data */
     405       20565 :                 c_var = SG(request_info).cookie_data;
     406       20584 :                 if (c_var && *c_var) {
     407          19 :                         res = (char *) estrdup(c_var);
     408          19 :                         free_buffer = 1;
     409             :                 } else {
     410       20546 :                         free_buffer = 0;
     411             :                 }
     412          28 :         } else if (arg == PARSE_STRING) {               /* String data */
     413          28 :                 res = str;
     414          28 :                 free_buffer = 1;
     415             :         }
     416             : 
     417       41160 :         if (!res) {
     418       40898 :                 return;
     419             :         }
     420             : 
     421         262 :         switch (arg) {
     422             :                 case PARSE_GET:
     423             :                 case PARSE_STRING:
     424         243 :                         separator = (char *) estrdup(PG(arg_separator).input);
     425         243 :                         break;
     426             :                 case PARSE_COOKIE:
     427          19 :                         separator = ";\0";
     428             :                         break;
     429             :         }
     430             :         
     431         262 :         var = php_strtok_r(res, separator, &strtok_buf);
     432             :         
     433         860 :         while (var) {
     434         336 :                 val = strchr(var, '=');
     435             : 
     436         336 :                 if (arg == PARSE_COOKIE) {
     437             :                         /* Remove leading spaces from cookie names, needed for multi-cookie header where ; can be followed by a space */
     438          88 :                         while (isspace(*var)) {
     439          10 :                                 var++;
     440             :                         }
     441          39 :                         if (var == val || *var == '\0') {
     442             :                                 goto next_cookie;
     443             :                         }
     444             :                 }
     445             : 
     446         336 :                 if (++count > PG(max_input_vars)) {
     447           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variables exceeded " ZEND_LONG_FMT ". To increase the limit change max_input_vars in php.ini.", PG(max_input_vars));
     448           0 :                         break;
     449             :                 }
     450             : 
     451         336 :                 if (val) { /* have a value */
     452             :                         size_t val_len;
     453             :                         size_t new_val_len;
     454             : 
     455         150 :                         *val++ = '\0';
     456         150 :                         php_url_decode(var, strlen(var));
     457         150 :                         val_len = php_url_decode(val, strlen(val));
     458         150 :                         val = estrndup(val, val_len);
     459         150 :                         if (sapi_module.input_filter(arg, var, &val, val_len, &new_val_len TSRMLS_CC)) {
     460          66 :                                 php_register_variable_safe(var, val, new_val_len, &array TSRMLS_CC);
     461             :                         }
     462         150 :                         efree(val);
     463             :                 } else {
     464             :                         size_t val_len;
     465             :                         size_t new_val_len;
     466             : 
     467         186 :                         php_url_decode(var, strlen(var));
     468         186 :                         val_len = 0;
     469         186 :                         val = estrndup("", val_len);
     470         186 :                         if (sapi_module.input_filter(arg, var, &val, val_len, &new_val_len TSRMLS_CC)) {
     471           0 :                                 php_register_variable_safe(var, val, new_val_len, &array TSRMLS_CC);
     472             :                         }
     473         186 :                         efree(val);
     474             :                 }
     475             : next_cookie:
     476         336 :                 var = php_strtok_r(NULL, separator, &strtok_buf);
     477             :         }
     478             : 
     479         262 :         if (arg != PARSE_COOKIE) {
     480         243 :                 efree(separator);
     481             :         }
     482             : 
     483         262 :         if (free_buffer) {
     484         262 :                 efree(res);
     485             :         }
     486             : }
     487             : 
     488       21744 : void _php_import_environment_variables(zval *array_ptr TSRMLS_DC)
     489             : {
     490             :         char buf[128];
     491       21744 :         char **env, *p, *t = buf;
     492       21744 :         size_t alloc_size = sizeof(buf);
     493             :         unsigned long nlen; /* ptrdiff_t is not portable */
     494             : 
     495     1026076 :         for (env = environ; env != NULL && *env != NULL; env++) {
     496     1004332 :                 p = strchr(*env, '=');
     497     1004332 :                 if (!p) {                               /* malformed entry? */
     498           0 :                         continue;
     499             :                 }
     500     1004332 :                 nlen = p - *env;
     501     1004332 :                 if (nlen >= alloc_size) {
     502           0 :                         alloc_size = nlen + 64;
     503           0 :                         t = (t == buf ? emalloc(alloc_size): erealloc(t, alloc_size));
     504             :                 }
     505     1004332 :                 memcpy(t, *env, nlen);
     506     1004332 :                 t[nlen] = '\0';
     507     1004332 :                 php_register_variable(t, p + 1, array_ptr TSRMLS_CC);
     508             :         }
     509       21744 :         if (t != buf && t != NULL) {
     510           0 :                 efree(t);
     511             :         }
     512       21744 : }
     513             : 
     514           0 : zend_bool php_std_auto_global_callback(char *name, uint name_len TSRMLS_DC)
     515             : {
     516           0 :         zend_printf("%s\n", name);
     517           0 :         return 0; /* don't rearm */
     518             : }
     519             : 
     520             : /* {{{ php_build_argv
     521             :  */
     522       20684 : static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC)
     523             : {
     524             :         zval arr, argc, tmp;
     525       20684 :         int count = 0;
     526             :         char *ss, *space;
     527             :         
     528       20684 :         if (!(SG(request_info).argc || track_vars_array)) {
     529           0 :                 return;
     530             :         }
     531             :         
     532       20684 :         array_init(&arr);
     533             : 
     534             :         /* Prepare argv */
     535       20684 :         if (SG(request_info).argc) { /* are we in cli sapi? */
     536             :                 int i;
     537       40798 :                 for (i = 0; i < SG(request_info).argc; i++) {
     538       40878 :                         ZVAL_STRING(&tmp, SG(request_info).argv[i]);
     539       20439 :                         if (zend_hash_next_index_insert(Z_ARRVAL(arr), &tmp) == NULL) {                             
     540           0 :                                 zend_string_free(Z_STR(tmp));
     541             :                         }
     542             :                 }
     543         325 :         } else  if (s && *s) {
     544          38 :                 ss = s;
     545         125 :                 while (ss) {
     546          49 :                         space = strchr(ss, '+');
     547          49 :                         if (space) {
     548          11 :                                 *space = '\0';
     549             :                         }
     550             :                         /* auto-type */
     551          98 :                         ZVAL_STRING(&tmp, ss);
     552          49 :                         count++;
     553          49 :                         if (zend_hash_next_index_insert(Z_ARRVAL(arr), &tmp) == NULL) {
     554           0 :                                 zend_string_free(Z_STR(tmp));
     555             :                         }
     556          49 :                         if (space) {
     557          11 :                                 *space = '+';
     558          11 :                                 ss = space + 1;
     559             :                         } else {
     560          38 :                                 ss = space;
     561             :                         }
     562             :                 }
     563             :         }
     564             : 
     565             :         /* prepare argc */
     566       20684 :         if (SG(request_info).argc) {
     567       20359 :                 ZVAL_LONG(&argc, SG(request_info).argc);
     568             :         } else {
     569         325 :                 ZVAL_LONG(&argc, count);
     570             :         }
     571             : 
     572       20684 :         if (SG(request_info).argc) {
     573             :                 Z_ADDREF(arr);
     574       20359 :                 zend_hash_str_update(&EG(symbol_table).ht, "argv", sizeof("argv")-1, &arr);
     575       20359 :                 zend_hash_str_add(&EG(symbol_table).ht, "argc", sizeof("argc")-1, &argc);
     576             :         } 
     577       41368 :         if (track_vars_array && Z_TYPE_P(track_vars_array) == IS_ARRAY) {
     578             :                 Z_ADDREF(arr);
     579         107 :                 zend_hash_str_update(Z_ARRVAL_P(track_vars_array), "argv", sizeof("argv")-1, &arr);
     580         107 :                 zend_hash_str_update(Z_ARRVAL_P(track_vars_array), "argc", sizeof("argc")-1, &argc);
     581             :         }
     582       20684 :         zval_ptr_dtor(&arr);
     583             : }
     584             : /* }}} */
     585             : 
     586             : /* {{{ php_register_server_variables
     587             :  */
     588       20283 : static inline void php_register_server_variables(TSRMLS_D)
     589             : {
     590       20283 :         zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_SERVER]);
     591       20283 :         array_init(&PG(http_globals)[TRACK_VARS_SERVER]);
     592             : 
     593             :         /* Server variables */
     594       20283 :         if (sapi_module.register_server_variables) {
     595       20283 :                 sapi_module.register_server_variables(&PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
     596             :         }
     597             : 
     598             :         /* PHP Authentication support */
     599       20283 :         if (SG(request_info).auth_user) {
     600           0 :                 php_register_variable("PHP_AUTH_USER", SG(request_info).auth_user, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
     601             :         }
     602       20283 :         if (SG(request_info).auth_password) {
     603           0 :                 php_register_variable("PHP_AUTH_PW", SG(request_info).auth_password, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
     604             :         }
     605       20283 :         if (SG(request_info).auth_digest) {
     606           0 :                 php_register_variable("PHP_AUTH_DIGEST", SG(request_info).auth_digest, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
     607             :         }
     608             :         /* store request init time */
     609             :         {
     610             :                 zval request_time_float, request_time_long;
     611       20283 :                 ZVAL_DOUBLE(&request_time_float, sapi_get_request_time(TSRMLS_C));
     612       20283 :                 php_register_variable_ex("REQUEST_TIME_FLOAT", &request_time_float, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
     613       40566 :                 ZVAL_LONG(&request_time_long, zend_dval_to_lval(Z_DVAL(request_time_float)));
     614       20283 :                 php_register_variable_ex("REQUEST_TIME", &request_time_long, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
     615             :         }
     616             : 
     617       20283 : }
     618             : /* }}} */
     619             : 
     620             : /* {{{ php_autoglobal_merge
     621             :  */
     622         108 : static void php_autoglobal_merge(HashTable *dest, HashTable *src TSRMLS_DC)
     623             : {
     624             :         zval *src_entry, *dest_entry;
     625             :         zend_string *string_key;
     626             :         zend_ulong num_key;
     627         108 :         int globals_check = (dest == (&EG(symbol_table).ht));
     628             : 
     629         136 :         ZEND_HASH_FOREACH_KEY_VAL(src, num_key, string_key, src_entry) {
     630          29 :                 if (Z_TYPE_P(src_entry) != IS_ARRAY
     631           0 :                         || (string_key && (dest_entry = zend_hash_find(dest, string_key)) == NULL)
     632           1 :                         || (string_key == NULL && (dest_entry = zend_hash_index_find(dest, num_key)) == NULL)
     633             :                         || Z_TYPE_P(dest_entry) != IS_ARRAY) {
     634          14 :                         if (Z_REFCOUNTED_P(src_entry)) {
     635             :                                 Z_ADDREF_P(src_entry);
     636             :                         }
     637          14 :                         if (string_key) {
     638          26 :                                 if (!globals_check || string_key->len != sizeof("GLOBALS") - 1 
     639           0 :                                                 || memcmp(string_key->val, "GLOBALS", sizeof("GLOBALS") - 1)) {
     640          13 :                                         zend_hash_update(dest, string_key, src_entry);
     641           0 :                                 } else if (Z_REFCOUNTED_P(src_entry)) {
     642             :                                         Z_DELREF_P(src_entry);
     643             :                                 }
     644             :                         } else {
     645           1 :                                 zend_hash_index_update(dest, num_key, src_entry);
     646             :                         }
     647             :                 } else {
     648           0 :                         SEPARATE_ZVAL(dest_entry);
     649           0 :                         php_autoglobal_merge(Z_ARRVAL_P(dest_entry), Z_ARRVAL_P(src_entry) TSRMLS_CC);
     650             :                 }
     651             :         } ZEND_HASH_FOREACH_END();
     652         108 : }
     653             : /* }}} */
     654             : 
     655             : /* {{{ php_hash_environment
     656             :  */
     657       20579 : PHPAPI int php_hash_environment(TSRMLS_D)
     658             : {
     659       20579 :         memset(PG(http_globals), 0, sizeof(PG(http_globals)));
     660       20579 :         zend_activate_auto_globals(TSRMLS_C);
     661       20579 :         if (PG(register_argc_argv)) {
     662       20577 :                 php_build_argv(SG(request_info).query_string, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
     663             :         }
     664       20579 :         return SUCCESS;
     665             : }
     666             : /* }}} */
     667             : 
     668       20579 : static zend_bool php_auto_globals_create_get(zend_string *name TSRMLS_DC)
     669             : {
     670       41157 :         if (PG(variables_order) && (strchr(PG(variables_order),'G') || strchr(PG(variables_order),'g'))) {
     671       20578 :                 sapi_module.treat_data(PARSE_GET, NULL, NULL TSRMLS_CC);
     672             :         } else {
     673           1 :                 zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_GET]);
     674           1 :                 array_init(&PG(http_globals)[TRACK_VARS_GET]);
     675             :         }
     676             : 
     677       20579 :         zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_GET]);
     678             :         Z_ADDREF(PG(http_globals)[TRACK_VARS_GET]);
     679             :         
     680       20579 :         return 0; /* don't rearm */
     681             : }
     682             : 
     683       20579 : static zend_bool php_auto_globals_create_post(zend_string *name TSRMLS_DC)
     684             : {
     685       82608 :         if (PG(variables_order) &&
     686       20584 :                         (strchr(PG(variables_order),'P') || strchr(PG(variables_order),'p')) &&
     687       20578 :                 !SG(headers_sent) &&
     688       20577 :                 SG(request_info).request_method &&
     689         212 :                 !strcasecmp(SG(request_info).request_method, "POST")) {
     690          78 :                 sapi_module.treat_data(PARSE_POST, NULL, NULL TSRMLS_CC);
     691             :         } else {
     692       20501 :                 zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_POST]);
     693       20501 :                 array_init(&PG(http_globals)[TRACK_VARS_POST]);
     694             :         }
     695             : 
     696       20579 :         zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_POST]);
     697             :         Z_ADDREF(PG(http_globals)[TRACK_VARS_POST]);
     698             :         
     699       20579 :         return 0; /* don't rearm */
     700             : }
     701             : 
     702       20579 : static zend_bool php_auto_globals_create_cookie(zend_string *name TSRMLS_DC)
     703             : {
     704       41149 :         if (PG(variables_order) && (strchr(PG(variables_order),'C') || strchr(PG(variables_order),'c'))) {
     705       20570 :                 sapi_module.treat_data(PARSE_COOKIE, NULL, NULL TSRMLS_CC);
     706             :         } else {
     707           9 :                 zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_COOKIE]);
     708           9 :                 array_init(&PG(http_globals)[TRACK_VARS_COOKIE]);
     709             :         }
     710             : 
     711       20579 :         zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_COOKIE]);
     712             :         Z_ADDREF(PG(http_globals)[TRACK_VARS_COOKIE]);
     713             :         
     714       20579 :         return 0; /* don't rearm */
     715             : }
     716             : 
     717       20579 : static zend_bool php_auto_globals_create_files(zend_string *name TSRMLS_DC)
     718             : {
     719       20579 :         if (Z_TYPE(PG(http_globals)[TRACK_VARS_FILES]) == IS_UNDEF) {
     720       20545 :                 array_init(&PG(http_globals)[TRACK_VARS_FILES]);
     721             :         }
     722             : 
     723       20579 :         zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_FILES]);
     724             :         Z_ADDREF(PG(http_globals)[TRACK_VARS_FILES]);
     725             :         
     726       20579 :         return 0; /* don't rearm */
     727             : }
     728             : 
     729       20285 : static zend_bool php_auto_globals_create_server(zend_string *name TSRMLS_DC)
     730             : {
     731       40568 :         if (PG(variables_order) && (strchr(PG(variables_order),'S') || strchr(PG(variables_order),'s'))) {
     732       20283 :                 php_register_server_variables(TSRMLS_C);
     733             : 
     734       20283 :                 if (PG(register_argc_argv)) {
     735       20281 :                         if (SG(request_info).argc) {
     736             :                                 zval *argc, *argv;
     737             :         
     738       40348 :                                 if ((argc = zend_hash_str_find(&EG(symbol_table).ht, "argc", sizeof("argc")-1)) != NULL &&
     739       20174 :                                         (argv = zend_hash_str_find(&EG(symbol_table).ht, "argv", sizeof("argv")-1)) != NULL) {
     740             :                                         Z_ADDREF_P(argv);
     741       20174 :                                         zend_hash_str_update(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv")-1, argv);
     742       20174 :                                         zend_hash_str_update(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "argc", sizeof("argc")-1, argc);
     743             :                                 }
     744             :                         } else {
     745         107 :                                 php_build_argv(SG(request_info).query_string, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
     746             :                         }
     747             :                 }
     748             :         
     749             :         } else {
     750           2 :                 zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_SERVER]);
     751           2 :                 array_init(&PG(http_globals)[TRACK_VARS_SERVER]);
     752             :         }
     753             : 
     754       20285 :         zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_SERVER]);
     755             :         Z_ADDREF(PG(http_globals)[TRACK_VARS_SERVER]);
     756             :         
     757       20285 :         return 0; /* don't rearm */
     758             : }
     759             : 
     760        1462 : static zend_bool php_auto_globals_create_env(zend_string *name TSRMLS_DC)
     761             : {
     762        1462 :         zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_ENV]);
     763        1462 :         array_init(&PG(http_globals)[TRACK_VARS_ENV]);
     764             :         
     765        1462 :         if (PG(variables_order) && (strchr(PG(variables_order),'E') || strchr(PG(variables_order),'e'))) {
     766        1461 :                 php_import_environment_variables(&PG(http_globals)[TRACK_VARS_ENV] TSRMLS_CC);
     767             :         }
     768             : 
     769        1462 :         zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_ENV]);
     770             :         Z_ADDREF(PG(http_globals)[TRACK_VARS_ENV]);
     771             : 
     772        1462 :         return 0; /* don't rearm */
     773             : }
     774             : 
     775          36 : static zend_bool php_auto_globals_create_request(zend_string *name TSRMLS_DC)
     776             : {
     777             :         zval form_variables;
     778          36 :         unsigned char _gpc_flags[3] = {0, 0, 0};
     779             :         char *p;
     780             : 
     781          36 :         array_init(&form_variables);
     782             : 
     783          36 :         if (PG(request_order) != NULL) {
     784           0 :                 p = PG(request_order);
     785             :         } else {
     786          36 :                 p = PG(variables_order);
     787             :         }
     788             : 
     789         216 :         for (; p && *p; p++) {
     790         180 :                 switch (*p) {
     791             :                         case 'g':
     792             :                         case 'G':
     793          36 :                                 if (!_gpc_flags[0]) {
     794          36 :                                         php_autoglobal_merge(Z_ARRVAL(form_variables), Z_ARRVAL(PG(http_globals)[TRACK_VARS_GET]) TSRMLS_CC);
     795          36 :                                         _gpc_flags[0] = 1;
     796             :                                 }
     797          36 :                                 break;
     798             :                         case 'p':
     799             :                         case 'P':
     800          36 :                                 if (!_gpc_flags[1]) {
     801          36 :                                         php_autoglobal_merge(Z_ARRVAL(form_variables), Z_ARRVAL(PG(http_globals)[TRACK_VARS_POST]) TSRMLS_CC);
     802          36 :                                         _gpc_flags[1] = 1;
     803             :                                 }
     804          36 :                                 break;
     805             :                         case 'c':
     806             :                         case 'C':
     807          36 :                                 if (!_gpc_flags[2]) {
     808          36 :                                         php_autoglobal_merge(Z_ARRVAL(form_variables), Z_ARRVAL(PG(http_globals)[TRACK_VARS_COOKIE]) TSRMLS_CC);
     809          36 :                                         _gpc_flags[2] = 1;
     810             :                                 }
     811             :                                 break;
     812             :                 }
     813             :         }
     814             : 
     815          36 :         zend_hash_update(&EG(symbol_table).ht, name, &form_variables);
     816          36 :         return 0;
     817             : }
     818             : 
     819       20622 : void php_startup_auto_globals(TSRMLS_D)
     820             : {
     821       20622 :         zend_register_auto_global(zend_string_init("_GET", sizeof("_GET")-1, 1), 0, php_auto_globals_create_get TSRMLS_CC);
     822       20622 :         zend_register_auto_global(zend_string_init("_POST", sizeof("_POST")-1, 1), 0, php_auto_globals_create_post TSRMLS_CC);
     823       20622 :         zend_register_auto_global(zend_string_init("_COOKIE", sizeof("_COOKIE")-1, 1), 0, php_auto_globals_create_cookie TSRMLS_CC);
     824       41244 :         zend_register_auto_global(zend_string_init("_SERVER", sizeof("_SERVER")-1, 1), PG(auto_globals_jit), php_auto_globals_create_server TSRMLS_CC);
     825       41244 :         zend_register_auto_global(zend_string_init("_ENV", sizeof("_ENV")-1, 1), PG(auto_globals_jit), php_auto_globals_create_env TSRMLS_CC);
     826       41244 :         zend_register_auto_global(zend_string_init("_REQUEST", sizeof("_REQUEST")-1, 1), PG(auto_globals_jit), php_auto_globals_create_request TSRMLS_CC);
     827       20622 :         zend_register_auto_global(zend_string_init("_FILES", sizeof("_FILES")-1, 1), 0, php_auto_globals_create_files TSRMLS_CC);
     828       20622 : }
     829             : 
     830             : /*
     831             :  * Local variables:
     832             :  * tab-width: 4
     833             :  * c-basic-offset: 4
     834             :  * End:
     835             :  * vim600: sw=4 ts=4 fdm=marker
     836             :  * vim<600: sw=4 ts=4
     837             :  */

Generated by: LCOV version 1.10

Generated at Sat, 13 Dec 2014 06:16:27 +0000 (6 days ago)

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