php.ini PHP configuration file Chinese version (PHP7, PHP8)

;;;;;;;;;;;;;;;;;;
;; about php.ini ;;
;;;;;;;;;;;;;;;;;;
; For server modules, php.ini is read only once, when the server starts. For CGI and CLI, php.ini is read on every call.

; PHP will search for this file in the following order during initialization (stop when it finds one):
; 1. Location specified by the SAPI module:
; (a) PHPIniDir directive in Apache 2.x
; (b) -c command line option in CGI/CLI mode
; (c) php_ini parameters in NSAPI
; (d) PHP_INI_PATH environment variable in THTTPD
; 2. The location specified by the PHPRC environment variable
; 3. The location specified by the Windows registry (search in sequence and stop when found):
; (a) The value of IniFilePath in [HKEY_LOCAL_MACHINE\SOFTWARE\PHP\xyz] (specific to php-xyz version)
; (b) The value of IniFilePath in [HKEY_LOCAL_MACHINE\SOFTWARE\PHP\xy] (specific to php-xy* series versions)
; (c) The value of IniFilePath in [HKEY_LOCAL_MACHINE\SOFTWARE\PHP\x] (specific to the php-x.*.* series version)
; (d) The value of IniFilePath in [HKEY_LOCAL_MACHINE\SOFTWARE\PHP] (not specific to PHP version)
; 4. Current working directory (not applicable to CLI mode)
; [Tip] Apache will change the current working directory to the root directory when it starts, which will cause PHP to try to read php.ini in the root directory.
; 5. The web server directory (for SAPI modules) or the directory where PHP is located (other cases under Windows)
; 6. The location specified by the compile-time option --with-config-file-path or the Windows directory (%SystemRoot% is usually "C:\Windows")

; If php-SAPI.ini exists (such as php-apache2handler.ini, php-fpm-fcgi.ini, php-cli-server.ini, php-cli.ini, etc.),
; then php.ini will be replaced by php-SAPI.ini.

; Latest version:
; php.ini-production
; php.ini-development

;;;;;;;;;;;;
;; grammar;;
;;;;;;;;;;;;
; The syntax of this file is very simple. Blank lines and lines starting with a semicolon are simply ignored.
; Ordinary configuration section headers (e.g. [PHP]) are also simply ignored (even though they may have some meaning in the future).

; A configuration segment like [PATH=/www/mysite] means that it only applies to PHP files in the /www/mysite directory.
; A configuration section such as [HOST=www.example.com] only applies to http://www.example.com The PHP files for your site.
; [Tip] For sites with multiple domain names, the value of the SERVER_NAME parameter (that is, the first domain name in the domain name list) should be used.
; The settings in these two configuration sections cannot be modified at runtime and are not affected by the .user.ini file.
; These two configuration sections only work in CGI/FastCGI mode [FastCGI Protocol Specification Chinese Version] and cannot contain extension and zend_extension instructions.

; The format of the setting instruction is as follows:
; command = value
; "Directives" are case sensitive! So "foo=bar" is not the same as "FOO=bar".
; Unrecognized "commands" will be ignored directly, and unset commands will use their default values.
; "value" can be:
; 1. A string (can be delimited by quotes, e.g. "foo")
; 2. A number (integer or floating point, such as: 0, 1, 34, -1, 33.55)
; 3. A PHP constant (eg: E_ALL, M_PI) (cannot be used outside of php.ini [eg httpd.conf])
; 4. An INI constant (On, Off, Yes, No, None)
; 5. An expression (e.g. E_ALL & ~E_NOTICE)
; [Note 1] You can reference environment variables in "value", such as: "${AUTHOR}.log", ".:${USER}/pear/php"
; [Note 2] You can reference previously set directive values in "value", such as: "${open_basedir}:/new/dir"

; Only bitwise operators, logical negation, and parentheses can be used in expressions:
; | Bitwise OR
; ^ Bitwise exclusive OR (XOR)
; & Bitwise AND
; ~ bitwise NOT
; ! Logical NOT

; Boolean flags are turned on with 1, On, True, Yes, and turned off with 0, Off, False, No.

; An empty string can be represented by writing nothing after the equal sign, or by using the None keyword:
; foo = ; Set foo to an empty string (recommended)
; foo = None ; Set foo to an empty string
; foo = "None" ; Set foo to the string 'None'

; If you want to use constants from dynamic extensions (PHP extensions or Zend extensions) in directive values,
; Then these constants can only be used after loading these dynamic extension instruction lines (extension or zend_extension).

;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Production environment and development environment;;
;;;;;;;;;;;;;;;;;;;;;;;;;;
; PHP provides two reference configurations for production and development environments: php.ini-production and php.ini-development.
; The differences between the two reference configurations are as follows:

;display_errors
; Default Value: On
; Development Value: On
; Production Value: Off

;display_startup_errors
; Default Value: On
; Development Value: On
; Production Value: Off

;error_reporting
; Default Value: E_ALL
; Development Value: E_ALL
; Production Value: E_ALL & ~E_DEPRECATED & ~E_STRICT

;log_errors
; Default Value: Off
; Development Value: On
; Production Value: On

;max_input_time
; Default Value: -1 (Unlimited)
; Development Value: 60 (60 seconds)
; Production Value: 60 (60 seconds)

