Last active
March 29, 2023 13:04
-
-
Save ewilan-riviere/9b8014f7a5941e34eda1524ae5d43096 to your computer and use it in GitHub Desktop.
INI for PHP 8.2
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
[PHP] | |
;;;;;;;;;;;;;;;;;;; | |
; About php.ini ; | |
;;;;;;;;;;;;;;;;;;; | |
; PHP's initialization file, generally called php.ini, is responsible for | |
; configuring many of the aspects of PHP's behavior. | |
; PHP attempts to find and load this configuration from a number of locations. | |
; The following is a summary of its search order: | |
; 1. SAPI module specific location. | |
; 2. The PHPRC environment variable. | |
; 3. A number of predefined registry keys on Windows | |
; 4. Current working directory (except CLI) | |
; 5. The web server's directory (for SAPI modules), or directory of PHP | |
; (otherwise in Windows) | |
; 6. The directory from the --with-config-file-path compile time option, or the | |
; Windows directory (usually C:\windows) | |
; See the PHP docs for more specific information. | |
; https://php.net/configuration.file | |
; The syntax of the file is extremely simple. Whitespace and lines | |
; beginning with a semicolon are silently ignored (as you probably guessed). | |
; Section headers (e.g. [Foo]) are also silently ignored, even though | |
; they might mean something in the future. | |
; Directives following the section heading [PATH=/www/mysite] only | |
; apply to PHP files in the /www/mysite directory. Directives | |
; following the section heading [HOST=www.example.com] only apply to | |
; PHP files served from www.example.com. Directives set in these | |
; special sections cannot be overridden by user-defined INI files or | |
; at runtime. Currently, [PATH=] and [HOST=] sections only work under | |
; CGI/FastCGI. | |
; https://php.net/ini.sections | |
; Directives are specified using the following syntax: | |
; directive = value | |
; Directive names are *case sensitive* - foo=bar is different from FOO=bar. | |
; Directives are variables used to configure PHP or PHP extensions. | |
; There is no name validation. If PHP can't find an expected | |
; directive because it is not set or is mistyped, a default value will be used. | |
; The value can be a string, a number, a PHP constant (e.g. E_ALL or M_PI), one | |
; of the INI constants (On, Off, True, False, Yes, No and None) or an expression | |
; (e.g. E_ALL & ~E_NOTICE), a quoted string ("bar"), or a reference to a | |
; previously set variable or directive (e.g. ${foo}) | |
; Expressions in the INI file are limited to bitwise operators and parentheses: | |
; | bitwise OR | |
; ^ bitwise XOR | |
; & bitwise AND | |
; ~ bitwise NOT | |
; ! boolean NOT | |
; Boolean flags can be turned on using the values 1, On, True or Yes. | |
; They can be turned off using the values 0, Off, False or No. | |
; An empty string can be denoted by simply not writing anything after the equal | |
; sign, or by using the None keyword: | |
; foo = ; sets foo to an empty string | |
; foo = None ; sets foo to an empty string | |
; foo = "None" ; sets foo to the string 'None' | |
; If you use constants in your value, and these constants belong to a | |
; dynamically loaded extension (either a PHP extension or a Zend extension), | |
; you may only use these constants *after* the line that loads the extension. | |
;;;;;;;;;;;;;;;;;;; | |
; About this file ; | |
;;;;;;;;;;;;;;;;;;; | |
; PHP comes packaged with two INI files. One that is recommended to be used | |
; in production environments and one that is recommended to be used in | |
; development environments. | |
; php.ini-production contains settings which hold security, performance and | |
; best practices at its core. But please be aware, these settings may break | |
; compatibility with older or less security conscience applications. We | |
; recommending using the production ini in production and testing environments. | |
; php.ini-development is very similar to its production variant, except it is | |
; much more verbose when it comes to errors. We recommend using the | |
; development version only in development environments, as errors shown to | |
; application users can inadvertently leak otherwise secure information. | |
; This is the php.ini-production INI file. | |
;;;;;;;;;;;;;;;;;;; | |
; Quick Reference ; | |
;;;;;;;;;;;;;;;;;;; | |
; The following are all the settings which are different in either the production | |
; or development versions of the INIs with respect to PHP's default behavior. | |
; Please see the actual settings later in the document for more details as to why | |
; we recommend these changes in PHP's behavior. | |
; 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 | |
;;;;;;;;;;;;;;;;;;;; | |
; php.ini Options ; | |
;;;;;;;;;;;;;;;;;;;; | |
; Name for user-defined php.ini (.htaccess) files. Default is ".user.ini" | |
;user_ini.filename = ".user.ini" | |
; To disable this feature set this option to an empty value | |
;user_ini.filename = | |
; TTL for user-defined php.ini files (time-to-live) in seconds. Default is 300 seconds (5 minutes) | |
;user_ini.cache_ttl = 300 | |
;;;;;;;;;;;;;;;;;;;; | |
; Language Options ; | |
;;;;;;;;;;;;;;;;;;;; | |
; Enable the PHP scripting language engine under Apache. | |
; https://php.net/engine | |
engine = On | |
; This directive determines whether or not PHP will recognize code between | |
; <? and ?> tags as PHP source which should be processed as such. It is | |
; generally recommended that <?php and ?> should be used and that this feature | |
; should be disabled, as enabling it may result in issues when generating XML | |
; documents, however this remains supported for backward compatibility reasons. | |
; Note that this directive does not control the <?= shorthand tag, which can be | |
; used regardless of this directive. | |
; Default Value: On | |
; Development Value: Off | |
; Production Value: Off | |
; https://php.net/short-open-tag | |
short_open_tag = Off | |
; The number of significant digits displayed in floating point numbers. | |
; https://php.net/precision | |
precision = 14 | |
; Output buffering is a mechanism for controlling how much output data | |
; (excluding headers and cookies) PHP should keep internally before pushing that | |
; data to the client. If your application's output exceeds this setting, PHP | |
; will send that data in chunks of roughly the size you specify. | |
; Turning on this setting and managing its maximum buffer size can yield some | |
; interesting side-effects depending on your application and web server. | |
; You may be able to send headers and cookies after you've already sent output | |
; through print or echo. You also may see performance benefits if your server is | |
; emitting less packets due to buffered output versus PHP streaming the output | |
; as it gets it. On production servers, 4096 bytes is a good setting for performance | |
; reasons. | |
; Note: Output buffering can also be controlled via Output Buffering Control | |
; functions. | |
; Possible Values: | |
; On = Enabled and buffer is unlimited. (Use with caution) | |
; Off = Disabled | |
; Integer = Enables the buffer and sets its maximum size in bytes. | |
; Note: This directive is hardcoded to Off for the CLI SAPI | |
; Default Value: Off | |
; Development Value: 4096 | |
; Production Value: 4096 | |
; https://php.net/output-buffering | |
output_buffering = 4096 | |
; You can redirect all of the output of your scripts to a function. For | |
; example, if you set output_handler to "mb_output_handler", character | |
; encoding will be transparently converted to the specified encoding. | |
; Setting any output handler automatically turns on output buffering. | |
; Note: People who wrote portable scripts should not depend on this ini | |
; directive. Instead, explicitly set the output handler using ob_start(). | |
; Using this ini directive may cause problems unless you know what script | |
; is doing. | |
; Note: You cannot use both "mb_output_handler" with "ob_iconv_handler" | |
; and you cannot use both "ob_gzhandler" and "zlib.output_compression". | |
; Note: output_handler must be empty if this is set 'On' !!!! | |
; Instead you must use zlib.output_handler. | |
; https://php.net/output-handler | |
;output_handler = | |
; URL rewriter function rewrites URL on the fly by using | |
; output buffer. You can set target tags by this configuration. | |
; "form" tag is special tag. It will add hidden input tag to pass values. | |
; Refer to session.trans_sid_tags for usage. | |
; Default Value: "form=" | |
; Development Value: "form=" | |
; Production Value: "form=" | |
;url_rewriter.tags | |
; URL rewriter will not rewrite absolute URL nor form by default. To enable | |
; absolute URL rewrite, allowed hosts must be defined at RUNTIME. | |
; Refer to session.trans_sid_hosts for more details. | |
; Default Value: "" | |
; Development Value: "" | |
; Production Value: "" | |
;url_rewriter.hosts | |
; Transparent output compression using the zlib library | |
; Valid values for this option are 'off', 'on', or a specific buffer size | |
; to be used for compression (default is 4KB) | |
; Note: Resulting chunk size may vary due to nature of compression. PHP | |
; outputs chunks that are few hundreds bytes each as a result of | |
; compression. If you prefer a larger chunk size for better | |
; performance, enable output_buffering in addition. | |
; Note: You need to use zlib.output_handler instead of the standard | |
; output_handler, or otherwise the output will be corrupted. | |
; https://php.net/zlib.output-compression | |
zlib.output_compression = Off | |
; https://php.net/zlib.output-compression-level | |
;zlib.output_compression_level = -1 | |
; You cannot specify additional output handlers if zlib.output_compression | |
; is activated here. This setting does the same as output_handler but in | |
; a different order. | |
; https://php.net/zlib.output-handler | |
;zlib.output_handler = | |
; Implicit flush tells PHP to tell the output layer to flush itself | |
; automatically after every output block. This is equivalent to calling the | |
; PHP function flush() after each and every call to print() or echo() and each | |
; and every HTML block. Turning this option on has serious performance | |
; implications and is generally recommended for debugging purposes only. | |
; https://php.net/implicit-flush | |
; Note: This directive is hardcoded to On for the CLI SAPI | |
implicit_flush = Off | |
; The unserialize callback function will be called (with the undefined class' | |
; name as parameter), if the unserializer finds an undefined class | |
; which should be instantiated. A warning appears if the specified function is | |
; not defined, or if the function doesn't include/implement the missing class. | |
; So only set this entry, if you really want to implement such a | |
; callback-function. | |
unserialize_callback_func = | |
; The unserialize_max_depth specifies the default depth limit for unserialized | |
; structures. Setting the depth limit too high may result in stack overflows | |
; during unserialization. The unserialize_max_depth ini setting can be | |
; overridden by the max_depth option on individual unserialize() calls. | |
; A value of 0 disables the depth limit. | |
;unserialize_max_depth = 4096 | |
; When floats & doubles are serialized, store serialize_precision significant | |
; digits after the floating point. The default value ensures that when floats | |
; are decoded with unserialize, the data will remain the same. | |
; The value is also used for json_encode when encoding double values. | |
; If -1 is used, then dtoa mode 0 is used which automatically select the best | |
; precision. | |
serialize_precision = -1 | |
; open_basedir, if set, limits all file operations to the defined directory | |
; and below. This directive makes most sense if used in a per-directory | |
; or per-virtualhost web server configuration file. | |
; Note: disables the realpath cache | |
; https://php.net/open-basedir | |
;open_basedir = | |
; This directive allows you to disable certain functions. | |
; It receives a comma-delimited list of function names. | |
; https://php.net/disable-functions | |
disable_functions = | |
; This directive allows you to disable certain classes. | |
; It receives a comma-delimited list of class names. | |
; https://php.net/disable-classes | |
disable_classes = | |
; Colors for Syntax Highlighting mode. Anything that's acceptable in | |
; <span style="color: ???????"> would work. | |
; https://php.net/syntax-highlighting | |
;highlight.string = #DD0000 | |
;highlight.comment = #FF9900 | |
;highlight.keyword = #007700 | |
;highlight.default = #0000BB | |
;highlight.html = #000000 | |
; If enabled, the request will be allowed to complete even if the user aborts | |
; the request. Consider enabling it if executing long requests, which may end up | |
; being interrupted by the user or a browser timing out. PHP's default behavior | |
; is to disable this feature. | |
; https://php.net/ignore-user-abort | |
;ignore_user_abort = On | |
; Determines the size of the realpath cache to be used by PHP. This value should | |
; be increased on systems where PHP opens many files to reflect the quantity of | |
; the file operations performed. | |
; Note: if open_basedir is set, the cache is disabled | |
; https://php.net/realpath-cache-size | |
;realpath_cache_size = 4096k | |
; Duration of time, in seconds for which to cache realpath information for a given | |
; file or directory. For systems with rarely changing files, consider increasing this | |
; value. | |
; https://php.net/realpath-cache-ttl | |
;realpath_cache_ttl = 120 | |
; Enables or disables the circular reference collector. | |
; https://php.net/zend.enable-gc | |
zend.enable_gc = On | |
; If enabled, scripts may be written in encodings that are incompatible with | |
; the scanner. CP936, Big5, CP949 and Shift_JIS are the examples of such | |
; encodings. To use this feature, mbstring extension must be enabled. | |
;zend.multibyte = Off | |
; Allows to set the default encoding for the scripts. This value will be used | |
; unless "declare(encoding=...)" directive appears at the top of the script. | |
; Only affects if zend.multibyte is set. | |
;zend.script_encoding = | |
; Allows to include or exclude arguments from stack traces generated for exceptions. | |
; In production, it is recommended to turn this setting on to prohibit the output | |
; of sensitive information in stack traces | |
; Default Value: Off | |
; Development Value: Off | |
; Production Value: On | |
zend.exception_ignore_args = On | |
; Allows setting the maximum string length in an argument of a stringified stack trace | |
; to a value between 0 and 1000000. | |
; This has no effect when zend.exception_ignore_args is enabled. | |
; Default Value: 15 | |
; Development Value: 15 | |
; Production Value: 0 | |
; In production, it is recommended to set this to 0 to reduce the output | |
; of sensitive information in stack traces. | |
zend.exception_string_param_max_len = 0 | |
;;;;;;;;;;;;;;;;; | |
; Miscellaneous ; | |
;;;;;;;;;;;;;;;;; | |
; Decides whether PHP may expose the fact that it is installed on the server | |
; (e.g. by adding its signature to the Web server header). It is no security | |
; threat in any way, but it makes it possible to determine whether you use PHP | |
; on your server or not. | |
; https://php.net/expose-php | |
expose_php = On | |
;;;;;;;;;;;;;;;;;;; | |
; Resource Limits ; | |
;;;;;;;;;;;;;;;;;;; | |
; Maximum execution time of each script, in seconds | |
; https://php.net/max-execution-time | |
; Note: This directive is hardcoded to 0 for the CLI SAPI | |
max_execution_time = 30 | |
; Maximum amount of time each script may spend parsing request data. It's a good | |
; idea to limit this time on productions servers in order to eliminate unexpectedly | |
; long running scripts. | |
; Note: This directive is hardcoded to -1 for the CLI SAPI | |
; Default Value: -1 (Unlimited) | |
; Development Value: 60 (60 seconds) | |
; Production Value: 60 (60 seconds) | |
; https://php.net/max-input-time | |
max_input_time = 60 | |
; Maximum input variable nesting level | |
; https://php.net/max-input-nesting-level | |
;max_input_nesting_level = 64 | |
; How many GET/POST/COOKIE input variables may be accepted | |
;max_input_vars = 1000 | |
; How many multipart body parts (combined input variable and file uploads) may | |
; be accepted. | |
; Default Value: -1 (Sum of max_input_vars and max_file_uploads) | |
;max_multipart_body_parts = 1500 | |
; Maximum amount of memory a script may consume | |
; https://php.net/memory-limit | |
memory_limit = -1 | |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
; Error handling and logging ; | |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
; This directive informs PHP of which errors, warnings and notices you would like | |
; it to take action for. The recommended way of setting values for this | |
; directive is through the use of the error level constants and bitwise | |
; operators. The error level constants are below here for convenience as well as | |
; some common settings and their meanings. | |
; By default, PHP is set to take action on all errors, notices and warnings EXCEPT | |
; those related to E_NOTICE and E_STRICT, which together cover best practices and | |
; recommended coding standards in PHP. For performance reasons, this is the | |
; recommend error reporting setting. Your production server shouldn't be wasting | |
; resources complaining about best practices and coding standards. That's what | |
; development servers and development settings are for. | |
; Note: The php.ini-development file has this setting as E_ALL. This | |
; means it pretty much reports everything which is exactly what you want during | |
; development and early testing. | |
; | |
; Error Level Constants: | |
; E_ALL - All errors and warnings | |
; E_ERROR - fatal run-time errors | |
; E_RECOVERABLE_ERROR - almost fatal run-time errors | |
; E_WARNING - run-time warnings (non-fatal errors) | |
; E_PARSE - compile-time parse errors | |
; E_NOTICE - run-time notices (these are warnings which often result | |
; from a bug in your code, but it's possible that it was | |
; intentional (e.g., using an uninitialized variable and | |
; relying on the fact it is automatically initialized to an | |
; empty string) | |
; E_STRICT - run-time notices, enable to have PHP suggest changes | |
; to your code which will ensure the best interoperability | |
; and forward compatibility of your code | |
; E_CORE_ERROR - fatal errors that occur during PHP's initial startup | |
; E_CORE_WARNING - warnings (non-fatal errors) that occur during PHP's | |
; initial startup | |
; E_COMPILE_ERROR - fatal compile-time errors | |
; E_COMPILE_WARNING - compile-time warnings (non-fatal errors) | |
; E_USER_ERROR - user-generated error message | |
; E_USER_WARNING - user-generated warning message | |
; E_USER_NOTICE - user-generated notice message | |
; E_DEPRECATED - warn about code that will not work in future versions | |
; of PHP | |
; E_USER_DEPRECATED - user-generated deprecation warnings | |
; | |
; Common Values: | |
; E_ALL (Show all errors, warnings and notices including coding standards.) | |
; E_ALL & ~E_NOTICE (Show all errors, except for notices) | |
; E_ALL & ~E_NOTICE & ~E_STRICT (Show all errors, except for notices and coding standards warnings.) | |
; E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR (Show only errors) | |
; Default Value: E_ALL | |
; Development Value: E_ALL | |
; Production Value: E_ALL & ~E_DEPRECATED & ~E_STRICT | |
; https://php.net/error-reporting | |
error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT | |
; This directive controls whether or not and where PHP will output errors, | |
; notices and warnin |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment