LTP GCOV extension - code coverage report
Current view: directory - Zend - zend_ini.c
Test: PHP Code Coverage
Date: 2007-04-10 Instrumented lines: 215
Code covered: 53.0 % Executed lines: 114
Legend: not executed executed

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

Generated by: LTP GCOV extension version 1.5