;output_buffering
; Default Value: Off
; Development Value: 4096
; Production Value: 4096

;register_argc_argv
; Default Value: On
; Development Value: Off
; Production Value: Off

;request_order
; Default Value: None
; Development Value: "GP"
; Production Value: "GP"

;session.gc_divisor
; Default Value: 100
; Development Value: 1000
; Production Value: 1000

;session.sid_bits_per_character
; Default Value: 4
; Development Value: 5
; Production Value: 5

;short_open_tag
; Default Value: On
; Development Value: Off
; Production Value: Off

;variables_order
; Default Value: "EGPCS"
; Development Value: "GPCS"
; Production Value: "GPCS"

;zend.exception_ignore_args
; Default Value: Off
; Development Value: Off
; Production Value: On

;zend.exception_string_param_max_len
; Default Value: 15
; Development Value: 15
; Production Value: 0

;;=========================================================================================
;;=====================================Detailed explanation of configuration instructions========================================
;;=========================================================================================
; The values of each of the following directives are the same as the default values built into PHP-8.0 (also taking into account PHP-7.2 PHP-7.3 PHP-7.4 versions).
; That is, if 'php.ini' does not exist, or you delete some lines, the default values will be the same.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SAPI (Server API) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

[apache2handler]
; The directives in this configuration section only make sense when using PHP as an Apache2 handler module (php_module).
; [Tip] You can use the php_value/php_flag and php_admin_value/php_admin_flag directives in httpd.conf to override the settings in php.ini.

engine = On
; Whether to enable the PHP parsing engine. Generally used to turn on and off the PHP parsing engine based on directories or virtual hosts.

last_modified = Off
; Whether to place the last modification time of the PHP script in the "Last-Modified:" response header.

xbithack = Off
; Whether to parse files as PHP scripts regardless of their extension as long as they have executable bits.

[fpm-fcgi]
; The directives in this configuration section only make sense when using PHP in FPM/FastCGI mode.

cgi.check_shebang_line = On
; Whether to check for a line starting with #! at the top of the script (shebang).
; This shebang is required if the script is to be run both standalone and in PHP CGI mode.
; Setting it to On means that this line will be automatically ignored in CGI mode.

cgi.discard_path = Off
; Whether to allow placing the PHP CGI directory outside the web directory tree to enhance security so that clients cannot bypass .htaccess security protections.

cgi.fix_pathinfo = On
; Whether to provide real PATH_INFO/PATH_TRANSLATED values for CGI (comply with the cgi specification).
; The previous behavior was to set PATH_TRANSLATED to SCRIPT_FILENAME regardless of PATH_INFO.
; Turning this directive on will cause PHP to fix its paths to comply with the CGI specification, otherwise it will still use the old non-compliant behavior.
; You are encouraged to turn this directive on and fix your scripts to use SCRIPT_FILENAME instead of PATH_TRANSLATED .
; [Tip] Even if you use PHP-FPM with Nginx, you should keep this directive On (there are many old articles on the Internet).
; See the cgi specification for more information on PATH_INFO.

cgi.force_redirect = On
; Whether to enable CGI forced redirection. It is strongly recommended to enable it to improve security.
; NOTE: This must be turned off on IIS!

cgi.nph = Off
; Whether to force all requests to send a "Status: 200" status code in CGI mode.

cgi.redirect_status_env =
; If cgi.force_redirect = On and running PHP with something other than Apache,
; You may need to set a cgi redirection environment variable name, and PHP will decide whether to continue execution based on this environment variable.
; Setting this variable may lead to security vulnerabilities, please make sure you know what you are doing before setting it.

cgi.rfc2616_headers = Off
; Specifies which status header PHP should use when sending HTTP response codes.
; Setting it to Off means using headers that comply with the RFC3875 standard (e.g. "Status: 404 Not Found"), which is supported by Apache and other web servers.
; Setting it to On means using headers that comply with the RFC2616 standard (for example, "HTTP/1.0 404 Not found").
; Always keep the default value Off unless you really know what you are doing.

fastcgi.error_header =
; If display_errors = Off and the accessed PHP script contains syntax errors,
; then by default, the user will receive an empty page with a status line of "HTTP/1.1 500 Internal Server Error".
; If you think the default status line is unreasonable, you can use this directive to customize a status line (for example, "HTTP/1.1 550 Server Exploded").

fastcgi.impersonate = Off
; FastCGI in IIS supports the ability to impersonate client security tokens, which enables IIS to define the security context on which runtime requests are based.
; However, Apache does not support this feature. If running in IIS, it should be set to On, otherwise it should be set to Off.

fastcgi.logging = On
; Whether to enable FastCGI logging.

fpm.config =
; Explicitly specify the path to the FPM configuration file (php-fpm.conf)

[cli-server]
; The directives in this configuration section are only valid when using PHP's built-in CLI Web Server.

cli_server.color = Off
; Whether to have the CLI Web Server use colors in terminal output.

[cli]
; The instructions in this configuration section only make sense when using the PHP command line mode (actually setting the readline module).

cli.pager =
; External pager for displaying command line output.

cli.prompt = "\b \>"
; Command line prompt when used interactively.

;;;;;;;;;;;;;;;;;;;
;; Core;;
;;;;;;;;;;;;;;;;;;;

[Core-Language]

