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 - Zend - zend_ini.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 202 247 81.8 %
Date: 2014-04-18 Functions: 25 28 89.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend Engine                                                          |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 2.00 of the Zend 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.zend.com/license/2_00.txt.                                |
      11             :    | If you did not receive a copy of the Zend license and are unable to  |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@zend.com so we can mail you a copy immediately.              |
      14             :    +----------------------------------------------------------------------+
      15             :    | Author: Zeev Suraski <zeev@zend.com>                                 |
      16             :    +----------------------------------------------------------------------+
      17             : */
      18             : 
      19             : /* $Id$ */
      20             : 
      21             : #include "zend.h"
      22             : #include "zend_qsort.h"
      23             : #include "zend_API.h"
      24             : #include "zend_ini.h"
      25             : #include "zend_alloc.h"
      26             : #include "zend_operators.h"
      27             : #include "zend_strtod.h"
      28             : 
      29             : static HashTable *registered_zend_ini_directives;
      30             : 
      31             : #define NO_VALUE_PLAINTEXT              "no value"
      32             : #define NO_VALUE_HTML                   "<i>no value</i>"
      33             : 
      34             : /*
      35             :  * hash_apply functions
      36             :  */
      37   106116663 : static int zend_remove_ini_entries(zend_ini_entry *ini_entry, int *module_number TSRMLS_DC) /* {{{ */
      38             : {
      39   106116663 :         if (ini_entry->module_number == *module_number) {
      40     5001720 :                 return 1;
      41             :         } else {
      42   101114943 :                 return 0;
      43             :         }
      44             : }
      45             : /* }}} */
      46             : 
      47       24093 : static int zend_restore_ini_entry_cb(zend_ini_entry *ini_entry, int stage TSRMLS_DC) /* {{{ */
      48             : {
      49       24093 :         int result = FAILURE;
      50             : 
      51       24093 :         if (ini_entry->modified) {
      52       24091 :                 if (ini_entry->on_modify) {
      53       23980 :                         zend_try {
      54             :                         /* even if on_modify bails out, we have to continue on with restoring,
      55             :                                 since there can be allocated variables that would be freed on MM shutdown
      56             :                                 and would lead to memory corruption later ini entry is modified again */
      57       23980 :                                 result = ini_entry->on_modify(ini_entry, ini_entry->orig_value, ini_entry->orig_value_length, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage TSRMLS_CC);
      58       23980 :                         } zend_end_try();
      59             :                 }
      60       24091 :                 if (stage == ZEND_INI_STAGE_RUNTIME && result == FAILURE) {
      61             :                         /* runtime failure is OK */
      62           0 :                         return 1;
      63             :                 }
      64       24091 :                 if (ini_entry->value != ini_entry->orig_value) {
      65       24084 :                         efree(ini_entry->value);
      66             :                 }
      67       24091 :                 ini_entry->value = ini_entry->orig_value;
      68       24091 :                 ini_entry->value_length = ini_entry->orig_value_length;
      69       24091 :                 ini_entry->modifiable = ini_entry->orig_modifiable;
      70       24091 :                 ini_entry->modified = 0;
      71       24091 :                 ini_entry->orig_value = NULL;
      72       24091 :                 ini_entry->orig_value_length = 0;
      73       24091 :                 ini_entry->orig_modifiable = 0;
      74             :         }
      75       24093 :         return 0;
      76             : }
      77             : /* }}} */
      78             : 
      79       24067 : static int zend_restore_ini_entry_wrapper(zend_ini_entry **ini_entry TSRMLS_DC) /* {{{ */
      80             : {
      81       24067 :         zend_restore_ini_entry_cb(*ini_entry, ZEND_INI_STAGE_DEACTIVATE TSRMLS_CC);
      82       24067 :         return 1;
      83             : }
      84             : /* }}} */
      85             : 
      86             : /*
      87             :  * Startup / shutdown
      88             :  */
      89       19341 : ZEND_API int zend_ini_startup(TSRMLS_D) /* {{{ */
      90             : {
      91       19341 :         registered_zend_ini_directives = (HashTable *) malloc(sizeof(HashTable));
      92             : 
      93       19341 :         EG(ini_directives) = registered_zend_ini_directives;
      94       19341 :         EG(modified_ini_directives) = NULL;
      95       19341 :         if (zend_hash_init_ex(registered_zend_ini_directives, 100, NULL, NULL, 1, 0) == FAILURE) {
      96           0 :                 return FAILURE;
      97             :         }
      98       19341 :         return SUCCESS;
      99             : }
     100             : /* }}} */
     101             : 
     102       19376 : ZEND_API int zend_ini_shutdown(TSRMLS_D) /* {{{ */
     103             : {
     104       19376 :         zend_hash_destroy(EG(ini_directives));
     105       19376 :         free(EG(ini_directives));
     106       19376 :         return SUCCESS;
     107             : }
     108             : /* }}} */
     109             : 
     110           0 : ZEND_API int zend_ini_global_shutdown(TSRMLS_D) /* {{{ */
     111             : {
     112           0 :         zend_hash_destroy(registered_zend_ini_directives);
     113           0 :         free(registered_zend_ini_directives);
     114           0 :         return SUCCESS;
     115             : }
     116             : /* }}} */
     117             : 
     118       19376 : ZEND_API int zend_ini_deactivate(TSRMLS_D) /* {{{ */
     119             : {
     120       19376 :         if (EG(modified_ini_directives)) {
     121       19350 :                 zend_hash_apply(EG(modified_ini_directives), (apply_func_t) zend_restore_ini_entry_wrapper TSRMLS_CC);
     122       19350 :                 zend_hash_destroy(EG(modified_ini_directives));
     123       19350 :                 FREE_HASHTABLE(EG(modified_ini_directives));
     124       19350 :                 EG(modified_ini_directives) = NULL;
     125             :         }
     126       19376 :         return SUCCESS;
     127             : }
     128             : /* }}} */
     129             : 
     130             : #ifdef ZTS
     131             : ZEND_API int zend_copy_ini_directives(TSRMLS_D) /* {{{ */
     132             : {
     133             :         zend_ini_entry ini_entry;
     134             : 
     135             :         EG(modified_ini_directives) = NULL;
     136             :         EG(ini_directives) = (HashTable *) malloc(sizeof(HashTable));
     137             :         if (zend_hash_init_ex(EG(ini_directives), registered_zend_ini_directives->nNumOfElements, NULL, NULL, 1, 0) == FAILURE) {
     138             :                 return FAILURE;
     139             :         }
     140             :         zend_hash_copy(EG(ini_directives), registered_zend_ini_directives, NULL, &ini_entry, sizeof(zend_ini_entry));
     141             :         return SUCCESS;
     142             : }
     143             : /* }}} */
     144             : #endif
     145             : 
     146      305796 : static int ini_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ */
     147             : {
     148             :         Bucket *f;
     149             :         Bucket *s;
     150             : 
     151      305796 :         f = *((Bucket **) a);
     152      305796 :         s = *((Bucket **) b);
     153             : 
     154      305796 :         if (f->nKeyLength == 0 && s->nKeyLength == 0) { /* both numeric */
     155           0 :                 return ZEND_NORMALIZE_BOOL(f->nKeyLength - s->nKeyLength);
     156      305796 :         } else if (f->nKeyLength == 0) { /* f is numeric, s is not */
     157           0 :                 return -1;
     158      305796 :         } else if (s->nKeyLength == 0) { /* s is numeric, f is not */
     159           0 :                 return 1;
     160             :         } else { /* both strings */
     161      305796 :                 return zend_binary_strcasecmp(f->arKey, f->nKeyLength, s->arKey, s->nKeyLength);
     162             :         }
     163             : }
     164             : /* }}} */
     165             : 
     166         167 : ZEND_API void zend_ini_sort_entries(TSRMLS_D) /* {{{ */
     167             : {
     168         167 :         zend_hash_sort(EG(ini_directives), zend_qsort, ini_key_compare, 0 TSRMLS_CC);
     169         167 : }
     170             : /* }}} */
     171             : 
     172             : /*
     173             :  * Registration / unregistration
     174             :  */
     175      696618 : ZEND_API int zend_register_ini_entries(const zend_ini_entry *ini_entry, int module_number TSRMLS_DC) /* {{{ */
     176             : {
     177      696618 :         const zend_ini_entry *p = ini_entry;
     178             :         zend_ini_entry *hashed_ini_entry;
     179             :         zval default_value;
     180      696618 :         HashTable *directives = registered_zend_ini_directives;
     181      696618 :         zend_bool config_directive_success = 0;
     182             : 
     183             : #ifdef ZTS
     184             :         /* if we are called during the request, eg: from dl(),
     185             :          * then we should not touch the global directives table,
     186             :          * and should update the per-(request|thread) version instead.
     187             :          * This solves two problems: one is that ini entries for dl()'d
     188             :          * extensions will now work, and the second is that updating the
     189             :          * global hash here from dl() is not mutex protected and can
     190             :          * lead to death.
     191             :          */
     192             :         if (directives != EG(ini_directives)) {
     193             :                 directives = EG(ini_directives);
     194             :         }
     195             : #endif
     196             : 
     197     6443973 :         while (p->name) {
     198     5050737 :                 config_directive_success = 0;
     199     5050737 :                 if (zend_hash_add(directives, p->name, p->name_length, (void*)p, sizeof(zend_ini_entry), (void **) &hashed_ini_entry) == FAILURE) {
     200           0 :                         zend_unregister_ini_entries(module_number TSRMLS_CC);
     201           0 :                         return FAILURE;
     202             :                 }
     203     5050737 :                 hashed_ini_entry->module_number = module_number;
     204     5050737 :                 if ((zend_get_configuration_directive(p->name, p->name_length, &default_value)) == SUCCESS) {
     205     1197721 :                         if (!hashed_ini_entry->on_modify
     206      579599 :                                 || hashed_ini_entry->on_modify(hashed_ini_entry, Z_STRVAL(default_value), Z_STRLEN(default_value), hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC) == SUCCESS) {
     207      618120 :                                 hashed_ini_entry->value = Z_STRVAL(default_value);
     208      618120 :                                 hashed_ini_entry->value_length = Z_STRLEN(default_value);
     209      618120 :                                 config_directive_success = 1;
     210             :                         }
     211             :                 }
     212             : 
     213     5050737 :                 if (!config_directive_success && hashed_ini_entry->on_modify) {
     214     3832887 :                         hashed_ini_entry->on_modify(hashed_ini_entry, hashed_ini_entry->value, hashed_ini_entry->value_length, hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC);
     215             :                 }
     216     5050737 :                 p++;
     217             :         }
     218      696618 :         return SUCCESS;
     219             : }
     220             : /* }}} */
     221             : 
     222      620371 : ZEND_API void zend_unregister_ini_entries(int module_number TSRMLS_DC) /* {{{ */
     223             : {
     224      620371 :         zend_hash_apply_with_argument(registered_zend_ini_directives, (apply_func_arg_t) zend_remove_ini_entries, (void *) &module_number TSRMLS_CC);
     225      620371 : }
     226             : /* }}} */
     227             : 
     228             : #ifdef ZTS
     229             : static int zend_ini_refresh_cache(zend_ini_entry *p, int stage TSRMLS_DC) /* {{{ */
     230             : {
     231             :         if (p->on_modify) {
     232             :                 p->on_modify(p, p->value, p->value_length, p->mh_arg1, p->mh_arg2, p->mh_arg3, stage TSRMLS_CC);
     233             :         }
     234             :         return 0;
     235             : }
     236             : /* }}} */
     237             : 
     238             : ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC) /* {{{ */
     239             : {
     240             :         zend_hash_apply_with_argument(EG(ini_directives), (apply_func_arg_t) zend_ini_refresh_cache, (void *)(zend_intptr_t) stage TSRMLS_CC);
     241             : }
     242             : /* }}} */
     243             : #endif
     244             : 
     245        1117 : ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage) /* {{{ */
     246             : {
     247             :         TSRMLS_FETCH();
     248             : 
     249        1117 :         return zend_alter_ini_entry_ex(name, name_length, new_value, new_value_length, modify_type, stage, 0 TSRMLS_CC);
     250             : }
     251             : /* }}} */
     252             : 
     253     2134177 : ZEND_API int zend_alter_ini_entry_ex(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage, int force_change TSRMLS_DC) /* {{{ */
     254             : {
     255             :         zend_ini_entry *ini_entry;
     256             :         char *duplicate;
     257             :         zend_bool modifiable;
     258             :         zend_bool modified;
     259             : 
     260     2134177 :         if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == FAILURE) {
     261          28 :                 return FAILURE;
     262             :         }
     263             : 
     264     2134149 :         modifiable = ini_entry->modifiable;
     265     2134149 :         modified = ini_entry->modified;
     266             : 
     267     2134149 :         if (stage == ZEND_INI_STAGE_ACTIVATE && modify_type == ZEND_INI_SYSTEM) {
     268       77242 :                 ini_entry->modifiable = ZEND_INI_SYSTEM;
     269             :         }
     270             : 
     271     2134149 :         if (!force_change) {
     272        3491 :                 if (!(ini_entry->modifiable & modify_type)) {
     273          11 :                         return FAILURE;
     274             :                 }
     275             :         }
     276             : 
     277     2134138 :         if (!EG(modified_ini_directives)) {
     278       19315 :                 ALLOC_HASHTABLE(EG(modified_ini_directives));
     279       19315 :                 zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
     280             :         }
     281     2134138 :         if (!modified) {
     282       24053 :                 ini_entry->orig_value = ini_entry->value;
     283       24053 :                 ini_entry->orig_value_length = ini_entry->value_length;
     284       24053 :                 ini_entry->orig_modifiable = modifiable;
     285       24053 :                 ini_entry->modified = 1;
     286       24053 :                 zend_hash_add(EG(modified_ini_directives), name, name_length, &ini_entry, sizeof(zend_ini_entry*), NULL);
     287             :         }
     288             : 
     289     2134138 :         duplicate = estrndup(new_value, new_value_length);
     290             : 
     291     6402288 :         if (!ini_entry->on_modify
     292     2134026 :                 || ini_entry->on_modify(ini_entry, duplicate, new_value_length, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage TSRMLS_CC) == SUCCESS) {
     293     2134124 :                 if (modified && ini_entry->orig_value != ini_entry->value) { /* we already changed the value, free the changed value */
     294     2110078 :                         efree(ini_entry->value);
     295             :                 }
     296     2134124 :                 ini_entry->value = duplicate;
     297     2134124 :                 ini_entry->value_length = new_value_length;
     298             :         } else {
     299          14 :                 efree(duplicate);
     300          14 :                 return FAILURE;
     301             :         }
     302             : 
     303     2134124 :         return SUCCESS;
     304             : }
     305             : /* }}} */
     306             : 
     307          26 : ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage) /* {{{ */
     308             : {
     309             :         zend_ini_entry *ini_entry;
     310             :         TSRMLS_FETCH();
     311             : 
     312          52 :         if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == FAILURE ||
     313          26 :                 (stage == ZEND_INI_STAGE_RUNTIME && (ini_entry->modifiable & ZEND_INI_USER) == 0)) {
     314           0 :                 return FAILURE;
     315             :         }
     316             : 
     317          26 :         if (EG(modified_ini_directives)) {
     318          26 :                 if (zend_restore_ini_entry_cb(ini_entry, stage TSRMLS_CC) == 0) {
     319          26 :                         zend_hash_del(EG(modified_ini_directives), name, name_length);
     320             :                 } else {
     321           0 :                         return FAILURE;
     322             :                 }
     323             :         }
     324             : 
     325          26 :         return SUCCESS;
     326             : }
     327             : /* }}} */
     328             : 
     329           0 : ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type)) /* {{{ */
     330             : {
     331             :         zend_ini_entry *ini_entry;
     332             : 
     333           0 :         if (zend_hash_find(registered_zend_ini_directives, name, name_length, (void **) &ini_entry) == FAILURE) {
     334           0 :                 return FAILURE;
     335             :         }
     336             : 
     337           0 :         ini_entry->displayer = displayer;
     338           0 :         return SUCCESS;
     339             : }
     340             : /* }}} */
     341             : 
     342             : /*
     343             :  * Data retrieval
     344             :  */
     345             : 
     346       58704 : ZEND_API long zend_ini_long(char *name, uint name_length, int orig) /* {{{ */
     347             : {
     348             :         zend_ini_entry *ini_entry;
     349             :         TSRMLS_FETCH();
     350             : 
     351       58704 :         if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == SUCCESS) {
     352       58704 :                 if (orig && ini_entry->modified) {
     353           0 :                         return (ini_entry->orig_value ? strtol(ini_entry->orig_value, NULL, 0) : 0);
     354             :                 } else {
     355       58704 :                         return (ini_entry->value      ? strtol(ini_entry->value, NULL, 0)      : 0);
     356             :                 }
     357             :         }
     358             : 
     359           0 :         return 0;
     360             : }
     361             : /* }}} */
     362             : 
     363          48 : ZEND_API double zend_ini_double(char *name, uint name_length, int orig) /* {{{ */
     364             : {
     365             :         zend_ini_entry *ini_entry;
     366             :         TSRMLS_FETCH();
     367             : 
     368          48 :         if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == SUCCESS) {
     369          48 :                 if (orig && ini_entry->modified) {
     370           0 :                         return (double) (ini_entry->orig_value ? zend_strtod(ini_entry->orig_value, NULL) : 0.0);
     371             :                 } else {
     372          48 :                         return (double) (ini_entry->value      ? zend_strtod(ini_entry->value, NULL)      : 0.0);
     373             :                 }
     374             :         }
     375             : 
     376           0 :         return 0.0;
     377             : }
     378             : /* }}} */
     379             : 
     380      161176 : ZEND_API char *zend_ini_string_ex(char *name, uint name_length, int orig, zend_bool *exists) /* {{{ */
     381             : {
     382             :         zend_ini_entry *ini_entry;
     383             :         TSRMLS_FETCH();
     384             : 
     385      161176 :         if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == SUCCESS) {
     386      161140 :                 if (exists) {
     387       60890 :                         *exists = 1;
     388             :                 }
     389             : 
     390      161140 :                 if (orig && ini_entry->modified) {
     391           0 :                         return ini_entry->orig_value;
     392             :                 } else {
     393      161140 :                         return ini_entry->value;
     394             :                 }
     395             :         } else {
     396          36 :                 if (exists) {
     397          36 :                         *exists = 0;
     398             :                 }
     399          36 :                 return NULL;
     400             :         }
     401             : }
     402             : /* }}} */
     403             : 
     404       60926 : ZEND_API char *zend_ini_string(char *name, uint name_length, int orig) /* {{{ */
     405             : {
     406       60926 :         zend_bool exists = 1;
     407             :         char *return_value;
     408             : 
     409       60926 :         return_value = zend_ini_string_ex(name, name_length, orig, &exists);
     410       60926 :         if (!exists) {
     411          36 :                 return NULL;
     412       60890 :         } else if (!return_value) {
     413       39906 :                 return_value = "";
     414             :         }
     415       60890 :         return return_value;
     416             : }
     417             : /* }}} */
     418             : 
     419             : #if TONY_20070307
     420             : static void zend_ini_displayer_cb(zend_ini_entry *ini_entry, int type) /* {{{ */
     421             : {
     422             :         if (ini_entry->displayer) {
     423             :                 ini_entry->displayer(ini_entry, type);
     424             :         } else {
     425             :                 char *display_string;
     426             :                 uint display_string_length;
     427             : 
     428             :                 if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     429             :                         if (ini_entry->orig_value) {
     430             :                                 display_string = ini_entry->orig_value;
     431             :                                 display_string_length = ini_entry->orig_value_length;
     432             :                         } else {
     433             :                                 if (zend_uv.html_errors) {
     434             :                                         display_string = NO_VALUE_HTML;
     435             :                                         display_string_length = sizeof(NO_VALUE_HTML) - 1;
     436             :                                 } else {
     437             :                                         display_string = NO_VALUE_PLAINTEXT;
     438             :                                         display_string_length = sizeof(NO_VALUE_PLAINTEXT) - 1;
     439             :                                 }
     440             :                         }
     441             :                 } else if (ini_entry->value && ini_entry->value[0]) {
     442             :                         display_string = ini_entry->value;
     443             :                         display_string_length = ini_entry->value_length;
     444             :                 } else {
     445             :                         if (zend_uv.html_errors) {
     446             :                                 display_string = NO_VALUE_HTML;
     447             :                                 display_string_length = sizeof(NO_VALUE_HTML) - 1;
     448             :                         } else {
     449             :                                 display_string = NO_VALUE_PLAINTEXT;
     450             :                                 display_string_length = sizeof(NO_VALUE_PLAINTEXT) - 1;
     451             :                         }
     452             :                 }
     453             :                 ZEND_WRITE(display_string, display_string_length);
     454             :         }
     455             : }
     456             : /* }}} */
     457             : #endif
     458             : 
     459       18944 : ZEND_INI_DISP(zend_ini_boolean_displayer_cb) /* {{{ */
     460             : {
     461             :         int value, tmp_value_len;
     462             :         char *tmp_value;
     463             : 
     464       19192 :         if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     465         248 :                 tmp_value = (ini_entry->orig_value ? ini_entry->orig_value : NULL );
     466         248 :                 tmp_value_len = ini_entry->orig_value_length;
     467       18696 :         } else if (ini_entry->value) {
     468       18696 :                 tmp_value = ini_entry->value;
     469       18696 :                 tmp_value_len = ini_entry->value_length;
     470             :         } else {
     471           0 :                 tmp_value = NULL;
     472           0 :                 tmp_value_len = 0;
     473             :         }
     474             : 
     475       18944 :         if (tmp_value) {
     476       18944 :                 if (tmp_value_len == 4 && strcasecmp(tmp_value, "true") == 0) {
     477           0 :                         value = 1;
     478       18944 :                 } else if (tmp_value_len == 3 && strcasecmp(tmp_value, "yes") == 0) {
     479           0 :                         value = 1;
     480       18944 :                 } else if (tmp_value_len == 2 && strcasecmp(tmp_value, "on") == 0) {
     481           0 :                         value = 1;
     482             :                 } else {
     483       18944 :                         value = atoi(tmp_value);
     484             :                 }
     485             :         } else {
     486           0 :                 value = 0;
     487             :         }
     488             : 
     489       18944 :         if (value) {
     490        9172 :                 ZEND_PUTS("On");
     491             :         } else {
     492        9772 :                 ZEND_PUTS("Off");
     493             :         }
     494       18944 : }
     495             : /* }}} */
     496             : 
     497        1776 : ZEND_INI_DISP(zend_ini_color_displayer_cb) /* {{{ */
     498             : {
     499             :         char *value;
     500             : 
     501        1776 :         if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     502           0 :                 value = ini_entry->orig_value;
     503        1776 :         } else if (ini_entry->value) {
     504        1776 :                 value = ini_entry->value;
     505             :         } else {
     506           0 :                 value = NULL;
     507             :         }
     508        1776 :         if (value) {
     509        1776 :                 if (zend_uv.html_errors) {
     510        1776 :                         zend_printf("<font style=\"color: %s\">%s</font>", value, value);
     511             :                 } else {
     512           0 :                         ZEND_PUTS(value);
     513             :                 }
     514             :         } else {
     515           0 :                 if (zend_uv.html_errors) {
     516           0 :                         ZEND_PUTS(NO_VALUE_HTML);
     517             :                 } else {
     518           0 :                         ZEND_PUTS(NO_VALUE_PLAINTEXT);
     519             :                 }
     520             :         }
     521        1776 : }
     522             : /* }}} */
     523             : 
     524        3848 : ZEND_INI_DISP(display_link_numbers) /* {{{ */
     525             : {
     526             :         char *value;
     527             : 
     528        3848 :         if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     529           0 :                 value = ini_entry->orig_value;
     530        3848 :         } else if (ini_entry->value) {
     531        3848 :                 value = ini_entry->value;
     532             :         } else {
     533           0 :                 value = NULL;
     534             :         }
     535             : 
     536        3848 :         if (value) {
     537        3848 :                 if (atoi(value) == -1) {
     538        3242 :                         ZEND_PUTS("Unlimited");
     539             :                 } else {
     540         606 :                         zend_printf("%s", value);
     541             :                 }
     542             :         }
     543        3848 : }
     544             : /* }}} */
     545             : 
     546             : /* Standard message handlers */
     547     1105441 : ZEND_API ZEND_INI_MH(OnUpdateBool) /* {{{ */
     548             : {
     549             :         zend_bool *p;
     550             : #ifndef ZTS
     551     1105441 :         char *base = (char *) mh_arg2;
     552             : #else
     553             :         char *base;
     554             : 
     555             :         base = (char *) ts_resource(*((int *) mh_arg2));
     556             : #endif
     557             : 
     558     1105441 :         p = (zend_bool *) (base+(size_t) mh_arg1);
     559             : 
     560     1105441 :         if (new_value_length == 2 && strcasecmp("on", new_value) == 0) {
     561           0 :                 *p = (zend_bool) 1;
     562             :         }
     563     1105441 :         else if (new_value_length == 3 && strcasecmp("yes", new_value) == 0) {
     564           0 :                 *p = (zend_bool) 1;
     565             :         }
     566     1105441 :         else if (new_value_length == 4 && strcasecmp("true", new_value) == 0) {
     567           0 :                 *p = (zend_bool) 1;
     568             :         }
     569             :         else {
     570     1105441 :                 *p = (zend_bool) atoi(new_value);
     571             :         }
     572     1105441 :         return SUCCESS;
     573             : }
     574             : /* }}} */
     575             : 
     576     1470187 : ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */
     577             : {
     578             :         long *p;
     579             : #ifndef ZTS
     580     1470187 :         char *base = (char *) mh_arg2;
     581             : #else
     582             :         char *base;
     583             : 
     584             :         base = (char *) ts_resource(*((int *) mh_arg2));
     585             : #endif
     586             : 
     587     1470187 :         p = (long *) (base+(size_t) mh_arg1);
     588             : 
     589     1470187 :         *p = zend_atol(new_value, new_value_length);
     590     1470187 :         return SUCCESS;
     591             : }
     592             : /* }}} */
     593             : 
     594       77366 : ZEND_API ZEND_INI_MH(OnUpdateLongGEZero) /* {{{ */
     595             : {
     596             :         long *p, tmp;
     597             : #ifndef ZTS
     598       77366 :         char *base = (char *) mh_arg2;
     599             : #else
     600             :         char *base;
     601             : 
     602             :         base = (char *) ts_resource(*((int *) mh_arg2));
     603             : #endif
     604             : 
     605       77366 :         tmp = zend_atol(new_value, new_value_length);
     606       77366 :         if (tmp < 0) {
     607           2 :                 return FAILURE;
     608             :         }
     609             : 
     610       77364 :         p = (long *) (base+(size_t) mh_arg1);
     611       77364 :         *p = tmp;
     612             : 
     613       77364 :         return SUCCESS;
     614             : }
     615             : /* }}} */
     616             : 
     617           0 : ZEND_API ZEND_INI_MH(OnUpdateReal) /* {{{ */
     618             : {
     619             :         double *p;
     620             : #ifndef ZTS
     621           0 :         char *base = (char *) mh_arg2;
     622             : #else
     623             :         char *base;
     624             : 
     625             :         base = (char *) ts_resource(*((int *) mh_arg2));
     626             : #endif
     627             : 
     628           0 :         p = (double *) (base+(size_t) mh_arg1);
     629             : 
     630           0 :         *p = zend_strtod(new_value, NULL);
     631           0 :         return SUCCESS;
     632             : }
     633             : /* }}} */
     634             : 
     635     1045344 : ZEND_API ZEND_INI_MH(OnUpdateString) /* {{{ */
     636             : {
     637             :         char **p;
     638             : #ifndef ZTS
     639     1045344 :         char *base = (char *) mh_arg2;
     640             : #else
     641             :         char *base;
     642             : 
     643             :         base = (char *) ts_resource(*((int *) mh_arg2));
     644             : #endif
     645             : 
     646     1045344 :         p = (char **) (base+(size_t) mh_arg1);
     647             : 
     648     1045344 :         *p = new_value;
     649     1045344 :         return SUCCESS;
     650             : }
     651             : /* }}} */
     652             : 
     653      215118 : ZEND_API ZEND_INI_MH(OnUpdateStringUnempty) /* {{{ */
     654             : {
     655             :         char **p;
     656             : #ifndef ZTS
     657      215118 :         char *base = (char *) mh_arg2;
     658             : #else
     659             :         char *base;
     660             : 
     661             :         base = (char *) ts_resource(*((int *) mh_arg2));
     662             : #endif
     663             : 
     664      215118 :         if (new_value && !new_value[0]) {
     665           4 :                 return FAILURE;
     666             :         }
     667             : 
     668      215114 :         p = (char **) (base+(size_t) mh_arg1);
     669             : 
     670      215114 :         *p = new_value;
     671      215114 :         return SUCCESS;
     672             : }
     673             : /* }}} */
     674             : 
     675             : /*
     676             :  * Local variables:
     677             :  * tab-width: 4
     678             :  * c-basic-offset: 4
     679             :  * indent-tabs-mode: t
     680             :  * End:
     681             :  */

Generated by: LCOV version 1.10

Generated at Fri, 18 Apr 2014 07:01:23 +0000 (7 days ago)

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