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