short_open_tag = On
; Is it allowed to use " "Short mark.
; Unless your PHP program is only run in a controlled environment and is only for your own use, please do not use short tags.
; If you want to use PHP with XML, you can choose to turn this option off to facilitate direct embedding" ".
; This directive does not affect the abbreviation form"

precision = 14
; Display precision of floating point data (number of significant digits).

serialize_precision = -1
; The precision (number of significant digits) when storing float and double data serially.
; The default value of -1 means automatically selecting the best precision, which is just enough to ensure that no data is lost when floating point data is decoded by the deserializer.
; This value also affects the precision of double data encoded by json_encode().

disable_functions =
; This directive accepts a comma-separated list of function names to disable specific functions.
; This instruction can only disable built-in functions, not user-defined functions.

disable_classes =
; This directive accepts a comma-separated list of class names to disable specific classes.

expose_php = On
; Whether to expose the fact that PHP is installed on the server (add its signature to the http header).
; It does not pose a direct security threat, but it makes the client aware that PHP is installed on the server.

hard_timeout = 2
; When the script execution time reaches the max_execution_time limit, it will be terminated "softly and safely".
; This instruction sets the maximum allowed time (in seconds) for ending the script in this "soft and safe" way.
; Once the timeout (default is 2 seconds), it will be terminated in a rough manner (without releasing any unreleased resources).

zend.assertions = 1
; How to compile assertions:
; -1 Do not compile at all (production mode)
; 0 Compile but skip at runtime
; 1 Compile and execute (development mode)

zend.exception_ignore_args = Off
; Whether to exclude arguments from the stack trace generated by the exception.
; Recommended to be set to On on production servers to prevent sensitive information from being output in stack traces.

zend.exception_string_param_max_len = 15
; Maximum string length allowed in stack trace parameters (value range = 0~1000000).
; Only makes sense when zend.exception_ignore_args = Off.
; It is recommended to set it to 0 on production servers to reduce the output of sensitive information.

zend.multibyte = Off
; Whether to allow PHP scripts to use unsafe character encodings such as CP936, Big5, CP949, Shift_JIS.
; Safe character encodings compatible with ISO-8859-1 (UTF-8, EUC, ...) do not need to enable this directive.
; To use this feature, the mbstring extension module must be loaded.

zend.script_encoding =
; The default character encoding used when there is no "declare(encoding=...)" statement in the first line of a PHP script.
; After setting this directive, the script will automatically use the mb_convert_encoding() function.
; Automatically convert all strings from zend.script_enconding to mbstring.internal_encoding.
; Only meaningful when zend.multibyte = On.
; If your script uses a character encoding that is not compatible with ISO-8859-1, it is recommended to set this directive explicitly.

zend.detect_unicode = On
; Whether to detect whether the script contains multi-byte characters by checking the script's BOM (byte order mark).
; Only meaningful when zend.multibyte = On.

zend.signal_check = Off
; Whether to check for replaced signal handlers on shutdown (Unix only)

[Core-ResourceLimits]

memory_limit = 128M
The maximum memory (bytes) that the script can request (can use K and M as units) (must be greater than the value of post_max_size)
; This helps prevent bad scripts from consuming all the memory on the server. Setting this to -1 removes the memory limit.
; After setting this directive, the memory_get_usage() function will become available.

[Core-Performance]

realpath_cache_size = 4M
; Specify the realpath (normalized absolute path name) buffer size used by PHP.
; Buffer size = total length of path string + cache item associated data. When caching mainly long paths, the cache must be larger.
; This value does not directly control the number of paths in the cache. On systems where PHP opens a large number of files this value should be increased to improve performance.
; NOTE: realpath cache will be disabled when open_basedir is enabled.

realpath_cache_ttl = 120
; Realpath cache validity period (seconds). For systems where files rarely change, this value can be increased to improve performance.

[Core-DataHandling]

arg_separator.output = "&"
; The separator used to separate parameters in the URL output by PHP.
; It can also be set to "&" or "," or ";" and so on.

arg_separator.input = "&"
; List of separators used by PHP when parsing variables in URLs. Every character in the string will be treated as a separator.
; It can also be set to ";,&" and so on.

variables_order = "EGPCS"
; Which superglobal arrays to register. Use E, G, P, C, S to represent $_ENV, $_GET, $_POST, $_COOKIE, $_SERVER respectively.
; Because registering these arrays will incur performance losses, and $_ENV is not commonly used, it is not recommended to register $_ENV.
; [Tip] In FastCGI mode, $_SERVER always contains environment variables (that is, S is always equivalent to ES).
; It is recommended to set it to "GPCS" and use getenv() to access environment variables.

request_order =
; How to register elements of the G, P, C superglobal arrays to the $_REQUEST superglobal array.
; This setting not only determines which of G, P, and C are registered, but also determines the overwriting order when registering (the later value will overwrite the previous value).
; [Note] Setting it to empty means inheriting the value of variables_order instead of leaving $_REQUEST empty. It is recommended to set it to "GP".

auto_globals_jit = On
; Whether to create the $_ENV, $_REQUEST, $_SERVER variables only when they are actually used (rather than automatically when the script is started).
; If these arrays are not used in the script, turning this directive on will improve performance.

