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: 373 416 89.7 %
Date: 2016-07-26 Functions: 21 23 91.3 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Tue, 26 Jul 2016 17:07:50 +0000 (2 days ago)

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