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: 233 276 84.4 %
Date: 2015-03-01 Functions: 30 32 93.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend Engine                                                          |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2015 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_sort.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    97142074 : static int zend_remove_ini_entries(zval *el, void *arg) /* {{{ */
      38             : {
      39    97142074 :         zend_ini_entry *ini_entry = (zend_ini_entry *)Z_PTR_P(el);
      40    97142074 :         int module_number = *(int *)arg;
      41    97142074 :         if (ini_entry->module_number == module_number) {
      42     5371581 :                 return 1;
      43             :         } else {
      44    91770493 :                 return 0;
      45             :         }
      46             : }
      47             : /* }}} */
      48             : 
      49        4909 : static int zend_restore_ini_entry_cb(zend_ini_entry *ini_entry, int stage) /* {{{ */
      50             : {
      51        4909 :         int result = FAILURE;
      52             : 
      53        4909 :         if (ini_entry->modified) {
      54        4908 :                 if (ini_entry->on_modify) {
      55        4907 :                         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        4907 :                                 result = ini_entry->on_modify(ini_entry, ini_entry->orig_value, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage);
      60        4907 :                         } zend_end_try();
      61             :                 }
      62        4908 :                 if (stage == ZEND_INI_STAGE_RUNTIME && result == FAILURE) {
      63             :                         /* runtime failure is OK */
      64           0 :                         return 1;
      65             :                 }
      66        4908 :                 if (ini_entry->value != ini_entry->orig_value) {
      67        2606 :                         zend_string_release(ini_entry->value);
      68             :                 }
      69        4908 :                 ini_entry->value = ini_entry->orig_value;
      70        4908 :                 ini_entry->modifiable = ini_entry->orig_modifiable;
      71        4908 :                 ini_entry->modified = 0;
      72        4908 :                 ini_entry->orig_value = NULL;
      73        4908 :                 ini_entry->orig_modifiable = 0;
      74             :         }
      75        4909 :         return 0;
      76             : }
      77             : /* }}} */
      78             : 
      79        4884 : static int zend_restore_ini_entry_wrapper(zval *el) /* {{{ */
      80             : {
      81        4884 :         zend_ini_entry *ini_entry = (zend_ini_entry *)Z_PTR_P(el);
      82        4884 :         zend_restore_ini_entry_cb(ini_entry, ZEND_INI_STAGE_DEACTIVATE);
      83        4884 :         return 1;
      84             : }
      85             : /* }}} */
      86             : 
      87     5455201 : static void free_ini_entry(zval *zv) /* {{{ */
      88             : {
      89     5455201 :         zend_ini_entry *entry = (zend_ini_entry*)Z_PTR_P(zv);
      90             : 
      91     5455201 :         zend_string_release(entry->name);
      92     5455201 :         if (entry->value) {
      93     4513217 :                 zend_string_release(entry->value);
      94             :         }
      95     5455201 :         if (entry->orig_value) {
      96           0 :                 zend_string_release(entry->orig_value);
      97             :         }
      98     5455201 :         free(entry);
      99     5455201 : }
     100             : /* }}} */
     101             : 
     102             : /*
     103             :  * Startup / shutdown
     104             :  */
     105       20871 : ZEND_API int zend_ini_startup(void) /* {{{ */
     106             : {
     107       20871 :         registered_zend_ini_directives = (HashTable *) malloc(sizeof(HashTable));
     108             : 
     109       20871 :         EG(ini_directives) = registered_zend_ini_directives;
     110       20871 :         EG(modified_ini_directives) = NULL;
     111       20871 :         EG(error_reporting_ini_entry) = NULL;
     112       20871 :         zend_hash_init_ex(registered_zend_ini_directives, 128, NULL, free_ini_entry, 1, 0);
     113       20871 :         return SUCCESS;
     114             : }
     115             : /* }}} */
     116             : 
     117       20905 : ZEND_API int zend_ini_shutdown(void) /* {{{ */
     118             : {
     119       20905 :         zend_ini_dtor(EG(ini_directives));
     120       20905 :         return SUCCESS;
     121             : }
     122             : /* }}} */
     123             : 
     124       20905 : ZEND_API void zend_ini_dtor(HashTable *ini_directives) /* {{{ */
     125             : {
     126       20905 :         zend_hash_destroy(ini_directives);
     127       20905 :         free(ini_directives);
     128       20905 : }
     129             : /* }}} */
     130             : 
     131           0 : ZEND_API int zend_ini_global_shutdown(void) /* {{{ */
     132             : {
     133           0 :         zend_hash_destroy(registered_zend_ini_directives);
     134           0 :         free(registered_zend_ini_directives);
     135           0 :         return SUCCESS;
     136             : }
     137             : /* }}} */
     138             : 
     139       20878 : ZEND_API int zend_ini_deactivate(void) /* {{{ */
     140             : {
     141       20878 :         if (EG(modified_ini_directives)) {
     142        3849 :                 zend_hash_apply(EG(modified_ini_directives), zend_restore_ini_entry_wrapper);
     143        3849 :                 zend_hash_destroy(EG(modified_ini_directives));
     144        3849 :                 FREE_HASHTABLE(EG(modified_ini_directives));
     145        3849 :                 EG(modified_ini_directives) = NULL;
     146             :         }
     147       20878 :         return SUCCESS;
     148             : }
     149             : /* }}} */
     150             : 
     151             : #ifdef ZTS
     152             : static void copy_ini_entry(zval *zv) /* {{{ */
     153             : {
     154             :         zend_ini_entry *old_entry = (zend_ini_entry*)Z_PTR_P(zv);
     155             :         zend_ini_entry *new_entry = pemalloc(sizeof(zend_ini_entry), 1);
     156             : 
     157             :         Z_PTR_P(zv) = new_entry;
     158             :         memcpy(new_entry, old_entry, sizeof(zend_ini_entry));
     159             :         if (old_entry->name) {
     160             :                 new_entry->name = zend_string_init(old_entry->name->val, old_entry->name->len, 1);
     161             :         }
     162             :         if (old_entry->value) {
     163             :                 new_entry->value = zend_string_init(old_entry->value->val, old_entry->value->len, 1);
     164             :         }
     165             :         if (old_entry->orig_value) {
     166             :                 new_entry->orig_value = zend_string_init(old_entry->orig_value->val, old_entry->orig_value->len, 1);
     167             :         }
     168             : }
     169             : /* }}} */
     170             : 
     171             : ZEND_API int zend_copy_ini_directives(void) /* {{{ */
     172             : {
     173             :         EG(modified_ini_directives) = NULL;
     174             :         EG(error_reporting_ini_entry) = NULL;
     175             :         EG(ini_directives) = (HashTable *) malloc(sizeof(HashTable));
     176             :         zend_hash_init_ex(EG(ini_directives), registered_zend_ini_directives->nNumOfElements, NULL, free_ini_entry, 1, 0);
     177             :         zend_hash_copy(EG(ini_directives), registered_zend_ini_directives, copy_ini_entry);
     178             :         return SUCCESS;
     179             : }
     180             : /* }}} */
     181             : #endif
     182             : 
     183      238820 : static int ini_key_compare(const void *a, const void *b) /* {{{ */
     184             : {
     185             :         const Bucket *f;
     186             :         const Bucket *s;
     187             : 
     188      238820 :         f = (const Bucket *) a;
     189      238820 :         s = (const Bucket *) b;
     190             : 
     191      238820 :         if (!f->key && !s->key) { /* both numeric */
     192           0 :                 return ZEND_NORMALIZE_BOOL(f->h - s->h);
     193      238820 :         } else if (!f->key) { /* f is numeric, s is not */
     194           0 :                 return -1;
     195      238820 :         } else if (!s->key) { /* s is numeric, f is not */
     196           0 :                 return 1;
     197             :         } else { /* both strings */
     198      238820 :                 return zend_binary_strcasecmp(f->key->val, f->key->len, s->key->val, s->key->len);
     199             :         }
     200             : }
     201             : /* }}} */
     202             : 
     203         165 : ZEND_API void zend_ini_sort_entries(void) /* {{{ */
     204             : {
     205         165 :         zend_hash_sort(EG(ini_directives), ini_key_compare, 0);
     206         165 : }
     207             : /* }}} */
     208             : 
     209             : /*
     210             :  * Registration / unregistration
     211             :  */
     212      709859 : ZEND_API int zend_register_ini_entries(const zend_ini_entry_def *ini_entry, int module_number) /* {{{ */
     213             : {
     214             :         zend_ini_entry *p;
     215             :         zval *default_value;
     216      709859 :         HashTable *directives = registered_zend_ini_directives;
     217             : 
     218             : #ifdef ZTS
     219             :         /* if we are called during the request, eg: from dl(),
     220             :          * then we should not touch the global directives table,
     221             :          * and should update the per-(request|thread) version instead.
     222             :          * This solves two problems: one is that ini entries for dl()'d
     223             :          * extensions will now work, and the second is that updating the
     224             :          * global hash here from dl() is not mutex protected and can
     225             :          * lead to death.
     226             :          */
     227             :         if (directives != EG(ini_directives)) {
     228             :                 directives = EG(ini_directives);
     229             :         }
     230             : #endif
     231             : 
     232     6865988 :         while (ini_entry->name) {
     233     5446270 :                 p = pemalloc(sizeof(zend_ini_entry), 1);
     234    10892540 :                 p->name = zend_string_init(ini_entry->name, ini_entry->name_length, 1);
     235     5446270 :                 p->on_modify = ini_entry->on_modify;
     236     5446270 :                 p->mh_arg1 = ini_entry->mh_arg1;
     237     5446270 :                 p->mh_arg2 = ini_entry->mh_arg2;
     238     5446270 :                 p->mh_arg3 = ini_entry->mh_arg3;
     239     5446270 :                 p->value = NULL;
     240     5446270 :                 p->orig_value = NULL;
     241     5446270 :                 p->displayer = ini_entry->displayer;
     242     5446270 :                 p->modifiable = ini_entry->modifiable;
     243             : 
     244     5446270 :                 p->orig_modifiable = 0;
     245     5446270 :                 p->modified = 0;
     246     5446270 :                 p->module_number = module_number;
     247             : 
     248    10892540 :                 if (zend_hash_add_ptr(directives, p->name, (void*)p) == NULL) {
     249           0 :                         if (p->name) {
     250           0 :                                 zend_string_release(p->name);
     251             :                         }
     252           0 :                         zend_unregister_ini_entries(module_number);
     253           0 :                         return FAILURE;
     254             :                 }
     255     7487791 :                 if (((default_value = zend_get_configuration_directive(p->name)) != NULL) &&
     256     1354090 :             (!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) == SUCCESS)) {
     257             : 
     258     1374862 :                         p->value = zend_string_copy(Z_STR_P(default_value));
     259             :                 } else {
     260     8577200 :                         p->value = ini_entry->value ?
     261     3818361 :                                 zend_string_init(ini_entry->value, ini_entry->value_length, 1) : NULL;
     262             : 
     263     4758839 :                         if (p->on_modify) {
     264     4341342 :                                 p->on_modify(p, p->value, p->mh_arg1, p->mh_arg2, p->mh_arg3, ZEND_INI_STAGE_STARTUP);
     265             :                         }
     266             :                 }
     267     5446270 :                 ini_entry++;
     268             :         }
     269      709859 :         return SUCCESS;
     270             : }
     271             : /* }}} */
     272             : 
     273      606490 : ZEND_API void zend_unregister_ini_entries(int module_number) /* {{{ */
     274             : {
     275      606490 :         zend_hash_apply_with_argument(registered_zend_ini_directives, zend_remove_ini_entries, (void *) &module_number);
     276      606490 : }
     277             : /* }}} */
     278             : 
     279             : #ifdef ZTS
     280             : static int zend_ini_refresh_cache(zval *el, void *arg) /* {{{ */
     281             : {
     282             :         zend_ini_entry *p = (zend_ini_entry *)Z_PTR_P(el);
     283             :         int stage = (int)(zend_intptr_t)arg;
     284             : 
     285             :         if (p->on_modify) {
     286             :                 p->on_modify(p, p->value, p->mh_arg1, p->mh_arg2, p->mh_arg3, stage);
     287             :         }
     288             :         return 0;
     289             : }
     290             : /* }}} */
     291             : 
     292             : ZEND_API void zend_ini_refresh_caches(int stage) /* {{{ */
     293             : {
     294             :         zend_hash_apply_with_argument(EG(ini_directives), zend_ini_refresh_cache, (void *)(zend_intptr_t) stage);
     295             : }
     296             : /* }}} */
     297             : #endif
     298             : 
     299         739 : ZEND_API int zend_alter_ini_entry(zend_string *name, zend_string *new_value, int modify_type, int stage) /* {{{ */
     300             : {
     301             : 
     302         739 :         return zend_alter_ini_entry_ex(name, new_value, modify_type, stage, 0);
     303             : }
     304             : /* }}} */
     305             : 
     306         386 : ZEND_API int zend_alter_ini_entry_chars(zend_string *name, const char *value, size_t value_length, int modify_type, int stage) /* {{{ */
     307             : {
     308             :     int ret;
     309             :     zend_string *new_value;
     310             : 
     311         772 :         new_value = zend_string_init(value, value_length, stage != ZEND_INI_STAGE_RUNTIME);
     312         386 :         ret = zend_alter_ini_entry_ex(name, new_value, modify_type, stage, 0);
     313             :         zend_string_release(new_value);
     314         386 :         return ret;
     315             : }
     316             : /* }}} */
     317             : 
     318          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) /* {{{ */
     319             : {
     320             :     int ret;
     321             :     zend_string *new_value;
     322             : 
     323          36 :         new_value = zend_string_init(value, value_length, stage != ZEND_INI_STAGE_RUNTIME);
     324          18 :         ret = zend_alter_ini_entry_ex(name, new_value, modify_type, stage, force_change);
     325             :         zend_string_release(new_value);
     326          18 :         return ret;
     327             : }
     328             : /* }}} */
     329             : 
     330        3719 : ZEND_API int zend_alter_ini_entry_ex(zend_string *name, zend_string *new_value, int modify_type, int stage, int force_change) /* {{{ */
     331             : {
     332             :         zend_ini_entry *ini_entry;
     333             :         zend_string *duplicate;
     334             :         zend_bool modifiable;
     335             :         zend_bool modified;
     336             : 
     337        7438 :         if ((ini_entry = zend_hash_find_ptr(EG(ini_directives), name)) == NULL) {
     338           0 :                 return FAILURE;
     339             :         }
     340             : 
     341        3719 :         modifiable = ini_entry->modifiable;
     342        3719 :         modified = ini_entry->modified;
     343             : 
     344        3719 :         if (stage == ZEND_INI_STAGE_ACTIVATE && modify_type == ZEND_INI_SYSTEM) {
     345           0 :                 ini_entry->modifiable = ZEND_INI_SYSTEM;
     346             :         }
     347             : 
     348        3719 :         if (!force_change) {
     349        3719 :                 if (!(ini_entry->modifiable & modify_type)) {
     350           1 :                         return FAILURE;
     351             :                 }
     352             :         }
     353             : 
     354        3718 :         if (!EG(modified_ini_directives)) {
     355        1907 :                 ALLOC_HASHTABLE(EG(modified_ini_directives));
     356        1907 :                 zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
     357             :         }
     358        3718 :         if (!modified) {
     359        2297 :                 ini_entry->orig_value = ini_entry->value;
     360        2297 :                 ini_entry->orig_modifiable = modifiable;
     361        2297 :                 ini_entry->modified = 1;
     362        2297 :                 zend_hash_add_ptr(EG(modified_ini_directives), name, ini_entry);
     363             :         }
     364             : 
     365        3718 :         duplicate = zend_string_copy(new_value);
     366             : 
     367       11117 :         if (!ini_entry->on_modify
     368        3715 :                 || ini_entry->on_modify(ini_entry, duplicate, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage) == SUCCESS) {
     369        3684 :                 if (modified && ini_entry->orig_value != ini_entry->value) { /* we already changed the value, free the changed value */
     370        1393 :                         zend_string_release(ini_entry->value);
     371             :                 }
     372        3684 :                 ini_entry->value = duplicate;
     373             :         } else {
     374             :                 zend_string_release(duplicate);
     375          34 :                 return FAILURE;
     376             :         }
     377             : 
     378        3684 :         return SUCCESS;
     379             : }
     380             : /* }}} */
     381             : 
     382          26 : ZEND_API int zend_restore_ini_entry(zend_string *name, int stage) /* {{{ */
     383             : {
     384             :         zend_ini_entry *ini_entry;
     385             : 
     386          78 :         if ((ini_entry = zend_hash_find_ptr(EG(ini_directives), name)) == NULL ||
     387          26 :                 (stage == ZEND_INI_STAGE_RUNTIME && (ini_entry->modifiable & ZEND_INI_USER) == 0)) {
     388           0 :                 return FAILURE;
     389             :         }
     390             : 
     391          26 :         if (EG(modified_ini_directives)) {
     392          25 :                 if (zend_restore_ini_entry_cb(ini_entry, stage) == 0) {
     393          25 :                         zend_hash_del(EG(modified_ini_directives), name);
     394             :                 } else {
     395           0 :                         return FAILURE;
     396             :                 }
     397             :         }
     398             : 
     399          26 :         return SUCCESS;
     400             : }
     401             : /* }}} */
     402             : 
     403           0 : ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type)) /* {{{ */
     404             : {
     405             :         zend_ini_entry *ini_entry;
     406             : 
     407           0 :         ini_entry = zend_hash_str_find_ptr(registered_zend_ini_directives, name, name_length);
     408           0 :         if (ini_entry == NULL) {
     409           0 :                 return FAILURE;
     410             :         }
     411             : 
     412           0 :         ini_entry->displayer = displayer;
     413           0 :         return SUCCESS;
     414             : }
     415             : /* }}} */
     416             : 
     417             : /*
     418             :  * Data retrieval
     419             :  */
     420             : 
     421         482 : ZEND_API zend_long zend_ini_long(char *name, uint name_length, int orig) /* {{{ */
     422             : {
     423             :         zend_ini_entry *ini_entry;
     424             : 
     425         964 :         ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length);
     426         482 :         if (ini_entry) {
     427          91 :                 if (orig && ini_entry->modified) {
     428           0 :                         return (ini_entry->orig_value ? ZEND_STRTOL(ini_entry->orig_value->val, NULL, 0) : 0);
     429             :                 } else {
     430          91 :                         return (ini_entry->value      ? ZEND_STRTOL(ini_entry->value->val, NULL, 0)      : 0);
     431             :                 }
     432             :         }
     433             : 
     434         391 :         return 0;
     435             : }
     436             : /* }}} */
     437             : 
     438          48 : ZEND_API double zend_ini_double(char *name, uint name_length, int orig) /* {{{ */
     439             : {
     440             :         zend_ini_entry *ini_entry;
     441             : 
     442          96 :         ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length);
     443          48 :         if (ini_entry) {
     444          48 :                 if (orig && ini_entry->modified) {
     445           0 :                         return (double) (ini_entry->orig_value ? zend_strtod(ini_entry->orig_value->val, NULL) : 0.0);
     446             :                 } else {
     447          48 :                         return (double) (ini_entry->value      ? zend_strtod(ini_entry->value->val, NULL)      : 0.0);
     448             :                 }
     449             :         }
     450             : 
     451           0 :         return 0.0;
     452             : }
     453             : /* }}} */
     454             : 
     455      152386 : ZEND_API char *zend_ini_string_ex(char *name, uint name_length, int orig, zend_bool *exists) /* {{{ */
     456             : {
     457             :         zend_ini_entry *ini_entry;
     458             : 
     459      304772 :         ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length);
     460      152386 :         if (ini_entry) {
     461      131005 :                 if (exists) {
     462       24099 :                         *exists = 1;
     463             :                 }
     464             : 
     465      131005 :                 if (orig && ini_entry->modified) {
     466           0 :                         return ini_entry->orig_value ? ini_entry->orig_value->val : NULL;
     467             :                 } else {
     468      131005 :                         return ini_entry->value ? ini_entry->value->val : NULL;
     469             :                 }
     470             :         } else {
     471       21381 :                 if (exists) {
     472       21381 :                         *exists = 0;
     473             :                 }
     474       21381 :                 return NULL;
     475             :         }
     476             : }
     477             : /* }}} */
     478             : 
     479       45480 : ZEND_API char *zend_ini_string(char *name, uint name_length, int orig) /* {{{ */
     480             : {
     481       45480 :         zend_bool exists = 1;
     482             :         char *return_value;
     483             : 
     484       45480 :         return_value = zend_ini_string_ex(name, name_length, orig, &exists);
     485       45480 :         if (!exists) {
     486       21381 :                 return NULL;
     487       24099 :         } else if (!return_value) {
     488       22210 :                 return_value = "";
     489             :         }
     490       24099 :         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       17674 : ZEND_INI_DISP(zend_ini_boolean_displayer_cb) /* {{{ */
     535             : {
     536             :         int value;
     537             :         zend_string *tmp_value;
     538             : 
     539       17774 :         if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     540         100 :                 tmp_value = (ini_entry->orig_value ? ini_entry->orig_value : NULL );
     541       17574 :         } else if (ini_entry->value) {
     542       17574 :                 tmp_value = ini_entry->value;
     543             :         } else {
     544           0 :                 tmp_value = NULL;
     545             :         }
     546             : 
     547       17674 :         if (tmp_value) {
     548       17674 :                 if (tmp_value->len == 4 && strcasecmp(tmp_value->val, "true") == 0) {
     549           0 :                         value = 1;
     550       17674 :                 } else if (tmp_value->len == 3 && strcasecmp(tmp_value->val, "yes") == 0) {
     551           0 :                         value = 1;
     552       17674 :                 } else if (tmp_value->len == 2 && strcasecmp(tmp_value->val, "on") == 0) {
     553           0 :                         value = 1;
     554             :                 } else {
     555       17674 :                         value = atoi(tmp_value->val);
     556             :                 }
     557             :         } else {
     558           0 :                 value = 0;
     559             :         }
     560             : 
     561       17674 :         if (value) {
     562        9372 :                 ZEND_PUTS("On");
     563             :         } else {
     564        8302 :                 ZEND_PUTS("Off");
     565             :         }
     566       17674 : }
     567             : /* }}} */
     568             : 
     569        1450 : ZEND_INI_DISP(zend_ini_color_displayer_cb) /* {{{ */
     570             : {
     571             :         char *value;
     572             : 
     573        1450 :         if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     574           0 :                 value = ini_entry->orig_value->val;
     575        1450 :         } else if (ini_entry->value) {
     576        1450 :                 value = ini_entry->value->val;
     577             :         } else {
     578           0 :                 value = NULL;
     579             :         }
     580        1450 :         if (value) {
     581        1450 :                 if (zend_uv.html_errors) {
     582        1450 :                         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        1450 : }
     594             : /* }}} */
     595             : 
     596        2030 : ZEND_INI_DISP(display_link_numbers) /* {{{ */
     597             : {
     598             :         char *value;
     599             : 
     600        2030 :         if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
     601           0 :                 value = ini_entry->orig_value->val;
     602        2030 :         } else if (ini_entry->value) {
     603        2030 :                 value = ini_entry->value->val;
     604             :         } else {
     605           0 :                 value = NULL;
     606             :         }
     607             : 
     608        2030 :         if (value) {
     609        2030 :                 if (atoi(value) == -1) {
     610        2016 :                         ZEND_PUTS("Unlimited");
     611             :                 } else {
     612          14 :                         zend_printf("%s", value);
     613             :                 }
     614             :         }
     615        2030 : }
     616             : /* }}} */
     617             : 
     618             : /* Standard message handlers */
     619     1337401 : ZEND_API ZEND_INI_MH(OnUpdateBool) /* {{{ */
     620             : {
     621             :         zend_bool *p;
     622             : #ifndef ZTS
     623     1337401 :         char *base = (char *) mh_arg2;
     624             : #else
     625             :         char *base;
     626             : 
     627             :         base = (char *) ts_resource(*((int *) mh_arg2));
     628             : #endif
     629             : 
     630     1337401 :         p = (zend_bool *) (base+(size_t) mh_arg1);
     631             : 
     632     1337401 :         if (new_value->len == 2 && strcasecmp("on", new_value->val) == 0) {
     633           0 :                 *p = (zend_bool) 1;
     634             :         }
     635     1337401 :         else if (new_value->len == 3 && strcasecmp("yes", new_value->val) == 0) {
     636           0 :                 *p = (zend_bool) 1;
     637             :         }
     638     1337401 :         else if (new_value->len == 4 && strcasecmp("true", new_value->val) == 0) {
     639           0 :                 *p = (zend_bool) 1;
     640             :         }
     641             :         else {
     642     1337401 :                 *p = (zend_bool) atoi(new_value->val);
     643             :         }
     644     1337401 :         return SUCCESS;
     645             : }
     646             : /* }}} */
     647             : 
     648     1251587 : ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */
     649             : {
     650             :         zend_long *p;
     651             : #ifndef ZTS
     652     1251587 :         char *base = (char *) mh_arg2;
     653             : #else
     654             :         char *base;
     655             : 
     656             :         base = (char *) ts_resource(*((int *) mh_arg2));
     657             : #endif
     658             : 
     659     1251587 :         p = (zend_long *) (base+(size_t) mh_arg1);
     660             : 
     661     1251587 :         *p = zend_atol(new_value->val, (int)new_value->len);
     662     1251587 :         return SUCCESS;
     663             : }
     664             : /* }}} */
     665             : 
     666       83486 : ZEND_API ZEND_INI_MH(OnUpdateLongGEZero) /* {{{ */
     667             : {
     668             :         zend_long *p, tmp;
     669             : #ifndef ZTS
     670       83486 :         char *base = (char *) mh_arg2;
     671             : #else
     672             :         char *base;
     673             : 
     674             :         base = (char *) ts_resource(*((int *) mh_arg2));
     675             : #endif
     676             : 
     677       83486 :         tmp = zend_atol(new_value->val, (int)new_value->len);
     678       83486 :         if (tmp < 0) {
     679           2 :                 return FAILURE;
     680             :         }
     681             : 
     682       83484 :         p = (zend_long *) (base+(size_t) mh_arg1);
     683       83484 :         *p = tmp;
     684             : 
     685       83484 :         return SUCCESS;
     686             : }
     687             : /* }}} */
     688             : 
     689       20871 : ZEND_API ZEND_INI_MH(OnUpdateReal) /* {{{ */
     690             : {
     691             :         double *p;
     692             : #ifndef ZTS
     693       20871 :         char *base = (char *) mh_arg2;
     694             : #else
     695             :         char *base;
     696             : 
     697             :         base = (char *) ts_resource(*((int *) mh_arg2));
     698             : #endif
     699             : 
     700       20871 :         p = (double *) (base+(size_t) mh_arg1);
     701             : 
     702       20871 :         *p = zend_strtod(new_value->val, NULL);
     703       20871 :         return SUCCESS;
     704             : }
     705             : /* }}} */
     706             : 
     707     1252845 : ZEND_API ZEND_INI_MH(OnUpdateString) /* {{{ */
     708             : {
     709             :         char **p;
     710             : #ifndef ZTS
     711     1252845 :         char *base = (char *) mh_arg2;
     712             : #else
     713             :         char *base;
     714             : 
     715             :         base = (char *) ts_resource(*((int *) mh_arg2));
     716             : #endif
     717             : 
     718     1252845 :         p = (char **) (base+(size_t) mh_arg1);
     719             : 
     720     1252845 :         *p = new_value ? new_value->val : NULL;
     721     1252845 :         return SUCCESS;
     722             : }
     723             : /* }}} */
     724             : 
     725      294600 : ZEND_API ZEND_INI_MH(OnUpdateStringUnempty) /* {{{ */
     726             : {
     727             :         char **p;
     728             : #ifndef ZTS
     729      294600 :         char *base = (char *) mh_arg2;
     730             : #else
     731             :         char *base;
     732             : 
     733             :         base = (char *) ts_resource(*((int *) mh_arg2));
     734             : #endif
     735             : 
     736      294600 :         if (new_value && !new_value->val[0]) {
     737       20717 :                 return FAILURE;
     738             :         }
     739             : 
     740      273883 :         p = (char **) (base+(size_t) mh_arg1);
     741             : 
     742      273883 :         *p = new_value ? new_value->val : NULL;
     743      273883 :         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 Sun, 01 Mar 2015 23:22:22 +0000 (2 days ago)

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