register_argc_argv = On
; Whether to register $argv and $argc global variables (may contain information of GET method).
; The $argv array contains all the arguments passed to the script. The $argc variable holds the number of arguments.
; It is recommended to turn off this directive to improve performance.
; [Tip] For CLI mode, this command is hardcoded to On

enable_post_data_reading = On
; Whether to allow reading POST data. If set to Off, $_POST and $_FILES will always be empty.
; The only way to get the POST data is via the php://input stream wrapper.
; Off is only suitable for proxying requests or processing POST data in a memory-efficient manner.

post_max_size = 8M
; Maximum POST data length (bytes) allowed to be accepted ("0" means unlimited). Only meaningful when enable_post_data_reading = On.
This setting also affects file uploads (must be larger than the value of upload_max_filesize). If the POST data exceeds the limit, $_POST and $_FILES will be empty.
If memory limiting is enabled, this value should be less than the value of memory_limit.

auto_prepend_file =
auto_append_file =
; Filenames to automatically insert before/after PHP scripts. Set to empty to disable this feature.
; The specified file is included as if by the include() function, so the value of the include_path directive will be used.
; NOTE: If the script is terminated via exit() then automatic postfixing will not occur.

default_mimetype = "text/html"
default_charset = "UTF-8"
; Set the default value of HTTP header "Content-Type:". Setting both to empty means no "Content-Type:" header will be output.
; The default value means outputting "Content-Type: text/html; charset=UTF-8".
; Deprecate setting default_charset to empty.

input_encoding =
; Character encoding used by PHP input. Setting this to empty means using the value of default_charset.

output_encoding =
; Character encoding used by PHP output. Setting this to empty means using the value of default_charset.

internal_encoding =
; The character encoding used internally by PHP. Setting it to empty means using the value of default_charset.

[Core-Paths]

include_path = ".;/path/to/php/pear"
; Specify a set of directories for require(), include(), fopen(), file(), readfile(), file_get_contents() ... and other functions to locate files.
; The format is similar to the system's PATH environment variable (separated by colons in UNIX and semicolons in Windows):
; UNIX: "/path1:/path2"
; Windows: "\path1;\path2"
; Using './path/to/file' directly to represent files relative to the current directory is a more efficient way (it is not recommended to use '.' in this command).
; Furthermore, setting this directive to empty can help improve the performance of locating files on the file system.
; The value of this directive can be modified at runtime using set_include_path().

open_basedir =
; Limit all files that PHP is allowed to operate to this group directory list to improve security (setting it to empty means allowing all files to be opened).
; When the script attempts to open a file outside the specified directory tree, it will be rejected.
; All symbolic links are resolved, so it is not possible to circumvent this restriction by using symbolic links.
; The special value '.' means that the directory where the script is stored will be used as the base directory, but this is not safe (the script can use chdir() to change the working directory).
; For shared servers, it will be very useful to flexibly set this directive in httpd.conf for different virtual hosts or directories.
; When used as an Apache module, the open_basedir path in the parent directory will be automatically inherited.
; In Windows, semicolons are used to separate directories, and in UNIX systems, colons are used to separate directories. It is recommended to use the PATH_SEPARATOR constant to write portable code.
; NOTE: When this feature is enabled realpath caching will be disabled.

doc_root =
; PHP's "CGI root directory". Only valid if non-empty.
; Placing executable programs/scripts in the web server's main document directory (such as "htdocs") is considered unsafe.
; For example, due to configuration errors, the script is displayed as ordinary HTML.
; Therefore, many system administrators will set up a directory outside the main document directory that can only be accessed through CGI.
; The contents of this directory will only be parsed and not displayed as is.
; If this directive is set, PHP will only interpret files in the doc_root directory.
; and ensure that no scripts outside of the directory will be executed by the PHP interpreter (except user_dir).
; If FORCE_REDIRECT was not specified when compiling PHP, this directive must be set.
; If running as CGI on a non-IIS server, be sure to read the security section in the manual.
; A safe alternative is to use the cgi.force_redirect directive.

user_dir =
; Tells PHP which directory to look for when opening a script with /~username. This is only valid when it is not empty.
; That is, use the basic directory name of the PHP file under the user directory, for example: "public_php"

user_ini.cache_ttl = 300
; The number of seconds between rereading the .user.ini file (the lifetime of the .user.ini file).

user_ini.filename = ".user.ini"
; The name of a user-defined php.ini file on a per-directory basis (only supported in CGI/FastCGI mode). Setting this to empty means disabling this feature.
; When this feature is enabled, in addition to the main php.ini, it will also scan from the directory where the executed PHP script is located, all the way up to the web root directory.
; If the executed PHP script is outside the web root directory, only the directory where the PHP script is located will be scanned.
; Only PHP_INI_PERDIR and PHP_INI_USER type directives are allowed in .user.ini files.
; Enabling this feature will make the PECL htscanner extension obsolete.

extension_dir = "/path/to/phpext"
; The directory where extension libraries (modules) are stored, which is also the directory that PHP uses to find dynamic extension modules.
; The default value for Windows is "C:\php\ext"
; The default value on Unix depends on the compile-time configuration.

sys_temp_dir = "/path/to/tmp"
; Temporary directory for temporary files. The default is the system's temporary directory (see sys_get_temp_dir() function)

;extension=PHP module name (without prefix and suffix, such as mbstring)
;zend_extension=Zend module name (without prefix and suffix, for example opcache )
; For modules that are not in the extension_dir directory, you can directly write the full absolute path of the module file.
; [Note] The exif module must be loaded after mbstring

