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: 207 248 83.5 %
Date: 2014-08-30 Functions: 26 28 92.9 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Sun, 31 Aug 2014 02:21:37 +0000 (2 days ago)

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