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: 230 273 84.2 %
Date: 2014-12-13 Functions: 29 31 93.5 %
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   102246691 : static int zend_remove_ini_entries(zval *el, void *arg TSRMLS_DC) /* {{{ */
      38             : {
      39   102246691 :         zend_ini_entry *ini_entry = (zend_ini_entry *)Z_PTR_P(el);
      40   102246691 :         int module_number = *(int *)arg;
      41   102246691 :         if (ini_entry->module_number == module_number) {
      42     5493492 :                 return 1;
      43             :         } else {
      44    96753199 :                 return 0;
      45             :         }
      46             : }
      47             : /* }}} */
      48             : 
      49        4983 : static int zend_restore_ini_entry_cb(zend_ini_entry *ini_entry, int stage TSRMLS_DC) /* {{{ */
      50             : {
      51        4983 :         int result = FAILURE;
      52             : 
      53        4983 :         if (ini_entry->modified) {
      54        4982 :                 if (ini_entry->on_modify) {
      55        4919 :                         zend_try {
      56             :                         /* even if on_modify bails out, we have to continue on with restoring,
      57             :                                 since there can be allocated variables that would be freed on MM shutdown
      58             :                                 and would lead to memory corruption later ini entry is modified again */
      59        4919 :                                 result = ini_entry->on_modify(ini_entry, ini_entry->orig_value, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage TSRMLS_CC);
      60        4919 :                         } zend_end_try();
      61             :                 }
      62        4982 :                 if (stage == ZEND_INI_STAGE_RUNTIME && result == FAILURE) {
      63             :                         /* runtime failure is OK */
      64           0 :                         return 1;
      65             :                 }
      66        4982 :                 if (ini_entry->value != ini_entry->orig_value) {
      67        2655 :                         zend_string_release(ini_entry->value);
      68             :                 }
      69        4982 :                 ini_entry->value = ini_entry->orig_value;
      70        4982 :                 ini_entry->modifiable = ini_entry->orig_modifiable;
      71        4982 :                 ini_entry->modified = 0;
      72        4982 :                 ini_entry->orig_value = NULL;
      73        4982 :                 ini_entry->orig_modifiable = 0;
      74             :         }
      75        4983 :         return 0;
      76             : }
      77             : /* }}} */
      78             : 
      79        4958 : static int zend_restore_ini_entry_wrapper(zval *el TSRMLS_DC) /* {{{ */
      80             : {
      81        4958 :         zend_ini_entry *ini_entry = (zend_ini_entry *)Z_PTR_P(el);
      82        4958 :         zend_restore_ini_entry_cb(ini_entry, ZEND_INI_STAGE_DEACTIVATE TSRMLS_CC);
      83        4958 :         return 1;
      84             : }
      85             : /* }}} */
      86             : 
      87     5576116 : static void free_ini_entry(zval *zv) /* {{{ */
      88             : {
      89     5576116 :         zend_ini_entry *entry = (zend_ini_entry*)Z_PTR_P(zv);
      90             : 
      91     5576116 :         zend_string_release(entry->name);
      92     5576116 :         if (entry->value) {
      93     4562711 :                 zend_string_release(entry->value);
      94             :         }
      95     5576116 :         if (entry->orig_value) {
      96           0 :                 zend_string_release(entry->orig_value);
      97             :         }
      98     5576116 :         free(entry);
      99     5576116 : }
     100             : /* }}} */
     101             : 
     102             : /*
     103             :  * Startup / shutdown
     104             :  */
     105       20622 : ZEND_API int zend_ini_startup(TSRMLS_D) /* {{{ */
     106             : {
     107       20622 :         registered_zend_ini_directives = (HashTable *) malloc(sizeof(HashTable));
     108             : 
     109       20622 :         EG(ini_directives) = registered_zend_ini_directives;
     110       20622 :         EG(modified_ini_directives) = NULL;
     111       20622 :         EG(error_reporting_ini_entry) = NULL;
     112       20622 :         zend_hash_init_ex(registered_zend_ini_directives, 128, NULL, free_ini_entry, 1, 0);
     113       20622 :         return SUCCESS;
     114             : }
     115             : /* }}} */
     116             : 
     117       20656 : ZEND_API int zend_ini_shutdown(TSRMLS_D) /* {{{ */
     118             : {
     119       20656 :         zend_hash_destroy(EG(ini_directives));
     120       20656 :         free(EG(ini_directives));
     121       20656 :         return SUCCESS;
     122             : }
     123             : /* }}} */
     124             : 
     125           0 : ZEND_API int zend_ini_global_shutdown(TSRMLS_D) /* {{{ */
     126             : {
     127           0 :         zend_hash_destroy(registered_zend_ini_directives);
     128           0 :         free(registered_zend_ini_directives);
     129           0 :         return SUCCESS;
     130             : }
     131             : /* }}} */
     132             : 
     133       20629 : ZEND_API int zend_ini_deactivate(TSRMLS_D) /* {{{ */
     134             : {
     135       20629 :         if (EG(modified_ini_directives)) {
     136        3879 :                 zend_hash_apply(EG(modified_ini_directives), zend_restore_ini_entry_wrapper TSRMLS_CC);
     137        3879 :                 zend_hash_destroy(EG(modified_ini_directives));
     138        3879 :                 FREE_HASHTABLE(EG(modified_ini_directives));
     139        3879 :                 EG(modified_ini_directives) = NULL;
     140             :         }
     141       20629 :         return SUCCESS;
     142             : }
     143             : /* }}} */
     144             : 
     145             : #ifdef ZTS
     146             : static void copy_ini_entry(zval *zv) /* {{{ */
     147             : {
     148             :         zend_ini_entry *old_entry = (zend_ini_entry*)Z_PTR_P(zv);
     149             :         zend_ini_entry *new_entry = pemalloc(sizeof(zend_ini_entry), 1);
     150             : 
     151             :         Z_PTR_P(zv) = new_entry;
     152             :         memcpy(new_entry, old_entry, sizeof(zend_ini_entry));
     153             :         if (old_entry->name) {
     154             :                 new_entry->name = zend_string_init(old_entry->name->val, old_entry->name->len, 1);
     155             :         }
     156             :         if (old_entry->value) {
     157             :                 new_entry->value = zend_string_init(old_entry->value->val, old_entry->value->len, 1);
     158             :         }
     159             :         if (old_entry->orig_value) {
     160             :                 new_entry->orig_value = zend_string_init(old_entry->orig_value->val, old_entry->orig_value->len, 1);
     161             :         }
     162             : }
     163             : /* }}} */
     164             : 
     165             : ZEND_API int zend_copy_ini_directives(TSRMLS_D) /* {{{ */
     166             : {
     167             :         EG(modified_ini_directives) = NULL;
     168             :         EG(error_reporting_ini_entry) = NULL;
     169             :         EG(ini_directives) = (HashTable *) malloc(sizeof(HashTable));
     170             :         zend_hash_init_ex(EG(ini_directives), registered_zend_ini_directives->nNumOfElements, NULL, free_ini_entry, 1, 0);
     171             :         zend_hash_copy(EG(ini_directives), registered_zend_ini_directives, copy_ini_entry);
     172             :         return SUCCESS;
     173             : }
     174             : /* }}} */
     175             : #endif
     176             : 
     177      331544 : static int ini_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ */
     178             : {
     179             :         const Bucket *f;
     180             :         const Bucket *s;
     181             : 
     182      331544 :         f = (const Bucket *) a;
     183      331544 :         s = (const Bucket *) b;
     184             : 
     185      331544 :         if (!f->key && !s->key) { /* both numeric */
     186           0 :                 return ZEND_NORMALIZE_BOOL(f->h - s->h);
     187      331544 :         } else if (!f->key) { /* f is numeric, s is not */
     188           0 :                 return -1;
     189      331544 :         } else if (!s->key) { /* s is numeric, f is not */
     190           0 :                 return 1;
     191             :         } else { /* both strings */
     192      331544 :                 return zend_binary_strcasecmp(f->key->val, f->key->len, s->key->val, s->key->len);
     193             :         }
     194             : }
     195             : /* }}} */
     196             : 
     197         163 : ZEND_API void zend_ini_sort_entries(TSRMLS_D) /* {{{ */
     198             : {
     199         163 :         zend_hash_sort(EG(ini_directives), zend_qsort, ini_key_compare, 0 TSRMLS_CC);
     200         163 : }
     201             : /* }}} */
     202             : 
     203             : /*
     204             :  * Registration / unregistration
     205             :  */
     206      722015 : ZEND_API int zend_register_ini_entries(const zend_ini_entry_def *ini_entry, int module_number TSRMLS_DC) /* {{{ */
     207             : {
     208             :         zend_ini_entry *p;
     209             :         zval *default_value;
     210      722015 :         HashTable *directives = registered_zend_ini_directives;
     211             : 
     212             : #ifdef ZTS
     213             :         /* if we are called during the request, eg: from dl(),
     214             :          * then we should not touch the global directives table,
     215             :          * and should update the per-(request|thread) version instead.
     216             :          * This solves two problems: one is that ini entries for dl()'d
     217             :          * extensions will now work, and the second is that updating the
     218             :          * global hash here from dl() is not mutex protected and can
     219             :          * lead to death.
     220             :          */
     221             :         if (directives != EG(ini_directives)) {
     222             :                 directives = EG(ini_directives);
     223             :         }
     224             : #endif
     225             : 
     226     7010909 :         while (ini_entry->name) {
     227     5566879 :                 p = pemalloc(sizeof(zend_ini_entry), 1);
     228    11133758 :                 p->name = zend_string_init(ini_entry->name, ini_entry->name_length, 1);
     229     5566879 :                 p->on_modify = ini_entry->on_modify;
     230     5566879 :                 p->mh_arg1 = ini_entry->mh_arg1;
     231     5566879 :                 p->mh_arg2 = ini_entry->mh_arg2;
     232     5566879 :                 p->mh_arg3 = ini_entry->mh_arg3;
     233     5566879 :                 p->value = NULL;
     234     5566879 :                 p->orig_value = NULL;
     235     5566879 :                 p->displayer = ini_entry->displayer;
     236     5566879 :                 p->modifiable = ini_entry->modifiable;
     237             : 
     238     5566879 :                 p->orig_modifiable = 0;
     239     5566879 :                 p->modified = 0;
     240     5566879 :                 p->module_number = module_number;
     241             : 
     242    11133758 :                 if (zend_hash_add_ptr(directives, p->name, (void*)p) == NULL) {
     243           0 :                         if (p->name) {
     244           0 :                                 zend_string_release(p->name);
     245             :                         }
     246           0 :                         zend_unregister_ini_entries(module_number TSRMLS_CC);
     247           0 :                         return FAILURE;
     248             :                 }
     249     7583699 :                 if (((default_value = zend_get_configuration_directive(p->name)) != NULL) &&
     250     1337705 :             (!p->on_modify || p->on_modify(p, Z_STR_P(default_value), p->mh_arg1, p->mh_arg2, p->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC) == SUCCESS)) {
     251             :                         
     252     1358230 :                         p->value = zend_string_copy(Z_STR_P(default_value));
     253             :                 } else {
     254     8763765 :                         p->value = ini_entry->value ?
     255     3876001 :                                 zend_string_init(ini_entry->value, ini_entry->value_length, 1) : NULL;
     256             : 
     257     4887764 :                         if (p->on_modify) {
     258     4269029 :                                 p->on_modify(p, p->value, p->mh_arg1, p->mh_arg2, p->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC);
     259             :                         }
     260             :                 }
     261     5566879 :                 ini_entry++;
     262             :         }
     263      722015 :         return SUCCESS;
     264             : }
     265             : /* }}} */
     266             : 
     267      619925 : ZEND_API void zend_unregister_ini_entries(int module_number TSRMLS_DC) /* {{{ */
     268             : {
     269      619925 :         zend_hash_apply_with_argument(registered_zend_ini_directives, zend_remove_ini_entries, (void *) &module_number TSRMLS_CC);
     270      619925 : }
     271             : /* }}} */
     272             : 
     273             : #ifdef ZTS
     274             : static int zend_ini_refresh_cache(zval *el, void *arg TSRMLS_DC) /* {{{ */
     275             : {
     276             :         zend_ini_entry *p = (zend_ini_entry *)Z_PTR_P(el);
     277             :         int stage = (int)(zend_intptr_t)arg;
     278             : 
     279             :         if (p->on_modify) {
     280             :                 p->on_modify(p, p->value, p->mh_arg1, p->mh_arg2, p->mh_arg3, stage TSRMLS_CC);
     281             :         }
     282             :         return 0;
     283             : }
     284             : /* }}} */
     285             : 
     286             : ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC) /* {{{ */
     287             : {
     288             :         zend_hash_apply_with_argument(EG(ini_directives), zend_ini_refresh_cache, (void *)(zend_intptr_t) stage TSRMLS_CC);
     289             : }
     290             : /* }}} */
     291             : #endif
     292             : 
     293        1112 : ZEND_API int zend_alter_ini_entry(zend_string *name, zend_string *new_value, int modify_type, int stage) /* {{{ */
     294             : {
     295             :         TSRMLS_FETCH();
     296             : 
     297        1112 :         return zend_alter_ini_entry_ex(name, new_value, modify_type, stage, 0 TSRMLS_CC);
     298             : }
     299             : /* }}} */
     300             : 
     301         385 : ZEND_API int zend_alter_ini_entry_chars(zend_string *name, const char *value, size_t value_length, int modify_type, int stage) /* {{{ */
     302             : {
     303             :     int ret;
     304             :     zend_string *new_value;
     305             :         TSRMLS_FETCH();
     306             : 
     307         770 :         new_value = zend_string_init(value, value_length, stage != ZEND_INI_STAGE_RUNTIME);
     308         385 :         ret = zend_alter_ini_entry_ex(name, new_value, modify_type, stage, 0 TSRMLS_CC);
     309             :         zend_string_release(new_value);
     310         385 :         return ret;
     311             : }
     312             : /* }}} */
     313             : 
     314          18 : ZEND_API int zend_alter_ini_entry_chars_ex(zend_string *name, const char *value, size_t value_length, int modify_type, int stage, int force_change TSRMLS_DC) /* {{{ */
     315             : {
     316             :     int ret;
     317             :     zend_string *new_value;
     318             : 
     319          36 :         new_value = zend_string_init(value, value_length, stage != ZEND_INI_STAGE_RUNTIME);
     320          18 :         ret = zend_alter_ini_entry_ex(name, new_value, modify_type, stage, force_change TSRMLS_CC);
     321             :         zend_string_release(new_value);
     322          18 :         return ret;
     323             : }
     324             : /* }}} */
     325             : 
     326        4145 : ZEND_API int zend_alter_ini_entry_ex(zend_string *name, zend_string *new_value, int modify_type, int stage, int force_change TSRMLS_DC) /* {{{ */
     327             : {
     328             :         zend_ini_entry *ini_entry;
     329             :         zend_string *duplicate;
     330             :         zend_bool modifiable;
     331             :         zend_bool modified;
     332             : 
     333        8290 :         if ((ini_entry = zend_hash_find_ptr(EG(ini_directives), name)) == NULL) {
     334           0 :                 return FAILURE;
     335             :         }
     336             : 
     337        4145 :         modifiable = ini_entry->modifiable;
     338        4145 :         modified = ini_entry->modified;
     339             : 
     340        4145 :         if (stage == ZEND_INI_STAGE_ACTIVATE && modify_type == ZEND_INI_SYSTEM) {
     341           0 :                 ini_entry->modifiable = ZEND_INI_SYSTEM;
     342             :         }
     343             : 
     344        4145 :         if (!force_change) {
     345        4145 :                 if (!(ini_entry->modifiable & modify_type)) {
     346           1 :                         return FAILURE;
     347             :                 }
     348             :         }
     349             : 
     350        4144 :         if (!EG(modified_ini_directives)) {
     351        2239 :                 ALLOC_HASHTABLE(EG(modified_ini_directives));
     352        2239 :                 zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
     353             :         }
     354        4144 :         if (!modified) {
     355        2658 :                 ini_entry->orig_value = ini_entry->value;
     356        2658 :                 ini_entry->orig_modifiable = modifiable;
     357        2658 :                 ini_entry->modified = 1;
     358        2658 :                 zend_hash_add_ptr(EG(modified_ini_directives), name, ini_entry);
     359             :         }
     360             : 
     361        4144 :         duplicate = zend_string_copy(new_value);
     362             : 
     363       12333 :         if (!ini_entry->on_modify
     364        4079 :                 || ini_entry->on_modify(ini_entry, duplicate, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage TSRMLS_CC) == SUCCESS) {
     365        4110 :                 if (modified && ini_entry->orig_value != ini_entry->value) { /* we already changed the value, free the changed value */
     366        1457 :                         zend_string_release(ini_entry->value);
     367             :                 }
     368        4110 :                 ini_entry->value = duplicate;
     369             :         } else {
     370             :                 zend_string_release(duplicate);
     371          34 :                 return FAILURE;
     372             :         }
     373             : 
     374        4110 :         return SUCCESS;
     375             : }
     376             : /* }}} */
     377             : 
     378          26 : ZEND_API int zend_restore_ini_entry(zend_string *name, int stage) /* {{{ */
     379             : {
     380             :         zend_ini_entry *ini_entry;
     381             :         TSRMLS_FETCH();
     382             : 
     383          78 :         if ((ini_entry = zend_hash_find_ptr(EG(ini_directives), name)) == NULL ||
     384          26 :                 (stage == ZEND_INI_STAGE_RUNTIME && (ini_entry->modifiable & ZEND_INI_USER) == 0)) {
     385           0 :                 return FAILURE;
     386             :         }
     387             : 
     388          26 :         if (EG(modified_ini_directives)) {
     389          25 :                 if (zend_restore_ini_entry_cb(ini_entry, stage TSRMLS_CC) == 0) {
     390          25 :                         zend_hash_del(EG(modified_ini_directives), name);
     391             :                 } else {
     392           0 :                         return FAILURE;
     393             :                 }
     394             :         }
     395             : 
     396          26 :         return SUCCESS;
     397             : }
     398             : /* }}} */
     399             : 
     400           0 : ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type)) /* {{{ */
     401             : {
     402             :         zend_ini_entry *ini_entry;
     403             : 
     404           0 :         ini_entry = zend_hash_str_find_ptr(registered_zend_ini_directives, name, name_length);  
     405           0 :         if (ini_entry == NULL) {
     406           0 :                 return FAILURE;
     407             :         }
     408             : 
     409           0 :         ini_entry->displayer = displayer;
     410           0 :         return SUCCESS;
     411             : }
     412             : /* }}} */
     413             : 
     414             : /*
     415             :  * Data retrieval
     416             :  */
     417             : 
     418         626 : ZEND_API zend_long zend_ini_long(char *name, uint name_length, int orig) /* {{{ */
     419             : {
     420             :         zend_ini_entry *ini_entry;
     421             :         TSRMLS_FETCH();
     422             : 
     423        1252 :         ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length);
     424         626 :         if (ini_entry) {
     425         237 :                 if (orig && ini_entry->modified) {
     426           0 :                         return (ini_entry->orig_value ? ZEND_STRTOL(ini_entry->orig_value->val, NULL, 0) : 0);
     427             :                 } else {
     428         237 :                         return (ini_entry->value      ? ZEND_STRTOL(ini_entry->value->val, NULL, 0)      : 0);
     429             :                 }
     430             :         }
     431             : 
     432         389 :         return 0;
     433             : }
     434             : /* }}} */
     435             : 
     436          48 : ZEND_API double zend_ini_double(char *name, uint name_length, int orig) /* {{{ */
     437             : {
     438             :         zend_ini_entry *ini_entry;
     439             :         TSRMLS_FETCH();
     440             : 
     441          96 :         ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length);
     442          48 :         if (ini_entry) {
     443          48 :                 if (orig && ini_entry->modified) {
     444           0 :                         return (double) (ini_entry->orig_value ? zend_strtod(ini_entry->orig_value->val, NULL) : 0.0);
     445             :                 } else {
     446          48 :                         return (double) (ini_entry->value      ? zend_strtod(ini_entry->value->val, NULL)      : 0.0);
     447             :                 }
     448             :         }
     449             : 
     450           0 :         return 0.0;
     451             : }
     452             : /* }}} */
     453             : 
     454      151595 : ZEND_API char *zend_ini_string_ex(char *name, uint name_length, int orig, zend_bool *exists) /* {{{ */
     455             : {
     456             :         zend_ini_entry *ini_entry;
     457             :         TSRMLS_FETCH();
     458             : 
     459      303190 :         ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length);
     460      151595 :         if (ini_entry) {
     461      130465 :                 if (exists) {
     462       23916 :                         *exists = 1;
     463             :                 }
     464             : 
     465      130465 :                 if (orig && ini_entry->modified) {
     466           0 :                         return ini_entry->orig_value ? ini_entry->orig_value->val : NULL;
     467             :                 } else {
     468      130465 :                         return ini_entry->value ? ini_entry->value->val : NULL;
     469             :                 }
     470             :         } else {
     471       21130 :                 if (exists) {
     472       21130 :                         *exists = 0;
     473             :                 }
     474       21130 :                 return NULL;
     475             :         }
     476             : }
     477             : /* }}} */
     478             : 
     479       45046 : ZEND_API char *zend_ini_string(char *name, uint name_length, int orig) /* {{{ */
     480             : {
     481       45046 :         zend_bool exists = 1;
     482             :         char *return_value;
     483             : 
     484       45046 :         return_value = zend_ini_string_ex(name, name_length, orig, &exists);
     485       45046 :         if (!exists) {
     486       21130 :                 return NULL;
     487       23916 :         } else if (!return_value) {
     488       22042 :                 return_value = "";
     489             :         }
     490       23916 :         return return_value;
     491             : }
     492             : /* }}} */
     493             : 
     494             : #if TONY_20070307
     495             : static void zend_ini_displayer_cb(zend_ini_entry *ini_entry, int type) /* {{{ */
     496             : {
     497             :         if (ini_entry->displayer) {
     498             :                 ini_entry->displayer(ini_entry, type);
     499             :         } else {
     500             :                 char *display_string;
     501             :                 uint display_string_length;
     502             : 
     503             :                 if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     504             :                         if (ini_entry->orig_value) {
     505             :                                 display_string = ini_entry->orig_value;
     506             :                                 display_string_length = ini_entry->orig_value_length;
     507             :                         } else {
     508             :                                 if (zend_uv.html_errors) {
     509             :                                         display_string = NO_VALUE_HTML;
     510             :                                         display_string_length = sizeof(NO_VALUE_HTML) - 1;
     511             :                                 } else {
     512             :                                         display_string = NO_VALUE_PLAINTEXT;
     513             :                                         display_string_length = sizeof(NO_VALUE_PLAINTEXT) - 1;
     514             :                                 }
     515             :                         }
     516             :                 } else if (ini_entry->value && ini_entry->value[0]) {
     517             :                         display_string = ini_entry->value;
     518             :                         display_string_length = ini_entry->value_length;
     519             :                 } else {
     520             :                         if (zend_uv.html_errors) {
     521             :                                 display_string = NO_VALUE_HTML;
     522             :                                 display_string_length = sizeof(NO_VALUE_HTML) - 1;
     523             :                         } else {
     524             :                                 display_string = NO_VALUE_PLAINTEXT;
     525             :                                 display_string_length = sizeof(NO_VALUE_PLAINTEXT) - 1;
     526             :                         }
     527             :                 }
     528             :                 ZEND_WRITE(display_string, display_string_length);
     529             :         }
     530             : }
     531             : /* }}} */
     532             : #endif
     533             : 
     534       17552 : ZEND_INI_DISP(zend_ini_boolean_displayer_cb) /* {{{ */
     535             : {
     536             :         int value;
     537             :         zend_string *tmp_value;
     538             : 
     539       17652 :         if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     540         100 :                 tmp_value = (ini_entry->orig_value ? ini_entry->orig_value : NULL );
     541       17452 :         } else if (ini_entry->value) {
     542       17452 :                 tmp_value = ini_entry->value;
     543             :         } else {
     544           0 :                 tmp_value = NULL;
     545             :         }
     546             : 
     547       17552 :         if (tmp_value) {
     548       17552 :                 if (tmp_value->len == 4 && strcasecmp(tmp_value->val, "true") == 0) {
     549           0 :                         value = 1;
     550       17552 :                 } else if (tmp_value->len == 3 && strcasecmp(tmp_value->val, "yes") == 0) {
     551           0 :                         value = 1;
     552       17552 :                 } else if (tmp_value->len == 2 && strcasecmp(tmp_value->val, "on") == 0) {
     553           0 :                         value = 1;
     554             :                 } else {
     555       17552 :                         value = atoi(tmp_value->val);
     556             :                 }
     557             :         } else {
     558           0 :                 value = 0;
     559             :         }
     560             : 
     561       17552 :         if (value) {
     562        9308 :                 ZEND_PUTS("On");
     563             :         } else {
     564        8244 :                 ZEND_PUTS("Off");
     565             :         }
     566       17552 : }
     567             : /* }}} */
     568             : 
     569        1440 : ZEND_INI_DISP(zend_ini_color_displayer_cb) /* {{{ */
     570             : {
     571             :         char *value;
     572             : 
     573        1440 :         if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     574           0 :                 value = ini_entry->orig_value->val;
     575        1440 :         } else if (ini_entry->value) {
     576        1440 :                 value = ini_entry->value->val;
     577             :         } else {
     578           0 :                 value = NULL;
     579             :         }
     580        1440 :         if (value) {
     581        1440 :                 if (zend_uv.html_errors) {
     582        1440 :                         zend_printf("<font style=\"color: %s\">%s</font>", value, value);
     583             :                 } else {
     584           0 :                         ZEND_PUTS(value);
     585             :                 }
     586             :         } else {
     587           0 :                 if (zend_uv.html_errors) {
     588           0 :                         ZEND_PUTS(NO_VALUE_HTML);
     589             :                 } else {
     590           0 :                         ZEND_PUTS(NO_VALUE_PLAINTEXT);
     591             :                 }
     592             :         }
     593        1440 : }
     594             : /* }}} */
     595             : 
     596        2592 : ZEND_INI_DISP(display_link_numbers) /* {{{ */
     597             : {
     598             :         char *value;
     599             : 
     600        2592 :         if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     601           0 :                 value = ini_entry->orig_value->val;
     602        2592 :         } else if (ini_entry->value) {
     603        2592 :                 value = ini_entry->value->val;
     604             :         } else {
     605           0 :                 value = NULL;
     606             :         }
     607             : 
     608        2592 :         if (value) {
     609        2592 :                 if (atoi(value) == -1) {
     610        2578 :                         ZEND_PUTS("Unlimited");
     611             :                 } else {
     612          14 :                         zend_printf("%s", value);
     613             :                 }
     614             :         }
     615        2592 : }
     616             : /* }}} */
     617             : 
     618             : /* Standard message handlers */
     619     1300832 : ZEND_API ZEND_INI_MH(OnUpdateBool) /* {{{ */
     620             : {
     621             :         zend_bool *p;
     622             : #ifndef ZTS
     623     1300832 :         char *base = (char *) mh_arg2;
     624             : #else
     625             :         char *base;
     626             : 
     627             :         base = (char *) ts_resource(*((int *) mh_arg2));
     628             : #endif
     629             : 
     630     1300832 :         p = (zend_bool *) (base+(size_t) mh_arg1);
     631             : 
     632     1300832 :         if (new_value->len == 2 && strcasecmp("on", new_value->val) == 0) {
     633           0 :                 *p = (zend_bool) 1;
     634             :         }
     635     1300832 :         else if (new_value->len == 3 && strcasecmp("yes", new_value->val) == 0) {
     636           0 :                 *p = (zend_bool) 1;
     637             :         }
     638     1300832 :         else if (new_value->len == 4 && strcasecmp("true", new_value->val) == 0) {
     639           0 :                 *p = (zend_bool) 1;
     640             :         }
     641             :         else {
     642     1300832 :                 *p = (zend_bool) atoi(new_value->val);
     643             :         }
     644     1300832 :         return SUCCESS;
     645             : }
     646             : /* }}} */
     647             : 
     648     1236649 : ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */
     649             : {
     650             :         zend_long *p;
     651             : #ifndef ZTS
     652     1236649 :         char *base = (char *) mh_arg2;
     653             : #else
     654             :         char *base;
     655             : 
     656             :         base = (char *) ts_resource(*((int *) mh_arg2));
     657             : #endif
     658             : 
     659     1236649 :         p = (zend_long *) (base+(size_t) mh_arg1);
     660             : 
     661     1236649 :         *p = zend_atol(new_value->val, (int)new_value->len);
     662     1236649 :         return SUCCESS;
     663             : }
     664             : /* }}} */
     665             : 
     666       82490 : ZEND_API ZEND_INI_MH(OnUpdateLongGEZero) /* {{{ */
     667             : {
     668             :         zend_long *p, tmp;
     669             : #ifndef ZTS
     670       82490 :         char *base = (char *) mh_arg2;
     671             : #else
     672             :         char *base;
     673             : 
     674             :         base = (char *) ts_resource(*((int *) mh_arg2));
     675             : #endif
     676             : 
     677       82490 :         tmp = zend_atol(new_value->val, (int)new_value->len);
     678       82490 :         if (tmp < 0) {
     679           2 :                 return FAILURE;
     680             :         }
     681             : 
     682       82488 :         p = (zend_long *) (base+(size_t) mh_arg1);
     683       82488 :         *p = tmp;
     684             : 
     685       82488 :         return SUCCESS;
     686             : }
     687             : /* }}} */
     688             : 
     689       20622 : ZEND_API ZEND_INI_MH(OnUpdateReal) /* {{{ */
     690             : {
     691             :         double *p;
     692             : #ifndef ZTS
     693       20622 :         char *base = (char *) mh_arg2;
     694             : #else
     695             :         char *base;
     696             : 
     697             :         base = (char *) ts_resource(*((int *) mh_arg2));
     698             : #endif
     699             : 
     700       20622 :         p = (double *) (base+(size_t) mh_arg1);
     701             : 
     702       20622 :         *p = zend_strtod(new_value->val, NULL);
     703       20622 :         return SUCCESS;
     704             : }
     705             : /* }}} */
     706             : 
     707     1237893 : ZEND_API ZEND_INI_MH(OnUpdateString) /* {{{ */
     708             : {
     709             :         char **p;
     710             : #ifndef ZTS
     711     1237893 :         char *base = (char *) mh_arg2;
     712             : #else
     713             :         char *base;
     714             : 
     715             :         base = (char *) ts_resource(*((int *) mh_arg2));
     716             : #endif
     717             : 
     718     1237893 :         p = (char **) (base+(size_t) mh_arg1);
     719             : 
     720     1237893 :         *p = new_value ? new_value->val : NULL;
     721     1237893 :         return SUCCESS;
     722             : }
     723             : /* }}} */
     724             : 
     725      291114 : ZEND_API ZEND_INI_MH(OnUpdateStringUnempty) /* {{{ */
     726             : {
     727             :         char **p;
     728             : #ifndef ZTS
     729      291114 :         char *base = (char *) mh_arg2;
     730             : #else
     731             :         char *base;
     732             : 
     733             :         base = (char *) ts_resource(*((int *) mh_arg2));
     734             : #endif
     735             : 
     736      291114 :         if (new_value && !new_value->val[0]) {
     737       20468 :                 return FAILURE;
     738             :         }
     739             : 
     740      270646 :         p = (char **) (base+(size_t) mh_arg1);
     741             : 
     742      270646 :         *p = new_value ? new_value->val : NULL;
     743      270646 :         return SUCCESS;
     744             : }
     745             : /* }}} */
     746             : 
     747             : /*
     748             :  * Local variables:
     749             :  * tab-width: 4
     750             :  * c-basic-offset: 4
     751             :  * indent-tabs-mode: t
     752             :  * End:
     753             :  */

Generated by: LCOV version 1.10

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

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