[Core-FileUploads]

file_uploads = On
; Whether to allow HTTP file upload. See upload_max_filesize, upload_tmp_dir, post_max_size directives.

upload_tmp_dir =
; Temporary directory for storing uploaded files (must be a directory writable by the PHP process). Setting it to empty means using the system default temporary directory.
; If the specified directory is not writable, the system default temporary directory will be automatically used.
; If open_basedir is set, it must contain the system default temporary directory, otherwise the upload function will not work.

upload_max_filesize = 2M
The maximum size of the file allowed to be uploaded (must be smaller than the value of post_max_size).

max_file_uploads = 20
; The maximum number of files that can be uploaded simultaneously in one HTTP request.

[Core-Windows]

windows.show_crt_warning = Off
; Whether to display C runtime warning messages (only available on Windows platforms)

;;;;;;;;;;;;;;;;;;;;;
;; Core Extensions;;
;;;;;;;;;;;;;;;;;;;;;

[DateTime]
; The first four configuration options are currently only used by the date_sunrise() and date_sunset() functions.

date.default_latitude = 31.7667
; Default latitude
date.default_longitude = 35.2333
; Default longitude
date.sunrise_zenith = 90.833333
; Default sunrise zenith
date.sunset_zenith = 90.833333
; Default sunset zenith

date.timezone =
; Default time zone used for all date and time functions when the TZ environment variable is not set.
; Mainland China should use "PRC" or "Asia/Shanghai"
; The order of precedence for applying time zones is:
; 1. The time zone set by the date_default_timezone_set() function (if set)
; 2. TZ environment variable (if non-empty)
; 3. The value of the command (if set)
; 4. PHP guesses it itself (if the operating system supports it)
; 5. If none of the above works, use "UTC"

[ErrorHandling]

error_reporting = E_ALL
; What the error report should contain (overlay of bit fields):
; 1 E_ERROR Fatal runtime error
; 2 E_WARNING Runtime warning (non-fatal error)
; 4 E_PARSE Compile-time parsing error
; 8 E_NOTICE Runtime warning (usually a bug, but may be intentional)
; 16 E_CORE_ERROR Fatal error during initialization when PHP is started
; 32 E_CORE_WARNING Warning during the initialization process when PHP starts (non-fatal error)
; 64 E_COMPILE_ERROR Fatal error during compilation
; 128 E_COMPILE_WARNING Compile-time warning (non-fatal error)
; 256 E_USER_ERROR User-defined fatal error
; 512 E_USER_WARNING User-defined warning (non-fatal error)
; 1024 E_USER_NOTICE User-defined reminder (often a bug, but may be intentional)
; 2048 E_STRICT Encoding standardization warning (suggestions on how to modify for forward compatibility)
; 4096 E_RECOVERABLE_ERROR Near-fatal runtime error, treated as E_ERROR if not caught
; 8192 E_DEPRECATED Warns about code that may not work properly in future versions
; 16384 E_USER_DEPRECATED User-defined warning (warning about code that may not work properly in future versions)
; 32767 E_ALL All errors and warnings above
; [NOTE] These constants cannot be used outside of php.ini (must use numeric values).
; The development environment can be set to 2147483647 (all binary bits are 1) to turn on various errors and warnings that may appear now or in the future.
; On production servers, it is recommended to set it to E_ALL & ~E_DEPRECATED & ~E_STRICT to avoid excessive performance loss.
; To further improve performance, consider setting it to E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR (only errors)

display_errors = On
; Whether to display error messages as part of the output.
; On final production web sites, it is strongly recommended that you turn this feature off and use error logging instead.
; Enabling this feature in the final published web site may expose some sensitive information.
; Special values STDOUT and STDERR are only available in CGI/CLI mode (CLI mode default = STDOUT).

display_startup_errors = On
; Whether to display errors when PHP starts (PHP7 default value = Off).
; Turning this parameter off will not display errors on PHP startup, even if display_errors = On.
; It is recommended to turn off this feature on production servers to avoid leaking sensitive configuration information.

log_errors = Off
; Whether to log error information to the destination specified by error_log.
; It is strongly recommended that you use logging errors instead of direct output in a production environment.
; This lets you know what went wrong without exposing sensitive information.
; Default value for FPM/FastCGI mode = On

log_errors_max_len = 1024
; Maximum length in bytes allowed for error messages. Setting this to 0 allows unlimited length.

ignore_repeated_errors = Off
; Whether to ignore repeated error messages.
; Error messages must appear on the same line in the same script to be considered repeated (unless ignore_repeated_source = On).

ignore_repeated_source = Off
; When ignore_repeated_errors = On, whether to ignore the source of the error message (ignore the same error message from different codes).

report_memleaks = On
; Whether to report memory leaks. This parameter only works in PHP compiled in debug mode.
; and must include E_WARNING in the error_reporting directive

report_zend_debug = Off
; No documentation yet (PHP7 Apache/FPM/FastCGI mode default = On)

html_errors = On
; Whether to use HTML tags in error messages.
; Do not use this feature when error logging is required!
; [Tip] For CLI mode, this command is hardcoded to Off

xmlrpc_errors = Off
; Whether to set the error report format to XML-RPC error message format (turn off normal error reporting).

