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 - ext/opcache - zend_accelerator_module.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 263 367 71.7 %
Date: 2018-07-27 Functions: 21 24 87.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend OPcache                                                         |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2018 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP 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.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Andi Gutmans <andi@zend.com>                                |
      16             :    |          Zeev Suraski <zeev@zend.com>                                |
      17             :    |          Stanislav Malyshev <stas@zend.com>                          |
      18             :    |          Dmitry Stogov <dmitry@zend.com>                             |
      19             :    +----------------------------------------------------------------------+
      20             : */
      21             : 
      22             : #include <time.h>
      23             : 
      24             : #include "php.h"
      25             : #include "ZendAccelerator.h"
      26             : #include "zend_API.h"
      27             : #include "zend_shared_alloc.h"
      28             : #include "zend_accelerator_blacklist.h"
      29             : #include "php_ini.h"
      30             : #include "SAPI.h"
      31             : #include "zend_virtual_cwd.h"
      32             : #include "ext/standard/info.h"
      33             : #include "ext/standard/php_filestat.h"
      34             : 
      35             : #define STRING_NOT_NULL(s) (NULL == (s)?"":s)
      36             : #define MIN_ACCEL_FILES 200
      37             : #define MAX_ACCEL_FILES 1000000
      38             : #define TOKENTOSTR(X) #X
      39             : 
      40             : static void (*orig_file_exists)(INTERNAL_FUNCTION_PARAMETERS) = NULL;
      41             : static void (*orig_is_file)(INTERNAL_FUNCTION_PARAMETERS) = NULL;
      42             : static void (*orig_is_readable)(INTERNAL_FUNCTION_PARAMETERS) = NULL;
      43             : 
      44             : ZEND_BEGIN_ARG_INFO(arginfo_opcache_none, 0)
      45             : ZEND_END_ARG_INFO()
      46             : 
      47             : ZEND_BEGIN_ARG_INFO_EX(arginfo_opcache_get_status, 0, 0, 0)
      48             :         ZEND_ARG_INFO(0, fetch_scripts)
      49             : ZEND_END_ARG_INFO()
      50             : 
      51             : ZEND_BEGIN_ARG_INFO_EX(arginfo_opcache_compile_file, 0, 0, 1)
      52             :         ZEND_ARG_INFO(0, file)
      53             : ZEND_END_ARG_INFO()
      54             : 
      55             : ZEND_BEGIN_ARG_INFO_EX(arginfo_opcache_invalidate, 0, 0, 1)
      56             :         ZEND_ARG_INFO(0, script)
      57             :         ZEND_ARG_INFO(0, force)
      58             : ZEND_END_ARG_INFO()
      59             : 
      60             : ZEND_BEGIN_ARG_INFO_EX(arginfo_opcache_is_script_cached, 0, 0, 1)
      61             :         ZEND_ARG_INFO(0, script)
      62             : ZEND_END_ARG_INFO()
      63             : 
      64             : /* User functions */
      65             : static ZEND_FUNCTION(opcache_reset);
      66             : static ZEND_FUNCTION(opcache_invalidate);
      67             : static ZEND_FUNCTION(opcache_is_script_cached);
      68             : 
      69             : /* Private functions */
      70             : static ZEND_FUNCTION(opcache_get_status);
      71             : static ZEND_FUNCTION(opcache_compile_file);
      72             : static ZEND_FUNCTION(opcache_get_configuration);
      73             : 
      74             : static zend_function_entry accel_functions[] = {
      75             :         /* User functions */
      76             :         ZEND_FE(opcache_reset,                                  arginfo_opcache_none)
      77             :         ZEND_FE(opcache_invalidate,                             arginfo_opcache_invalidate)
      78             :         ZEND_FE(opcache_compile_file,                   arginfo_opcache_compile_file)
      79             :         ZEND_FE(opcache_is_script_cached,               arginfo_opcache_is_script_cached)
      80             :         /* Private functions */
      81             :         ZEND_FE(opcache_get_configuration,              arginfo_opcache_none)
      82             :         ZEND_FE(opcache_get_status,                             arginfo_opcache_get_status)
      83             :         ZEND_FE_END
      84             : };
      85             : 
      86          20 : static int validate_api_restriction(void)
      87             : {
      88          20 :         if (ZCG(accel_directives).restrict_api && *ZCG(accel_directives).restrict_api) {
      89           0 :                 size_t len = strlen(ZCG(accel_directives).restrict_api);
      90             : 
      91           0 :                 if (!SG(request_info).path_translated ||
      92           0 :                     strlen(SG(request_info).path_translated) < len ||
      93           0 :                     memcmp(SG(request_info).path_translated, ZCG(accel_directives).restrict_api, len) != 0) {
      94           0 :                         zend_error(E_WARNING, ACCELERATOR_PRODUCT_NAME " API is restricted by \"restrict_api\" configuration directive");
      95           0 :                         return 0;
      96             :                 }
      97             :         }
      98          20 :         return 1;
      99             : }
     100             : 
     101       24499 : static ZEND_INI_MH(OnUpdateMemoryConsumption)
     102             : {
     103             :         zend_long *p;
     104             :         zend_long memsize;
     105             : #ifndef ZTS
     106       24499 :         char *base = (char *) mh_arg2;
     107             : #else
     108             :         char *base = (char *) ts_resource(*((int *) mh_arg2));
     109             : #endif
     110             : 
     111             :         /* keep the compiler happy */
     112             :         (void)entry; (void)mh_arg2; (void)mh_arg3; (void)stage;
     113             : 
     114       24499 :         p = (zend_long *) (base + (size_t)mh_arg1);
     115       24499 :         memsize = atoi(ZSTR_VAL(new_value));
     116             :         /* sanity check we must use at least 8 MB */
     117       24499 :         if (memsize < 8) {
     118           0 :                 const char *new_new_value = "8";
     119             :                 zend_ini_entry *ini_entry;
     120             : 
     121           0 :                 memsize = 8;
     122           0 :                 zend_accel_error(ACCEL_LOG_WARNING, "opcache.memory_consumption is set below the required 8MB.\n");
     123           0 :                 zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use the minimal 8MB configuration.\n");
     124             : 
     125           0 :                 if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives),
     126             :                                         "opcache.memory_consumption",
     127             :                                         sizeof("opcache.memory_consumption")-1)) == NULL) {
     128           0 :                         return FAILURE;
     129             :                 }
     130             : 
     131           0 :                 ini_entry->value = zend_string_init(new_new_value, 1, 1);
     132             :         }
     133       24499 :         if (UNEXPECTED(memsize > ZEND_ULONG_MAX / (1024 * 1024))) {
     134           0 :                 *p = ZEND_ULONG_MAX;
     135             :         } else {
     136       24499 :                 *p = memsize * (1024 * 1024);
     137             :         }
     138       24499 :         return SUCCESS;
     139             : }
     140             : 
     141       24499 : static ZEND_INI_MH(OnUpdateMaxAcceleratedFiles)
     142             : {
     143             :         zend_long *p;
     144             :         zend_long size;
     145             : #ifndef ZTS
     146       24499 :         char *base = (char *) mh_arg2;
     147             : #else
     148             :         char *base = (char *) ts_resource(*((int *) mh_arg2));
     149             : #endif
     150             : 
     151             :         /* keep the compiler happy */
     152             :         (void)entry; (void)mh_arg2; (void)mh_arg3; (void)stage;
     153             : 
     154       24499 :         p = (zend_long *) (base + (size_t)mh_arg1);
     155       24499 :         size = atoi(ZSTR_VAL(new_value));
     156             :         /* sanity check we must use a value between MIN_ACCEL_FILES and MAX_ACCEL_FILES */
     157             : 
     158       24499 :         if (size < MIN_ACCEL_FILES || size > MAX_ACCEL_FILES) {
     159             :                 const char *new_new_value;
     160             :                 zend_ini_entry *ini_entry;
     161             : 
     162           0 :                 if (size < MIN_ACCEL_FILES) {
     163           0 :                         size = MIN_ACCEL_FILES;
     164           0 :                         new_new_value = TOKENTOSTR(MIN_ACCEL_FILES);
     165           0 :                         zend_accel_error(ACCEL_LOG_WARNING, "opcache.max_accelerated_files is set below the required minimum (%d).\n", MIN_ACCEL_FILES);
     166           0 :                         zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use the minimal configuration.\n");
     167             :                 }
     168           0 :                 if (size > MAX_ACCEL_FILES) {
     169           0 :                         size = MAX_ACCEL_FILES;
     170           0 :                         new_new_value = TOKENTOSTR(MAX_ACCEL_FILES);
     171           0 :                         zend_accel_error(ACCEL_LOG_WARNING, "opcache.max_accelerated_files is set above the limit (%d).\n", MAX_ACCEL_FILES);
     172           0 :                         zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use the maximal configuration.\n");
     173             :                 }
     174           0 :                 if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives),
     175             :                                         "opcache.max_accelerated_files",
     176             :                                         sizeof("opcache.max_accelerated_files")-1)) == NULL) {
     177           0 :                         return FAILURE;
     178             :                 }
     179           0 :                 ini_entry->value = zend_string_init(new_new_value, strlen(new_new_value), 1);
     180             :         }
     181       24499 :         *p = size;
     182       24499 :         return SUCCESS;
     183             : }
     184             : 
     185       24499 : static ZEND_INI_MH(OnUpdateMaxWastedPercentage)
     186             : {
     187             :         double *p;
     188             :         zend_long percentage;
     189             : #ifndef ZTS
     190       24499 :         char *base = (char *) mh_arg2;
     191             : #else
     192             :         char *base = (char *) ts_resource(*((int *) mh_arg2));
     193             : #endif
     194             : 
     195             :         /* keep the compiler happy */
     196             :         (void)entry; (void)mh_arg2; (void)mh_arg3; (void)stage;
     197             : 
     198       24499 :         p = (double *) (base + (size_t)mh_arg1);
     199       24499 :         percentage = atoi(ZSTR_VAL(new_value));
     200             : 
     201       24499 :         if (percentage <= 0 || percentage > 50) {
     202           0 :                 const char *new_new_value = "5";
     203             :                 zend_ini_entry *ini_entry;
     204             : 
     205           0 :                 percentage = 5;
     206           0 :                 zend_accel_error(ACCEL_LOG_WARNING, "opcache.max_wasted_percentage must be set between 1 and 50.\n");
     207           0 :                 zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use 5%%.\n");
     208           0 :                 if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives),
     209             :                                         "opcache.max_wasted_percentage",
     210             :                                         sizeof("opcache.max_wasted_percentage")-1)) == NULL) {
     211           0 :                         return FAILURE;
     212             :                 }
     213           0 :                 ini_entry->value = zend_string_init(new_new_value, strlen(new_new_value), 1);
     214             :         }
     215       24499 :         *p = (double)percentage / 100.0;
     216       24499 :         return SUCCESS;
     217             : }
     218             : 
     219       24499 : static ZEND_INI_MH(OnEnable)
     220             : {
     221       24499 :         if (stage == ZEND_INI_STAGE_STARTUP ||
     222           0 :             stage == ZEND_INI_STAGE_SHUTDOWN ||
     223             :             stage == ZEND_INI_STAGE_DEACTIVATE) {
     224       24499 :                 return OnUpdateBool(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
     225             :         } else {
     226             :                 /* It may be only temporary disabled */
     227             :                 zend_bool *p;
     228             : #ifndef ZTS
     229           0 :                 char *base = (char *) mh_arg2;
     230             : #else
     231             :                 char *base = (char *) ts_resource(*((int *) mh_arg2));
     232             : #endif
     233             : 
     234           0 :                 p = (zend_bool *) (base+(size_t) mh_arg1);
     235           0 :                 if ((ZSTR_LEN(new_value) == 2 && strcasecmp("on", ZSTR_VAL(new_value)) == 0) ||
     236           0 :                     (ZSTR_LEN(new_value) == 3 && strcasecmp("yes", ZSTR_VAL(new_value)) == 0) ||
     237           0 :                     (ZSTR_LEN(new_value) == 4 && strcasecmp("true", ZSTR_VAL(new_value)) == 0) ||
     238           0 :                         atoi(ZSTR_VAL(new_value)) != 0) {
     239           0 :                         zend_error(E_WARNING, ACCELERATOR_PRODUCT_NAME " can't be temporary enabled (it may be only disabled till the end of request)");
     240           0 :                         return FAILURE;
     241             :                 } else {
     242           0 :                         *p = 0;
     243           0 :                         return SUCCESS;
     244             :                 }
     245             :         }
     246             : }
     247             : 
     248             : #ifdef HAVE_OPCACHE_FILE_CACHE
     249       24499 : static ZEND_INI_MH(OnUpdateFileCache)
     250             : {
     251       24499 :         if (new_value) {
     252        9641 :                 if (!ZSTR_LEN(new_value)) {
     253        9639 :                         new_value = NULL;
     254             :                 } else {
     255             :                         zend_stat_t buf;
     256             : 
     257           4 :                     if (!IS_ABSOLUTE_PATH(ZSTR_VAL(new_value), ZSTR_LEN(new_value)) ||
     258           4 :                             zend_stat(ZSTR_VAL(new_value), &buf) != 0 ||
     259           4 :                             !S_ISDIR(buf.st_mode) ||
     260             : #ifndef ZEND_WIN32
     261           2 :                                 access(ZSTR_VAL(new_value), R_OK | W_OK | X_OK) != 0) {
     262             : #else
     263             :                                 _access(ZSTR_VAL(new_value), 06) != 0) {
     264             : #endif
     265           0 :                                 zend_accel_error(ACCEL_LOG_WARNING, "opcache.file_cache must be a full path of accessable directory.\n");
     266           0 :                                 new_value = NULL;
     267             :                         }
     268             :                 }
     269             :         }
     270       24499 :         OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
     271       24499 :         return SUCCESS;
     272             : }
     273             : #endif
     274             : 
     275             : ZEND_INI_BEGIN()
     276             :         STD_PHP_INI_BOOLEAN("opcache.enable"             , "1", PHP_INI_ALL,    OnEnable,     enabled                             , zend_accel_globals, accel_globals)
     277             :         STD_PHP_INI_BOOLEAN("opcache.use_cwd"            , "1", PHP_INI_SYSTEM, OnUpdateBool, accel_directives.use_cwd            , zend_accel_globals, accel_globals)
     278             :         STD_PHP_INI_BOOLEAN("opcache.validate_timestamps", "1", PHP_INI_ALL   , OnUpdateBool, accel_directives.validate_timestamps, zend_accel_globals, accel_globals)
     279             :         STD_PHP_INI_BOOLEAN("opcache.validate_permission", "0", PHP_INI_SYSTEM, OnUpdateBool, accel_directives.validate_permission, zend_accel_globals, accel_globals)
     280             : #ifndef ZEND_WIN32
     281             :         STD_PHP_INI_BOOLEAN("opcache.validate_root"      , "0", PHP_INI_SYSTEM, OnUpdateBool, accel_directives.validate_root      , zend_accel_globals, accel_globals)
     282             : #endif
     283             :         STD_PHP_INI_BOOLEAN("opcache.inherited_hack"     , "1", PHP_INI_SYSTEM, OnUpdateBool, accel_directives.inherited_hack     , zend_accel_globals, accel_globals)
     284             :         STD_PHP_INI_BOOLEAN("opcache.dups_fix"           , "0", PHP_INI_ALL   , OnUpdateBool, accel_directives.ignore_dups        , zend_accel_globals, accel_globals)
     285             :         STD_PHP_INI_BOOLEAN("opcache.revalidate_path"    , "0", PHP_INI_ALL   , OnUpdateBool, accel_directives.revalidate_path    , zend_accel_globals, accel_globals)
     286             : 
     287             :         STD_PHP_INI_ENTRY("opcache.log_verbosity_level"   , "1"   , PHP_INI_SYSTEM, OnUpdateLong, accel_directives.log_verbosity_level,       zend_accel_globals, accel_globals)
     288             :         STD_PHP_INI_ENTRY("opcache.memory_consumption"    , "128"  , PHP_INI_SYSTEM, OnUpdateMemoryConsumption,    accel_directives.memory_consumption,        zend_accel_globals, accel_globals)
     289             :         STD_PHP_INI_ENTRY("opcache.interned_strings_buffer", "8"  , PHP_INI_SYSTEM, OnUpdateLong,                 accel_directives.interned_strings_buffer,   zend_accel_globals, accel_globals)
     290             :         STD_PHP_INI_ENTRY("opcache.max_accelerated_files" , "10000", PHP_INI_SYSTEM, OnUpdateMaxAcceleratedFiles,    accel_directives.max_accelerated_files,     zend_accel_globals, accel_globals)
     291             :         STD_PHP_INI_ENTRY("opcache.max_wasted_percentage" , "5"   , PHP_INI_SYSTEM, OnUpdateMaxWastedPercentage,     accel_directives.max_wasted_percentage,     zend_accel_globals, accel_globals)
     292             :         STD_PHP_INI_ENTRY("opcache.consistency_checks"    , "0"   , PHP_INI_ALL   , OnUpdateLong,                accel_directives.consistency_checks,        zend_accel_globals, accel_globals)
     293             :         STD_PHP_INI_ENTRY("opcache.force_restart_timeout" , "180" , PHP_INI_SYSTEM, OnUpdateLong,                accel_directives.force_restart_timeout,     zend_accel_globals, accel_globals)
     294             :         STD_PHP_INI_ENTRY("opcache.revalidate_freq"       , "2"   , PHP_INI_ALL   , OnUpdateLong,                accel_directives.revalidate_freq,           zend_accel_globals, accel_globals)
     295             :         STD_PHP_INI_ENTRY("opcache.file_update_protection", "2"   , PHP_INI_ALL   , OnUpdateLong,                accel_directives.file_update_protection,    zend_accel_globals, accel_globals)
     296             :         STD_PHP_INI_ENTRY("opcache.preferred_memory_model", ""    , PHP_INI_SYSTEM, OnUpdateStringUnempty,       accel_directives.memory_model,              zend_accel_globals, accel_globals)
     297             :         STD_PHP_INI_ENTRY("opcache.blacklist_filename"    , ""    , PHP_INI_SYSTEM, OnUpdateString,              accel_directives.user_blacklist_filename,   zend_accel_globals, accel_globals)
     298             :         STD_PHP_INI_ENTRY("opcache.max_file_size"         , "0"   , PHP_INI_SYSTEM, OnUpdateLong,                accel_directives.max_file_size,             zend_accel_globals, accel_globals)
     299             : 
     300             :         STD_PHP_INI_ENTRY("opcache.protect_memory"        , "0"  , PHP_INI_SYSTEM, OnUpdateBool,                  accel_directives.protect_memory,            zend_accel_globals, accel_globals)
     301             :         STD_PHP_INI_ENTRY("opcache.save_comments"         , "1"  , PHP_INI_SYSTEM, OnUpdateBool,                  accel_directives.save_comments,             zend_accel_globals, accel_globals)
     302             :         STD_PHP_INI_ENTRY("opcache.fast_shutdown"         , "0"  , PHP_INI_SYSTEM, OnUpdateBool,                  accel_directives.fast_shutdown,             zend_accel_globals, accel_globals)
     303             : 
     304             :         STD_PHP_INI_ENTRY("opcache.optimization_level"    , DEFAULT_OPTIMIZATION_LEVEL , PHP_INI_SYSTEM, OnUpdateLong, accel_directives.optimization_level,   zend_accel_globals, accel_globals)
     305             :         STD_PHP_INI_ENTRY("opcache.opt_debug_level"       , "0"      , PHP_INI_SYSTEM, OnUpdateLong,             accel_directives.opt_debug_level,            zend_accel_globals, accel_globals)
     306             :         STD_PHP_INI_BOOLEAN("opcache.enable_file_override"    , "0"   , PHP_INI_SYSTEM, OnUpdateBool,              accel_directives.file_override_enabled,     zend_accel_globals, accel_globals)
     307             :         STD_PHP_INI_BOOLEAN("opcache.enable_cli"             , "0"   , PHP_INI_SYSTEM, OnUpdateBool,              accel_directives.enable_cli,                zend_accel_globals, accel_globals)
     308             :         STD_PHP_INI_ENTRY("opcache.error_log"                , ""    , PHP_INI_SYSTEM, OnUpdateString,               accel_directives.error_log,                 zend_accel_globals, accel_globals)
     309             :         STD_PHP_INI_ENTRY("opcache.restrict_api"             , ""    , PHP_INI_SYSTEM, OnUpdateString,               accel_directives.restrict_api,              zend_accel_globals, accel_globals)
     310             : 
     311             : #ifndef ZEND_WIN32
     312             :         STD_PHP_INI_ENTRY("opcache.lockfile_path"             , "/tmp"    , PHP_INI_SYSTEM, OnUpdateString,           accel_directives.lockfile_path,              zend_accel_globals, accel_globals)
     313             : #else
     314             :         STD_PHP_INI_ENTRY("opcache.mmap_base", NULL, PHP_INI_SYSTEM,  OnUpdateString,                              accel_directives.mmap_base,                 zend_accel_globals, accel_globals)
     315             : #endif
     316             : 
     317             : #ifdef HAVE_OPCACHE_FILE_CACHE
     318             :         STD_PHP_INI_ENTRY("opcache.file_cache"                    , NULL  , PHP_INI_SYSTEM, OnUpdateFileCache, accel_directives.file_cache,                    zend_accel_globals, accel_globals)
     319             :         STD_PHP_INI_ENTRY("opcache.file_cache_only"               , "0"   , PHP_INI_SYSTEM, OnUpdateBool,      accel_directives.file_cache_only,               zend_accel_globals, accel_globals)
     320             :         STD_PHP_INI_ENTRY("opcache.file_cache_consistency_checks" , "1"   , PHP_INI_SYSTEM, OnUpdateBool,      accel_directives.file_cache_consistency_checks, zend_accel_globals, accel_globals)
     321             : #endif
     322             : #if ENABLE_FILE_CACHE_FALLBACK
     323             :         STD_PHP_INI_ENTRY("opcache.file_cache_fallback"           , "1"   , PHP_INI_SYSTEM, OnUpdateBool,      accel_directives.file_cache_fallback,           zend_accel_globals, accel_globals)
     324             : #endif
     325             : #ifdef HAVE_HUGE_CODE_PAGES
     326             :         STD_PHP_INI_BOOLEAN("opcache.huge_code_pages"             , "0"   , PHP_INI_SYSTEM, OnUpdateBool,      accel_directives.huge_code_pages,               zend_accel_globals, accel_globals)
     327             : #endif
     328             : ZEND_INI_END()
     329             : 
     330           5 : static int filename_is_in_cache(zend_string *filename)
     331             : {
     332             :         char *key;
     333             :         int key_length;
     334             : 
     335           5 :         key = accel_make_persistent_key(ZSTR_VAL(filename), ZSTR_LEN(filename), &key_length);
     336           5 :         if (key != NULL) {
     337           5 :                 zend_persistent_script *persistent_script = zend_accel_hash_str_find(&ZCSG(hash), key, key_length);
     338           5 :                 if (persistent_script && !persistent_script->corrupted) {
     339           3 :                         zend_file_handle handle = {{0}, NULL, NULL, 0, 0};
     340             : 
     341           3 :                         handle.filename = ZSTR_VAL(filename);
     342           3 :                         handle.type = ZEND_HANDLE_FILENAME;
     343             : 
     344           3 :                         if (ZCG(accel_directives).validate_timestamps) {
     345           2 :                                 return validate_timestamp_and_record_ex(persistent_script, &handle) == SUCCESS;
     346             :                         }
     347             : 
     348           1 :                         return 1;
     349             :                 }
     350             :         }
     351             : 
     352           2 :         return 0;
     353             : }
     354             : 
     355           1 : static int accel_file_in_cache(INTERNAL_FUNCTION_PARAMETERS)
     356             : {
     357             :         zval zfilename;
     358             : 
     359           2 :         if (ZEND_NUM_ARGS() != 1 ||
     360           2 :             zend_get_parameters_array_ex(1, &zfilename) == FAILURE ||
     361           2 :             Z_TYPE(zfilename) != IS_STRING ||
     362           1 :             Z_STRLEN(zfilename) == 0) {
     363           0 :                 return 0;
     364             :         }
     365           1 :         return filename_is_in_cache(Z_STR(zfilename));
     366             : }
     367             : 
     368           0 : static void accel_file_exists(INTERNAL_FUNCTION_PARAMETERS)
     369             : {
     370           0 :         if (accel_file_in_cache(INTERNAL_FUNCTION_PARAM_PASSTHRU)) {
     371           0 :                 RETURN_TRUE;
     372             :         } else {
     373           0 :                 orig_file_exists(INTERNAL_FUNCTION_PARAM_PASSTHRU);
     374             :         }
     375             : }
     376             : 
     377           1 : static void accel_is_file(INTERNAL_FUNCTION_PARAMETERS)
     378             : {
     379           1 :         if (accel_file_in_cache(INTERNAL_FUNCTION_PARAM_PASSTHRU)) {
     380           1 :                 RETURN_TRUE;
     381             :         } else {
     382           0 :                 orig_is_file(INTERNAL_FUNCTION_PARAM_PASSTHRU);
     383             :         }
     384             : }
     385             : 
     386           0 : static void accel_is_readable(INTERNAL_FUNCTION_PARAMETERS)
     387             : {
     388           0 :         if (accel_file_in_cache(INTERNAL_FUNCTION_PARAM_PASSTHRU)) {
     389           0 :                 RETURN_TRUE;
     390             :         } else {
     391           0 :                 orig_is_readable(INTERNAL_FUNCTION_PARAM_PASSTHRU);
     392             :         }
     393             : }
     394             : 
     395       24499 : static ZEND_MINIT_FUNCTION(zend_accelerator)
     396             : {
     397             :         (void)type; /* keep the compiler happy */
     398             : 
     399       24499 :         REGISTER_INI_ENTRIES();
     400             : 
     401       24499 :         return SUCCESS;
     402             : }
     403             : 
     404         501 : void zend_accel_override_file_functions(void)
     405             : {
     406             :         zend_function *old_function;
     407         501 :         if (ZCG(enabled) && accel_startup_ok && ZCG(accel_directives).file_override_enabled) {
     408             : #ifdef HAVE_OPCACHE_FILE_CACHE
     409           2 :                 if (file_cache_only) {
     410           0 :                         zend_accel_error(ACCEL_LOG_WARNING, "file_override_enabled has no effect when file_cache_only is set");
     411           0 :                         return;
     412             :                 }
     413             : #endif
     414             :                 /* override file_exists */
     415           4 :                 if ((old_function = zend_hash_str_find_ptr(CG(function_table), "file_exists", sizeof("file_exists")-1)) != NULL) {
     416           2 :                         orig_file_exists = old_function->internal_function.handler;
     417           2 :                         old_function->internal_function.handler = accel_file_exists;
     418             :                 }
     419           4 :                 if ((old_function = zend_hash_str_find_ptr(CG(function_table), "is_file", sizeof("is_file")-1)) != NULL) {
     420           2 :                         orig_is_file = old_function->internal_function.handler;
     421           2 :                         old_function->internal_function.handler = accel_is_file;
     422             :                 }
     423           4 :                 if ((old_function = zend_hash_str_find_ptr(CG(function_table), "is_readable", sizeof("is_readable")-1)) != NULL) {
     424           2 :                         orig_is_readable = old_function->internal_function.handler;
     425           2 :                         old_function->internal_function.handler = accel_is_readable;
     426             :                 }
     427             :         }
     428             : }
     429             : 
     430       24495 : static ZEND_MSHUTDOWN_FUNCTION(zend_accelerator)
     431             : {
     432             :         (void)type; /* keep the compiler happy */
     433             : 
     434       24495 :         UNREGISTER_INI_ENTRIES();
     435       24495 :         accel_shutdown();
     436       24495 :         return SUCCESS;
     437             : }
     438             : 
     439         145 : void zend_accel_info(ZEND_MODULE_INFO_FUNC_ARGS)
     440             : {
     441         145 :         php_info_print_table_start();
     442             : 
     443         146 :         if (ZCG(enabled) && accel_startup_ok &&
     444             : #ifdef HAVE_OPCACHE_FILE_CACHE
     445           1 :                 ((ZCG(counted) || ZCSG(accelerator_enabled)) || file_cache_only)
     446             : #else
     447             :                 (ZCG(counted) || ZCSG(accelerator_enabled))
     448             : #endif
     449             :         ) {
     450           1 :                 php_info_print_table_row(2, "Opcode Caching", "Up and Running");
     451             :         } else {
     452         144 :                 php_info_print_table_row(2, "Opcode Caching", "Disabled");
     453             :         }
     454         145 :         if (ZCG(enabled) && accel_startup_ok && ZCG(accel_directives).optimization_level) {
     455           1 :                 php_info_print_table_row(2, "Optimization", "Enabled");
     456             :         } else {
     457         144 :                 php_info_print_table_row(2, "Optimization", "Disabled");
     458             :         }
     459             : #ifdef HAVE_OPCACHE_FILE_CACHE
     460         145 :         if (!file_cache_only) {
     461         145 :                 php_info_print_table_row(2, "SHM Cache", "Enabled");
     462             :         } else {
     463           0 :                 php_info_print_table_row(2, "SHM Cache", "Disabled");
     464             :         }
     465         145 :         if (ZCG(accel_directives).file_cache) {
     466           0 :                 php_info_print_table_row(2, "File Cache", "Enabled");
     467             :         } else {
     468         145 :                 php_info_print_table_row(2, "File Cache", "Disabled");
     469             :         }
     470         145 :         if (file_cache_only) {
     471           0 :                 if (!accel_startup_ok || zps_api_failure_reason) {
     472           0 :                         php_info_print_table_row(2, "Startup Failed", zps_api_failure_reason);
     473             :                 } else {
     474           0 :                         php_info_print_table_row(2, "Startup", "OK");
     475             :                 }
     476             :         } else
     477             : #endif
     478         145 :         if (ZCG(enabled)) {
     479         145 :                 if (!accel_startup_ok || zps_api_failure_reason) {
     480         144 :                         php_info_print_table_row(2, "Startup Failed", zps_api_failure_reason);
     481             :                 } else {
     482             :                         char buf[32];
     483           1 :                         php_info_print_table_row(2, "Startup", "OK");
     484           1 :                         php_info_print_table_row(2, "Shared memory model", zend_accel_get_shared_model());
     485           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, (zend_ulong)ZCSG(hits));
     486           1 :                         php_info_print_table_row(2, "Cache hits", buf);
     487           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZSMMG(memory_exhausted)?ZCSG(misses):ZCSG(misses)-ZCSG(blacklist_misses));
     488           1 :                         php_info_print_table_row(2, "Cache misses", buf);
     489           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCG(accel_directives).memory_consumption-zend_shared_alloc_get_free_memory()-ZSMMG(wasted_shared_memory));
     490           1 :                         php_info_print_table_row(2, "Used memory", buf);
     491           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, zend_shared_alloc_get_free_memory());
     492           1 :                         php_info_print_table_row(2, "Free memory", buf);
     493           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZSMMG(wasted_shared_memory));
     494           1 :                         php_info_print_table_row(2, "Wasted memory", buf);
     495           1 :                         if (ZCSG(interned_strings_start) && ZCSG(interned_strings_end) && ZCSG(interned_strings_top)) {
     496           1 :                                 snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCSG(interned_strings_top) - ZCSG(interned_strings_start));
     497           1 :                                 php_info_print_table_row(2, "Interned Strings Used memory", buf);
     498           1 :                                 snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCSG(interned_strings_end) - ZCSG(interned_strings_top));
     499           1 :                                 php_info_print_table_row(2, "Interned Strings Free memory", buf);
     500             :                         }
     501           1 :                         snprintf(buf, sizeof(buf), "%d", ZCSG(hash).num_direct_entries);
     502           1 :                         php_info_print_table_row(2, "Cached scripts", buf);
     503           1 :                         snprintf(buf, sizeof(buf), "%d", ZCSG(hash).num_entries);
     504           1 :                         php_info_print_table_row(2, "Cached keys", buf);
     505           1 :                         snprintf(buf, sizeof(buf), "%d", ZCSG(hash).max_num_entries);
     506           1 :                         php_info_print_table_row(2, "Max keys", buf);
     507           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCSG(oom_restarts));
     508           1 :                         php_info_print_table_row(2, "OOM restarts", buf);
     509           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCSG(hash_restarts));
     510           1 :                         php_info_print_table_row(2, "Hash keys restarts", buf);
     511           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCSG(manual_restarts));
     512           1 :                         php_info_print_table_row(2, "Manual restarts", buf);
     513             :                 }
     514             :         }
     515             : 
     516         145 :         php_info_print_table_end();
     517         145 :         DISPLAY_INI_ENTRIES();
     518         145 : }
     519             : 
     520             : static zend_module_entry accel_module_entry = {
     521             :         STANDARD_MODULE_HEADER,
     522             :         ACCELERATOR_PRODUCT_NAME,
     523             :         accel_functions,
     524             :         ZEND_MINIT(zend_accelerator),
     525             :         ZEND_MSHUTDOWN(zend_accelerator),
     526             :         NULL,
     527             :         NULL,
     528             :         zend_accel_info,
     529             :         PHP_VERSION,
     530             :         NO_MODULE_GLOBALS,
     531             :         accel_post_deactivate,
     532             :         STANDARD_MODULE_PROPERTIES_EX
     533             : };
     534             : 
     535       24499 : int start_accel_module(void)
     536             : {
     537       24499 :         return zend_startup_module(&accel_module_entry);
     538             : }
     539             : 
     540             : /* {{{ proto array accelerator_get_scripts()
     541             :    Get the scripts which are accelerated by ZendAccelerator */
     542           2 : static int accelerator_get_scripts(zval *return_value)
     543             : {
     544             :         uint i;
     545             :         zval persistent_script_report;
     546             :         zend_accel_hash_entry *cache_entry;
     547             :         struct tm *ta;
     548             :         struct timeval exec_time;
     549             :         struct timeval fetch_time;
     550             : 
     551           2 :         if (!ZCG(enabled) || !accel_startup_ok || !ZCSG(accelerator_enabled) || accelerator_shm_read_lock() != SUCCESS) {
     552           0 :                 return 0;
     553             :         }
     554             : 
     555           2 :         array_init(return_value);
     556       32460 :         for (i = 0; i<ZCSG(hash).max_num_entries; i++) {
     557       32460 :                 for (cache_entry = ZCSG(hash).hash_table[i]; cache_entry; cache_entry = cache_entry->next) {
     558             :                         zend_persistent_script *script;
     559             :                         char *str;
     560             :                         size_t len;
     561             : 
     562           2 :                         if (cache_entry->indirect) continue;
     563             : 
     564           2 :                         script = (zend_persistent_script *)cache_entry->data;
     565             : 
     566           2 :                         array_init(&persistent_script_report);
     567           4 :                         add_assoc_str(&persistent_script_report, "full_path", zend_string_dup(script->script.filename, 0));
     568           2 :                         add_assoc_long(&persistent_script_report, "hits", (zend_long)script->dynamic_members.hits);
     569           2 :                         add_assoc_long(&persistent_script_report, "memory_consumption", script->dynamic_members.memory_consumption);
     570           2 :                         ta = localtime(&script->dynamic_members.last_used);
     571           2 :                         str = asctime(ta);
     572           2 :                         len = strlen(str);
     573           2 :                         if (len > 0 && str[len - 1] == '\n') len--;
     574           2 :                         add_assoc_stringl(&persistent_script_report, "last_used", str, len);
     575           2 :                         add_assoc_long(&persistent_script_report, "last_used_timestamp", script->dynamic_members.last_used);
     576           2 :                         if (ZCG(accel_directives).validate_timestamps) {
     577           2 :                                 add_assoc_long(&persistent_script_report, "timestamp", (zend_long)script->timestamp);
     578             :                         }
     579           2 :                         timerclear(&exec_time);
     580           2 :                         timerclear(&fetch_time);
     581             : 
     582           2 :                         zend_hash_str_update(Z_ARRVAL_P(return_value), cache_entry->key, cache_entry->key_length, &persistent_script_report);
     583             :                 }
     584             :         }
     585           2 :         accelerator_shm_read_unlock();
     586             : 
     587           2 :         return 1;
     588             : }
     589             : 
     590             : /* {{{ proto array accelerator_get_status([bool fetch_scripts])
     591             :    Obtain statistics information regarding code acceleration */
     592          11 : static ZEND_FUNCTION(opcache_get_status)
     593             : {
     594             :         zend_long reqs;
     595             :         zval memory_usage, statistics, scripts;
     596          11 :         zend_bool fetch_scripts = 1;
     597             : 
     598          11 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &fetch_scripts) == FAILURE) {
     599           9 :                 return;
     600             :         }
     601             : 
     602          11 :         if (!validate_api_restriction()) {
     603           0 :                 RETURN_FALSE;
     604             :         }
     605             : 
     606          11 :         if (!accel_startup_ok) {
     607           9 :                 RETURN_FALSE;
     608             :         }
     609             : 
     610           2 :         array_init(return_value);
     611             : 
     612             :         /* Trivia */
     613           2 :         add_assoc_bool(return_value, "opcache_enabled", ZCG(enabled) && (ZCG(counted) || ZCSG(accelerator_enabled)));
     614             : 
     615             : #ifdef HAVE_OPCACHE_FILE_CACHE
     616           2 :         if (ZCG(accel_directives).file_cache) {
     617           0 :                 add_assoc_string(return_value, "file_cache", ZCG(accel_directives).file_cache);
     618             :         }
     619           2 :         if (file_cache_only) {
     620           0 :                 add_assoc_bool(return_value, "file_cache_only", 1);
     621           0 :                 return;
     622             :         }
     623             : #endif
     624             : 
     625           2 :         add_assoc_bool(return_value, "cache_full", ZSMMG(memory_exhausted));
     626           2 :         add_assoc_bool(return_value, "restart_pending", ZCSG(restart_pending));
     627           2 :         add_assoc_bool(return_value, "restart_in_progress", ZCSG(restart_in_progress));
     628             : 
     629             :         /* Memory usage statistics */
     630           2 :         array_init(&memory_usage);
     631           2 :         add_assoc_long(&memory_usage, "used_memory", ZCG(accel_directives).memory_consumption-zend_shared_alloc_get_free_memory()-ZSMMG(wasted_shared_memory));
     632           2 :         add_assoc_long(&memory_usage, "free_memory", zend_shared_alloc_get_free_memory());
     633           2 :         add_assoc_long(&memory_usage, "wasted_memory", ZSMMG(wasted_shared_memory));
     634           2 :         add_assoc_double(&memory_usage, "current_wasted_percentage", (((double) ZSMMG(wasted_shared_memory))/ZCG(accel_directives).memory_consumption)*100.0);
     635           2 :         add_assoc_zval(return_value, "memory_usage", &memory_usage);
     636             : 
     637           2 :         if (ZCSG(interned_strings_start) && ZCSG(interned_strings_end) && ZCSG(interned_strings_top)) {
     638             :                 zval interned_strings_usage;
     639             : 
     640           2 :                 array_init(&interned_strings_usage);
     641           2 :                 add_assoc_long(&interned_strings_usage, "buffer_size", ZCSG(interned_strings_end) - ZCSG(interned_strings_start));
     642           2 :                 add_assoc_long(&interned_strings_usage, "used_memory", ZCSG(interned_strings_top) - ZCSG(interned_strings_start));
     643           2 :                 add_assoc_long(&interned_strings_usage, "free_memory", ZCSG(interned_strings_end) - ZCSG(interned_strings_top));
     644           2 :                 add_assoc_long(&interned_strings_usage, "number_of_strings", ZCSG(interned_strings).nNumOfElements);
     645           2 :                 add_assoc_zval(return_value, "interned_strings_usage", &interned_strings_usage);
     646             :         }
     647             : 
     648             :         /* Accelerator statistics */
     649           2 :         array_init(&statistics);
     650           2 :         add_assoc_long(&statistics, "num_cached_scripts", ZCSG(hash).num_direct_entries);
     651           2 :         add_assoc_long(&statistics, "num_cached_keys",    ZCSG(hash).num_entries);
     652           2 :         add_assoc_long(&statistics, "max_cached_keys",    ZCSG(hash).max_num_entries);
     653           2 :         add_assoc_long(&statistics, "hits", (zend_long)ZCSG(hits));
     654           2 :         add_assoc_long(&statistics, "start_time", ZCSG(start_time));
     655           2 :         add_assoc_long(&statistics, "last_restart_time", ZCSG(last_restart_time));
     656           2 :         add_assoc_long(&statistics, "oom_restarts", ZCSG(oom_restarts));
     657           2 :         add_assoc_long(&statistics, "hash_restarts", ZCSG(hash_restarts));
     658           2 :         add_assoc_long(&statistics, "manual_restarts", ZCSG(manual_restarts));
     659           2 :         add_assoc_long(&statistics, "misses", ZSMMG(memory_exhausted)?ZCSG(misses):ZCSG(misses)-ZCSG(blacklist_misses));
     660           2 :         add_assoc_long(&statistics, "blacklist_misses", ZCSG(blacklist_misses));
     661           2 :         reqs = ZCSG(hits)+ZCSG(misses);
     662           2 :         add_assoc_double(&statistics, "blacklist_miss_ratio", reqs?(((double) ZCSG(blacklist_misses))/reqs)*100.0:0);
     663           2 :         add_assoc_double(&statistics, "opcache_hit_rate", reqs?(((double) ZCSG(hits))/reqs)*100.0:0);
     664           2 :         add_assoc_zval(return_value, "opcache_statistics", &statistics);
     665             : 
     666           2 :         if (fetch_scripts) {
     667             :                 /* accelerated scripts */
     668           2 :                 if (accelerator_get_scripts(&scripts)) {
     669           2 :                         add_assoc_zval(return_value, "scripts", &scripts);
     670             :                 }
     671             :         }
     672             : }
     673             : 
     674           7 : static int add_blacklist_path(zend_blacklist_entry *p, zval *return_value)
     675             : {
     676           7 :         add_next_index_stringl(return_value, p->path, p->path_length);
     677           7 :         return 0;
     678             : }
     679             : 
     680             : /* {{{ proto array accelerator_get_configuration()
     681             :    Obtain configuration information */
     682           2 : static ZEND_FUNCTION(opcache_get_configuration)
     683             : {
     684             :         zval directives, version, blacklist;
     685             : 
     686           2 :         if (zend_parse_parameters_none() == FAILURE) {
     687           0 :                 RETURN_FALSE;
     688             :         }
     689             : 
     690           2 :         if (!validate_api_restriction()) {
     691           0 :                 RETURN_FALSE;
     692             :         }
     693             : 
     694           2 :         array_init(return_value);
     695             : 
     696             :         /* directives */
     697           2 :         array_init(&directives);
     698           2 :         add_assoc_bool(&directives, "opcache.enable",              ZCG(enabled));
     699           2 :         add_assoc_bool(&directives, "opcache.enable_cli",          ZCG(accel_directives).enable_cli);
     700           2 :         add_assoc_bool(&directives, "opcache.use_cwd",             ZCG(accel_directives).use_cwd);
     701           2 :         add_assoc_bool(&directives, "opcache.validate_timestamps", ZCG(accel_directives).validate_timestamps);
     702           2 :         add_assoc_bool(&directives, "opcache.validate_permission", ZCG(accel_directives).validate_permission);
     703             : #ifndef ZEND_WIN32
     704           2 :         add_assoc_bool(&directives, "opcache.validate_root",       ZCG(accel_directives).validate_root);
     705             : #endif
     706           2 :         add_assoc_bool(&directives, "opcache.inherited_hack",      ZCG(accel_directives).inherited_hack);
     707           2 :         add_assoc_bool(&directives, "opcache.dups_fix",            ZCG(accel_directives).ignore_dups);
     708           2 :         add_assoc_bool(&directives, "opcache.revalidate_path",     ZCG(accel_directives).revalidate_path);
     709             : 
     710           2 :         add_assoc_long(&directives,   "opcache.log_verbosity_level",    ZCG(accel_directives).log_verbosity_level);
     711           2 :         add_assoc_long(&directives,  "opcache.memory_consumption",     ZCG(accel_directives).memory_consumption);
     712           2 :         add_assoc_long(&directives,  "opcache.interned_strings_buffer",ZCG(accel_directives).interned_strings_buffer);
     713           2 :         add_assoc_long(&directives,          "opcache.max_accelerated_files",  ZCG(accel_directives).max_accelerated_files);
     714           2 :         add_assoc_double(&directives, "opcache.max_wasted_percentage",  ZCG(accel_directives).max_wasted_percentage);
     715           2 :         add_assoc_long(&directives,          "opcache.consistency_checks",     ZCG(accel_directives).consistency_checks);
     716           2 :         add_assoc_long(&directives,          "opcache.force_restart_timeout",  ZCG(accel_directives).force_restart_timeout);
     717           2 :         add_assoc_long(&directives,          "opcache.revalidate_freq",        ZCG(accel_directives).revalidate_freq);
     718           2 :         add_assoc_string(&directives, "opcache.preferred_memory_model", STRING_NOT_NULL(ZCG(accel_directives).memory_model));
     719           2 :         add_assoc_string(&directives, "opcache.blacklist_filename",     STRING_NOT_NULL(ZCG(accel_directives).user_blacklist_filename));
     720           2 :         add_assoc_long(&directives,   "opcache.max_file_size",          ZCG(accel_directives).max_file_size);
     721           2 :         add_assoc_string(&directives, "opcache.error_log",              STRING_NOT_NULL(ZCG(accel_directives).error_log));
     722             : 
     723           2 :         add_assoc_bool(&directives,   "opcache.protect_memory",         ZCG(accel_directives).protect_memory);
     724           2 :         add_assoc_bool(&directives,   "opcache.save_comments",          ZCG(accel_directives).save_comments);
     725           2 :         add_assoc_bool(&directives,   "opcache.fast_shutdown",          ZCG(accel_directives).fast_shutdown);
     726           2 :         add_assoc_bool(&directives,   "opcache.enable_file_override",   ZCG(accel_directives).file_override_enabled);
     727           2 :         add_assoc_long(&directives,          "opcache.optimization_level",     ZCG(accel_directives).optimization_level);
     728             : 
     729             : #ifndef ZEND_WIN32
     730           2 :         add_assoc_string(&directives, "opcache.lockfile_path",          STRING_NOT_NULL(ZCG(accel_directives).lockfile_path));
     731             : #endif
     732             : 
     733             : #ifdef HAVE_OPCACHE_FILE_CACHE
     734           2 :         add_assoc_string(&directives, "opcache.file_cache",                    ZCG(accel_directives).file_cache ? ZCG(accel_directives).file_cache : "");
     735           2 :         add_assoc_bool(&directives,   "opcache.file_cache_only",               ZCG(accel_directives).file_cache_only);
     736           2 :         add_assoc_bool(&directives,   "opcache.file_cache_consistency_checks", ZCG(accel_directives).file_cache_consistency_checks);
     737             : #endif
     738             : 
     739           2 :         add_assoc_zval(return_value, "directives", &directives);
     740             : 
     741             :         /*version */
     742           2 :         array_init(&version);
     743           2 :         add_assoc_string(&version, "version", PHP_VERSION);
     744           2 :         add_assoc_string(&version, "opcache_product_name", ACCELERATOR_PRODUCT_NAME);
     745           2 :         add_assoc_zval(return_value, "version", &version);
     746             : 
     747             :         /* blacklist */
     748           2 :         array_init(&blacklist);
     749           2 :         zend_accel_blacklist_apply(&accel_blacklist, add_blacklist_path, &blacklist);
     750           2 :         add_assoc_zval(return_value, "blacklist", &blacklist);
     751             : }
     752             : 
     753             : /* {{{ proto void accelerator_reset()
     754             :    Request that the contents of the opcode cache to be reset */
     755           1 : static ZEND_FUNCTION(opcache_reset)
     756             : {
     757           1 :         if (zend_parse_parameters_none() == FAILURE) {
     758           0 :                 RETURN_FALSE;
     759             :         }
     760             : 
     761           1 :         if (!validate_api_restriction()) {
     762           0 :                 RETURN_FALSE;
     763             :         }
     764             : 
     765           1 :         if ((!ZCG(enabled) || !accel_startup_ok || !ZCSG(accelerator_enabled))
     766             : #if ENABLE_FILE_CACHE_FALLBACK
     767             :         && !fallback_process
     768             : #endif
     769             :         ) {
     770           0 :                 RETURN_FALSE;
     771             :         }
     772             : 
     773           1 :         zend_accel_schedule_restart(ACCEL_RESTART_USER);
     774           1 :         RETURN_TRUE;
     775             : }
     776             : 
     777             : /* {{{ proto void opcache_invalidate(string $script [, bool $force = false])
     778             :    Invalidates cached script (in necessary or forced) */
     779           2 : static ZEND_FUNCTION(opcache_invalidate)
     780             : {
     781             :         char *script_name;
     782             :         size_t script_name_len;
     783           2 :         zend_bool force = 0;
     784             : 
     785           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|b", &script_name, &script_name_len, &force) == FAILURE) {
     786           0 :                 return;
     787             :         }
     788             : 
     789           2 :         if (!validate_api_restriction()) {
     790           0 :                 RETURN_FALSE;
     791             :         }
     792             : 
     793           2 :         if (zend_accel_invalidate(script_name, script_name_len, force) == SUCCESS) {
     794           1 :                 RETURN_TRUE;
     795             :         } else {
     796           1 :                 RETURN_FALSE;
     797             :         }
     798             : }
     799             : 
     800           0 : static ZEND_FUNCTION(opcache_compile_file)
     801             : {
     802             :         char *script_name;
     803             :         size_t script_name_len;
     804             :         zend_file_handle handle;
     805           0 :         zend_op_array *op_array = NULL;
     806           0 :         zend_execute_data *orig_execute_data = NULL;
     807             : 
     808           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &script_name, &script_name_len) == FAILURE) {
     809           0 :                 return;
     810             :         }
     811             : 
     812           0 :         if (!ZCG(enabled) || !accel_startup_ok || !ZCSG(accelerator_enabled)) {
     813           0 :                 zend_error(E_NOTICE, ACCELERATOR_PRODUCT_NAME " seems to be disabled, can't compile file");
     814           0 :                 RETURN_FALSE;
     815             :         }
     816             : 
     817           0 :         handle.filename = script_name;
     818           0 :         handle.free_filename = 0;
     819           0 :         handle.opened_path = NULL;
     820           0 :         handle.type = ZEND_HANDLE_FILENAME;
     821             : 
     822           0 :         orig_execute_data = EG(current_execute_data);
     823             : 
     824           0 :         zend_try {
     825           0 :                 op_array = persistent_compile_file(&handle, ZEND_INCLUDE);
     826           0 :         } zend_catch {
     827           0 :                 EG(current_execute_data) = orig_execute_data;
     828           0 :                 zend_error(E_WARNING, ACCELERATOR_PRODUCT_NAME " could not compile file %s", handle.filename);
     829           0 :         } zend_end_try();
     830             : 
     831           0 :         if(op_array != NULL) {
     832           0 :                 destroy_op_array(op_array);
     833           0 :                 efree(op_array);
     834           0 :                 RETVAL_TRUE;
     835             :         } else {
     836           0 :                 RETVAL_FALSE;
     837             :         }
     838           0 :         zend_destroy_file_handle(&handle);
     839             : }
     840             : 
     841             : /* {{{ proto bool opcache_is_script_cached(string $script)
     842             :    Return true if the script is cached in OPCache, false if it is not cached or if OPCache is not running. */
     843           4 : static ZEND_FUNCTION(opcache_is_script_cached)
     844             : {
     845             :         zend_string *script_name;
     846             : 
     847           4 :         if (!validate_api_restriction()) {
     848           0 :                 RETURN_FALSE;
     849             :         }
     850             : 
     851           4 :         if (!ZCG(enabled) || !accel_startup_ok || !ZCSG(accelerator_enabled)) {
     852           0 :                 RETURN_FALSE;
     853             :         }
     854             : 
     855           4 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &script_name) == FAILURE) {
     856           0 :                 return;
     857             :         }
     858             : 
     859           4 :         RETURN_BOOL(filename_is_in_cache(script_name));
     860             : }

Generated by: LCOV version 1.10

Generated at Sat, 28 Jul 2018 01:57:16 +0000 (23 days ago)

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