xmlrpc_error_number = 0
; The value of the XML-RPC faultCode element (only meaningful when xmlrpc_errors = On).

docref_root = ;"https://www.php.net/manual/zh/"
docref_ext = ;".php"
; If html_errors = On and docref_root is set, PHP will display hyperlinks in error messages.
; Direct link to a page describing the error or function that caused the error.
; After you download the PHP manual, you can point the docref_root directive to the URL directory where your local manual is located.
; You must also set the docref_ext directive to specify the file extension (must contain '.').
; [Note] Do not use this feature on a production server.

error_prepend_string = ;""
error_append_string = ;""
; Strings appended before and after the error message (generally used to add color)

error_log =
; Set the destination for error logging. If it is a file (recommended), it must have write permission.
; Set to syslog to log to the system log (event log under NT, syslog(3) under Unix)
; Setting it to empty means: Apache error log (apache2handler), standard error (CLI), no logging (FPM).
; Default value for FPM/FastCGI mode="/var/log/php-fpm/www-error.log"(RHEL/CentOS)

syslog.facility = LOG_USER
; The facility field value in the system log (the subsystem that generates the log).
; Only meaningful when error_log = syslog.

syslog.filter = no-ctrl
; Filter (escape as "\x???") unsafe characters in log messages:
; ascii (only ASCII characters and NL characters are allowed)
; no-ctrl (allow all non-control characters)
; all (all characters are allowed)
; raw (allow all characters, but do not split log messages on newlines)
; Only meaningful when error_log = syslog.

syslog.ident = php
; The ident field value in the system log (log message prefix [identification string]).
; Only meaningful when error_log = syslog.

[FileStream]

allow_url_fopen = On
; Is it allowed to use URLs (such as http:// or ftp://) as a file.

allow_url_include = Off
; Whether to allow include/require URLs (such as http:// or ftp://).

user_agent =
; The "User-Agent" string used by PHP when accessing the URL

default_socket_timeout = 60
; Default timeout in seconds for socket streams

from =
; Define the password for anonymous ftp (an email address)

auto_detect_line_endings = Off
; Whether to let PHP automatically detect the end of line (EOL).
; If your script must process Macintosh files, or you run on a Macintosh and have to process unix or win32 files,
; Turning on this directive allows PHP to automatically detect EOL so that fgets() and file() functions can work properly.
; But it will also cause incompatible behavior for people who use carriage return (CR) as item separator under Unix systems.
; Additionally, there is a small performance penalty for detecting the EOL convention on the first line.

[Filter]
;extension=filter
; Confirm and filter data from unreliable sources.

filter.default = unsafe_raw
; Use the specified filter to filter $_GET, $_POST, $_COOKIE, $_REQUEST, $_SERVER data ( unsafe_raw means no filtering).
; The raw data can be accessed via the filter_input() function.

filter.default_flags =
; Default filter flag.

[OptionsInfo]

assert.active = On
; Whether to enable assert() assertion evaluation.

assert.bail = Off
; Whether to abort script execution when a failed assertion occurs

assert.warning = On
; Whether to issue a warning for each failed assertion

assert.callback =
; Callback function executed when a failed assertion occurs

assert.exception = On
; Whether to throw an AssertionError exception when the assertion fails
; PHP7 default value = Off

enable_dl = On
; Whether to allow the use of the dl() function. The dl() function is only valid when PHP is installed as an apache module.
; Disabling the dl() function is mainly for security reasons, as it can bypass the restrictions of the open_basedir directive.
; This feature will definitely be removed in the future. It is strongly recommended to set it to Off.

max_execution_time = 30
The maximum execution time (in seconds) allowed for each script. 0 means no limit.
; This parameter helps prevent low-quality scripts from endlessly occupying server resources.
; This directive only affects the running time of the script itself. Any other time spent outside the script running,
; For example, system()/sleep() functions, database queries, file uploads, etc. are not included.
; [Tip] For CLI mode, this command is hardcoded to "0" (no limit)
; [Tip] Do not set this directive to be greater than Apache's Timeout directive (it may interrupt PHP execution prematurely).

max_input_time = -1
The maximum allowed time (in seconds) for each script to receive input data (POST, GET, upload).
-1 means unlimited. On a production server this should be limited to an explicit value to prevent the script from running indefinitely.
; If the user has a slow connection and needs to upload large files, a larger value should be set.
; [Tip] For CLI mode, this command is hardcoded to "-1" (no limit)

max_input_nesting_level = 64
; Maximum nesting depth of input variables ($_GET, $_POST, $_COOKIE ...)

max_input_vars = 1000
; Maximum total number of members of input variables ($_GET, $_POST, $_COOKIE ...).
; This directive mitigates the possibility of denial of service attacks via hash collisions
; Input variables exceeding the limit will be truncated and cause E_WARNING to be generated.

zend.enable_gc = On
; Whether to enable the circular reference counter collector (garbage collection). Turning off this directive may cause memory leaks.

[Mail]

mail.add_x_header = Off
; Whether to add X-PHP-Originating-Script: header to include "script UID + file name" information

mail.force_extra_parameters =
; Force the fifth parameter of the mail() function to be specified.

mail.log =
; How to log calls to the mail() function. Set to empty to not log.
; It can be set to a file path to indicate recording to a file, or it can be set to syslog to indicate recording to the system log.

SMTP = "localhost"
; The host name or IP address of the SMTP server used by the mail() function to send emails (Windows only).

smtp_port = 25
; Port number of the SMTP server (Windows only).

sendmail_from =
; Email address in the "From:" header when sending mail (win32 only).
; This option also sets the "Return-Path:" header.

sendmail_path = /path/to/sendmail
; Path to the sendmail program (including command line arguments).
; The configure script will try to find this program and set it to the default value (usually "/usr/sbin/sendmail -t -i"), but if that fails, you can set it manually here.
; Systems that do not use sendmail should set this directive to the sendmail replacement program (if any).
; The default value of this directive on Windows platforms is empty.
; If this directive is set on Windows platforms, the smtp smtp_port sendmail_from directives are ignored and the command specified here is run.

[Misc]

ignore_user_abort = Off
; Whether to complete the entire request even if the user aborts it.
; It is recommended to set this to On, as long requests may cause users to abort or browser timeout.

highlight.comment = "#FF8000"
highlight.default = "#0000BB"
highlight.html = "#000000"
highlight.keyword = "#007700"
highlight.string = "#DD0000"
; Color for syntax highlighting mode (usually used to display .phps files).
; As long as it can be Accept it and it will work normally.

browscap = ;"c:/windows/system32/inetsrv/browscap.ini"
; The location and file name of the browser function file (this setting is only required for PWS and IIS).

[OutputControl]

output_buffering = 0
; Output buffer size (bytes). The recommended value is 4096 [can also be controlled by ob_start() function].
; Output buffering allows you to send HTTP headers (including cookies) even after outputting the body content.
; Setting output buffering can sometimes reduce the number of network packets sent (improve network performance).
; The actual benefit of this parameter depends a lot on what web server and what kind of scripts you use.
; [TIP] For CLI mode, this command is hardcoded to "0" (disable output buffering)

output_handler =
; Redirect all script output to an output handler function.
; For example, when set to "mb_output_handler" to redirect to the mb_output_handler() function, the character encoding will be transparently converted to the specified encoding.
; Once an output handler is specified here, output buffering will be automatically turned on (buffer size = unlimited).
; Note 0: Only PHP built-in functions can be used here. Custom functions should be specified in the script using the ob_start() function.
; Note 1: Portable scripts should not rely on this directive, but should use the ob_start() function to explicitly specify the output processing function.
; Do not use this command lightly, otherwise it may cause errors in some scripts that you are not familiar with.
; Note 2: The two output processing functions "mb_output_handler" and "ob_iconv_handler" cannot be used at the same time.
; The "ob_gzhandler" output processing function and the "zlib.output_compression" directive cannot be used at the same time.
; NOTE 3: If "zlib.output_compression = On", then this directive must be empty (use "zlib.output_handler" instead).

implicit_flush = Off
; Whether to require the PHP output layer to automatically flush data after each output block.
; This is equivalent to automatically calling the flush() function after each print(), echo(), HTML block.
; Turning on this option will have a serious impact on the performance of program execution and is only recommended for debugging.
; [Tip] For CLI mode, this command is hardcoded to "On" (force automatic flash)

[PCRE]

pcre.backtrack_limit = 1000000
; Maximum backtracking depth.

pcre.recursion_limit = 100000
; Maximum recursion depth. If you set this value too high, you may run out of process stack space and cause PHP to crash.

pcre.jit = 1
; Whether to enable JIT (just-in-time) compilation of the PCRE library.

[Phar]
;extension=phar
; Package PHP applications/libraries to simplify deployment (read-only for others to use)

phar.readonly = On
; Whether to enable Phar read-only mode. Be sure to enable this command in a production environment, otherwise it will leave a huge security vulnerability.

phar.require_hash = On
; Whether to verify the signature of all Phar archives (to prevent archive contents from being tampered with). It is recommended to enable it to enhance security.

phar.cache_list =
; List of Phar archives to preparse during server startup (for improved performance).

[Session]

session.save_handler = files
; The name of the storage handler to store and retrieve session data. Defaults to files ("files").
; Setting it to "user" means that you can use session_set_save_handler() to register a custom storage handler.
; Extension modules can register new storage handlers. All registered storage handlers can be viewed via phpinfo().

session.save_path =
; Parameters passed to save_handler. For the files handler, this is the directory where session data files are stored (the default is the system temporary directory).
; You can use the "N;[MODE;]/path" mode to define the directory, where the optional [MODE;] is the data file access permission expressed in octal (the default is "600").
; The integer N means using N-level deep subdirectories (instead of saving all data files in the same directory) to improve performance for a large number of sessions.
; Note: (1) The double quotes around "N;[MODE;]/path" cannot be omitted (because ";" is a comment character). (2) [MODE;] does not rewrite the umask of the process.
; (3) PHP will not automatically create these directory structures (you can use the mod_files.sh script in the ext/session directory).
; (4) If the directory (such as "/tmp") can be read or retrieved by unsafe users, it will lead to security vulnerabilities (leakage of session ID or even session data).
; (5) When N>0, automatic garbage collection will fail (see session.gc_* instructions for details).
; (6) Setting N>2 (each layer has 64 subdirectories, and N=3 means creating 64*64*64 subdirectories) may be necessary only when you have a huge number of sessions.
; (7) It is recommended to set up different session storage directories for each different virtual host.
; Default value for FPM/FastCGI mode="/var/lib/php/session"(RHEL/CentOS)

session.name = PHPSESSID
; The session ID used in the cookie can only contain letters and numbers.

session.auto_start = Off
; Whether to automatically initialize the session engine when a client visits any page.
; Because class definitions must be loaded before the session is started, objects cannot be stored in the session when this option is turned on.

session.serialize_handler = php
; Processor used to serialize/deserialize data, you can use "php", "php_binary", "php_serialize".
; It is recommended to use the new "php_serialize" instead of the default old "php" to avoid certain limitations and defects.
; [NOTE] Once WDDX support is enabled, only "wddx" will be used.

session.gc_probability = 1
session.gc_divisor = 100
; Defines the probability of starting the garbage collector each time a session is initialized.
; The collection probability is calculated as follows: session.gc_probability/session.gc_divisor
; The more frequent the session page is accessed, the smaller the probability should be. It is recommended to set it to 1/(1000~5000).

session.gc_maxlifetime = 1440
; After the number of seconds specified by this directive, the saved data will be considered 'garbage' and cleaned up by the garbage collector.
; The judgment criterion is the time when the data was last accessed (for the FAT file system, it is the time when the data was last refreshed).
; If multiple scripts share the same session.save_path directory but have different session.gc_maxlifetime,
; then the minimum value of all session.gc_maxlifetime directives will be used.
; If you use multiple levels of subdirectories to store data files, the garbage collector will not start automatically.
; You must use a custom script, cron job, or other method to perform garbage collection.
; For example, the following script is equivalent to setting "session.gc_maxlifetime=1440" (24 minutes):
; cd /path/to/sessions; find -cmin +24 | xargs rm

session.referer_check =
; If the "Referer:" field in the request header does not contain the string specified here, the session ID will be considered invalid.
; NOTE: If the "Referer:" field is not present at all in the request header, the session ID will still be considered valid.
; The default is empty, which means no check is performed (all are considered valid).

session.use_strict_mode = 0
; Whether to use strict session ID mode (reject uninitialized session IDs). Enabling strict mode can protect the server from session fixation attacks.
; "Strict mode" means that if the browser sends an uninitialized session ID, the server will respond with a new initialized session ID.
; The default value "0" means disabling strict mode. It is recommended to set it to "1" to enable this feature.

session.use_cookies = 1
; Whether to use cookies to save session IDs on the client side ("1" to enable, "0" to disable).

session.use_only_cookies = 1
; Whether to use only cookies to save session IDs on the client side ("1" to enable, "0" to disable).
; Enabling this feature can avoid security issues caused by passing session IDs in URLs.
; It is recommended to enable this option to enhance security.

session.cookie_lifetime = 0
; The validity period (in seconds) of the cookie that passes the session ID. "0" means it is only valid while the browser is open.
; [Tip] If you cannot ensure that the server time and the client time are strictly consistent, please do not change this default value!

session.cookie_path = /
; Cookie path for passing session ID.

session.cookie_domain =
; Scope (domain name) of the cookie that passes the session ID.
; The default value of empty means the host name is generated according to the cookie specification.

session.cookie_secure = 0
; Whether to send cookies only over secure connections (https) ("1" to enable, "0" to disable).

session.cookie_httponly = 0
; Whether to add the httpOnly flag (allow only HTTP protocol access) to the cookie ("1" means enabled, "0" means disabled).
; Enabling this feature will prevent client scripts (JavaScript, etc.) from accessing the cookie.
; Turning on this directive can effectively prevent session ID hijacking through XSS attacks.

session.cookie_samesite =
; Add the value of the SameSite attribute to the cookie (one of "Strict", "Lax", "None" [be sure to keep the quotes]),
; Allows the server to declare to the client that this cookie should not be used for cross-site requests, which helps prevent Cross-Site Request Forgery.
; Not all browsers support this feature. Setting this to empty means that the SameSite attribute will not be sent with the cookie.
; "Strict" means that both POST and GET are prohibited from sending cookies across sites
; "Lax" means prohibiting POST from sending cookies across sites, but allowing GET to send cookies across sites
; See https://tools.ietf.org/html/draft-west-first-party-cookies-07

session.cache_limiter = nocache
; Specify cache control policy for session pages (nocache|private|private_no_expire|public).
; nocache means disabling client and proxy server caching; public means allowing client and proxy server caching;
; private means that client caching is allowed but proxy server caching is prohibited;
; private_no_expire is the same as private, but does not send the "Expire:" response header (to solve the BUG that browsers such as Mozilla may not handle the Expire response header correctly).
; Setting it to empty means not sending any response header related to cache policy. See the session_cache_limiter() function for details.

session.cache_expire = 180
; Specifies the expiration time (in minutes) of session pages in the client cache. This setting is meaningless when session.cache_limiter = nocache.

session.use_trans_sid = 0
; Whether to display the SID (session ID) in the URL in plain text ("1" means enabled, "0" means disabled).
; URL-based session management is always more risky than cookie-based session management and should be disabled.

session.trans_sid_tags = "a=href,area=href,frame=src,form="
; Specify which HTML tags to rewrite to include the SID (only meaningful when session.use_trans_sid = On).
;