[PHP] |
|
|
|
date.timezone = "Australia/Sydney" |
|
|
|
;;;;;;;;;;;;;;;;;;; |
|
; 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. (As of PHP 5.2.0) |
|
; 3. A number of predefined registry keys on Windows (As of PHP 5.2.0) |
|
; 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 (C:\windows or C:\winnt) |
|
; See the PHP docs for more specific information. |
|
; http://www.php.net/manual/en/configuration.file.php |
|
|
|
; 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. |
|
; http://www.php.net/manual/en/ini.sections.php |
|
|
|
; 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's |
|
; much more verbose when it comes to errors. We recommending using the |
|
; development version only in development environments as errors shown to |
|
; application users can inadvertently leak otherwise secure information. |
|
|
|
; This 2 files are provided, by RPM, in /usr/share/doc/php-common-*/ |
|
; File used by RPM (the /etc/php.ini) is mainly the php.ini-production |
|
|
|
;;;;;;;;;;;;;;;;;;; |
|
; 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. |
|
|
|
; allow_call_time_pass_reference |
|
; Default Value: On |
|
; Development Value: Off |
|
; Production Value: Off |
|
|
|
; display_errors |
|
; Default Value: On |
|
; Development Value: On |
|
; Production Value: Off |
|
|
|
; display_startup_errors |
|
; Default Value: Off |
|
; Development Value: On |
|
; Production Value: Off |
|
|
|
; error_reporting |
|
; Default Value: E_ALL & ~E_NOTICE |
|
; Development Value: E_ALL | E_STRICT |
|
; Production Value: E_ALL & ~E_DEPRECATED |
|
|
|
; html_errors |
|
; Default Value: On |
|
; Development Value: On |
|
; Production value: Off |
|
|
|
; log_errors |
|
; Default Value: Off |
|
; Development Value: On |
|
; Production Value: On |
|
|
|
; magic_quotes_gpc |
|
; Default Value: On |
|
; Development Value: Off |
|
; Production Value: Off |
|
|
|
; 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 |
|
|
|
; register_long_arrays |
|
; Default Value: On |
|
; Development Value: Off |
|
; Production Value: Off |
|
|
|
; request_order |
|
; Default Value: None |
|
; Development Value: "GP" |
|
; Production Value: "GP" |
|
|
|
; session.bug_compat_42 |
|
; Default Value: On |
|
; Development Value: On |
|
; Production Value: Off |
|
|
|
; session.bug_compat_warn |
|
; Default Value: On |
|
; Development Value: On |
|
; Production Value: Off |
|
|
|
; session.gc_divisor |
|
; Default Value: 100 |
|
; Development Value: 1000 |
|
; Production Value: 1000 |
|
|
|
; session.hash_bits_per_character |
|
; Default Value: 4 |
|
; Development Value: 5 |
|
; Production Value: 5 |
|
|
|
; short_open_tag |
|
; Default Value: On |
|
; Development Value: Off |
|
; Production Value: Off |
|
|
|
; track_errors |
|
; Default Value: Off |
|
; Development Value: On |
|
; Production Value: Off |
|
|
|
; url_rewriter.tags |
|
; Default Value: "a=href,area=href,frame=src,form=,fieldset=" |
|
; Development Value: "a=href,area=href,frame=src,input=src,form=fakeentry" |
|
; Production Value: "a=href,area=href,frame=src,input=src,form=fakeentry" |
|
|
|
; variables_order |
|
; Default Value: "EGPCS" |
|
; Development Value: "GPCS" |
|
; Production Value: "GPCS" |
|
|
|
;;;;;;;;;;;;;;;;;;;; |
|
; 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 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. |
|
; http://www.php.net/manual/en/apache.configuration.php#ini.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's been |
|
; recommended for several years that you not use the short tag "short cut" and |
|
; instead to use the full <?php and ?> tag combination. With the wide spread use |
|
; of XML and use of these tags by other languages, the server can become easily |
|
; confused and end up parsing the wrong code in the wrong context. But because |
|
; this short cut has been a feature for such a long time, it's currently still |
|
; supported for backwards compatibility, but we recommend you don't use them. |
|
; Default Value: On |
|
; Development Value: Off |
|
; Production Value: Off |
|
; http://www.php.net/manual/en/ini.core.php#ini.short-open-tag |
|
short_open_tag = Off |
|
|
|
; Allow ASP-style <% %> tags. |
|
; http://www.php.net/manual/en/ini.core.php#ini.asp-tags |
|
asp_tags = Off |
|
|
|
; The number of significant digits displayed in floating point numbers. |
|
; http://www.php.net/manual/en/ini.core.php#ini.precision |
|
precision = 14 |
|
|
|
; Enforce year 2000 compliance (will cause problems with non-compliant browsers) |
|
; http://www.php.net/manual/en/ini.core.php#ini.y2k-compliance |
|
y2k_compliance = On |
|
|
|
; 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. |
|
; Default Value: Off |
|
; Development Value: 4096 |
|
; Production Value: 4096 |
|
; http://www.php.net/manual/en/outcontrol.configuration.php#ini.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. |
|
; http://www.php.net/manual/en/outcontrol.configuration.php#ini.output-handler |
|
;output_handler = |
|
|
|
; 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. |
|
; http://www.php.net/manual/en/zlib.configuration.php#ini.zlib.output-compression |
|
zlib.output_compression = on |
|
|
|
; http://www.php.net/manual/en/zlib.configuration.php#ini.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. |
|
; http://www.php.net/manual/en/zlib.configuration.php#ini.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. |
|
; http://www.php.net/manual/en/outcontrol.configuration.php#ini.implicit-flush |
|
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 = |
|
|
|
; 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. |
|
serialize_precision = 100 |
|
|
|
; This directive allows you to enable and disable warnings which PHP will issue |
|
; if you pass a value by reference at function call time. Passing values by |
|
; reference at function call time is a deprecated feature which will be removed |
|
; from PHP at some point in the near future. The acceptable method for passing a |
|
; value by reference to a function is by declaring the reference in the functions |
|
; definition, not at call time. This directive does not disable this feature, it |
|
; only determines whether PHP will warn you about it or not. These warnings |
|
; should enabled in development environments only. |
|
; Default Value: On (Suppress warnings) |
|
; Development Value: Off (Issue warnings) |
|
; Production Value: Off (Issue warnings) |
|
; http://www.php.net/manual/en/ini.core.php#ini.allow-call-time-pass-reference |
|
allow_call_time_pass_reference = Off |
|
|
|
; Safe Mode |
|
; http://www.php.net/manual/en/ini.sect.safe-mode.php#ini.safe-mode |
|
safe_mode = Off |
|
|
|
; By default, Safe Mode does a UID compare check when |
|
; opening files. If you want to relax this to a GID compare, |
|
; then turn on safe_mode_gid. |
|
; http://www.php.net/manual/en/ini.sect.safe-mode.php#ini.safe-mode-gid |
|
safe_mode_gid = Off |
|
|
|
; When safe_mode is on, UID/GID checks are bypassed when |
|
; including files from this directory and its subdirectories. |
|
; (directory must also be in include_path or full path must |
|
; be used when including) |
|
; http://www.php.net/manual/en/ini.sect.safe-mode.php#ini.safe-mode-include-dir |
|
safe_mode_include_dir = |
|
|
|
; When safe_mode is on, only executables located in the safe_mode_exec_dir |
|
; will be allowed to be executed via the exec family of functions. |
|
; http://www.php.net/manual/en/ini.sect.safe-mode.php#ini.safe-mode-exec-dir |
|
safe_mode_exec_dir = |
|
|
|
; Setting certain environment variables may be a potential security breach. |
|
; This directive contains a comma-delimited list of prefixes. In Safe Mode, |
|
; the user may only alter environment variables whose names begin with the |
|
; prefixes supplied here. By default, users will only be able to set |
|
; environment variables that begin with PHP_ (e.g. PHP_FOO=BAR). |
|
; Note: If this directive is empty, PHP will let the user modify ANY |
|
; environment variable! |
|
; http://www.php.net/manual/en/ini.sect.safe-mode.php#ini.safe-mode-allowed-env-vars |
|
safe_mode_allowed_env_vars = PHP_ |
|
|
|
; This directive contains a comma-delimited list of environment variables that |
|
; the end user won't be able to change using putenv(). These variables will be |
|
; protected even if safe_mode_allowed_env_vars is set to allow to change them. |
|
; http://www.php.net/manual/en/ini.sect.safe-mode.php#ini.safe-mode-protected-env-vars |
|
safe_mode_protected_env_vars = LD_LIBRARY_PATH |
|
|
|
; 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. This directive is |
|
; *NOT* affected by whether Safe Mode is turned On or Off. |
|
; http://www.php.net/manual/en/ini.sect.safe-mode.php#ini.open-basedir |
|
;open_basedir = |
|
|
|
; This directive allows you to disable certain functions for security reasons. |
|
; It receives a comma-delimited list of function names. This directive is |
|
; *NOT* affected by whether Safe Mode is turned On or Off. |
|
; http://www.php.net/manual/en/ini.sect.safe-mode.php#ini.disable-functions |
|
disable_functions = |
|
|
|
; This directive allows you to disable certain classes for security reasons. |
|
; It receives a comma-delimited list of class names. This directive is |
|
; *NOT* affected by whether Safe Mode is turned On or Off. |
|
; http://www.php.net/manual/en/ini.sect.safe-mode.php#ini.disable-classes |
|
disable_classes = |
|
|
|
; Colors for Syntax Highlighting mode. Anything that's acceptable in |
|
; <span style="color: ???????"> would work. |
|
; http://www.php.net/manual/en/misc.configuration.php#ini.syntax-highlighting |
|
;highlight.string = #DD0000 |
|
;highlight.comment = #FF9900 |
|
;highlight.keyword = #007700 |
|
;highlight.bg = #FFFFFF |
|
;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. |
|
; http://www.php.net/manual/en/misc.configuration.php#ini.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. |
|
; http://www.php.net/manual/en/ini.core.php#ini.realpath-cache-size |
|
;realpath_cache_size = 16k |
|
|
|
; 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. |
|
; http://www.php.net/manual/en/ini.core.php#ini.realpath-cache-ttl |
|
;realpath_cache_ttl = 120 |
|
|
|
;;;;;;;;;;;;;;;;; |
|
; 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. |
|
; http://www.php.net/manual/en/ini.core.php#ini.expose-php |
|
expose_php = On |
|
|
|
;;;;;;;;;;;;;;;;;;; |
|
; Resource Limits ; |
|
;;;;;;;;;;;;;;;;;;; |
|
|
|
; Maximum execution time of each script, in seconds |
|
; http://www.php.net/manual/en/info.configuration.php#ini.max-execution-time |
|
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. |
|
; Default Value: -1 (Unlimited) |
|
; Development Value: 60 (60 seconds) |
|
; Production Value: 60 (60 seconds) |
|
; http://www.php.net/manual/en/info.configuration.php#ini.max-input-time |
|
max_input_time = 60 |
|
|
|
; Maximum input variable nesting level |
|
; http://www.php.net/manual/en/info.configuration.php#ini.max-input-nesting-level |
|
;max_input_nesting_level = 64 |
|
|
|
; Maximum amount of memory a script may consume (128MB) |
|
; http://www.php.net/manual/en/ini.core.php#ini.memory-limit |
|
memory_limit = 128M |
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
|
; 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 | E_STRICT. 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 (includes E_STRICT as of PHP 6.0.0) |
|
; 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's 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 & ~E_NOTICE (Show all errors, except for notices and coding standards warnings.) |
|
; E_ALL & ~E_NOTICE | E_STRICT (Show all errors, except for notices) |
|
; E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR (Show only errors) |
|
; E_ALL | E_STRICT (Show all errors, warnings and notices including coding standards.) |
|
; Default Value: E_ALL & ~E_NOTICE |
|
; Development Value: E_ALL | E_STRICT |
|
; Production Value: E_ALL & ~E_DEPRECATED |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.error-reporting |
|
error_reporting = E_ALL & ~E_DEPRECATED |
|
|
|
; This directive controls whether or not and where PHP will output errors, |
|
; notices and warnings too. Error output is very useful during development, but |
|
; it could be very dangerous in production environments. Depending on the code |
|
; which is triggering the error, sensitive information could potentially leak |
|
; out of your application such as database usernames and passwords or worse. |
|
; It's recommended that errors be logged on production servers rather than |
|
; having the errors sent to STDOUT. |
|
; Possible Values: |
|
; Off = Do not display any errors |
|
; stderr = Display errors to STDERR (affects only CGI/CLI binaries!) |
|
; On or stdout = Display errors to STDOUT |
|
; Default Value: On |
|
; Development Value: On |
|
; Production Value: Off |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.display-errors |
|
display_errors = Off |
|
|
|
; The display of errors which occur during PHP's startup sequence are handled |
|
; separately from display_errors. PHP's default behavior is to suppress those |
|
; errors from clients. Turning the display of startup errors on can be useful in |
|
; debugging configuration problems. But, it's strongly recommended that you |
|
; leave this setting off on production servers. |
|
; Default Value: Off |
|
; Development Value: On |
|
; Production Value: Off |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.display-startup-errors |
|
display_startup_errors = Off |
|
|
|
; Besides displaying errors, PHP can also log errors to locations such as a |
|
; server-specific log, STDERR, or a location specified by the error_log |
|
; directive found below. While errors should not be displayed on productions |
|
; servers they should still be monitored and logging is a great way to do that. |
|
; Default Value: Off |
|
; Development Value: On |
|
; Production Value: On |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.log-errors |
|
log_errors = On |
|
|
|
; Set maximum length of log_errors. In error_log information about the source is |
|
; added. The default is 1024 and 0 allows to not apply any maximum length at all. |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.log-errors-max-len |
|
log_errors_max_len = 1024 |
|
|
|
; Do not log repeated messages. Repeated errors must occur in same file on same |
|
; line unless ignore_repeated_source is set true. |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.ignore-repeated-errors |
|
ignore_repeated_errors = Off |
|
|
|
; Ignore source of message when ignoring repeated messages. When this setting |
|
; is On you will not log errors with repeated messages from different files or |
|
; source lines. |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.ignore-repeated-source |
|
ignore_repeated_source = Off |
|
|
|
; If this parameter is set to Off, then memory leaks will not be shown (on |
|
; stdout or in the log). This has only effect in a debug compile, and if |
|
; error reporting includes E_WARNING in the allowed list |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.report-memleaks |
|
report_memleaks = On |
|
|
|
; This setting is on by default. |
|
;report_zend_debug = 0 |
|
|
|
; Store the last error/warning message in $php_errormsg (boolean). Setting this value |
|
; to On can assist in debugging and is appropriate for development servers. It should |
|
; however be disabled on production servers. |
|
; Default Value: Off |
|
; Development Value: On |
|
; Production Value: Off |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.track-errors |
|
track_errors = Off |
|
|
|
; Turn off normal error reporting and emit XML-RPC error XML |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.xmlrpc-errors |
|
;xmlrpc_errors = 0 |
|
|
|
; An XML-RPC faultCode |
|
;xmlrpc_error_number = 0 |
|
|
|
; When PHP displays or logs an error, it has the capability of inserting html |
|
; links to documentation related to that error. This directive controls whether |
|
; those HTML links appear in error messages or not. For performance and security |
|
; reasons, it's recommended you disable this on production servers. |
|
; Default Value: On |
|
; Development Value: On |
|
; Production value: Off |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.html-errors |
|
html_errors = Off |
|
|
|
; If html_errors is set On PHP produces clickable error messages that direct |
|
; to a page describing the error or function causing the error in detail. |
|
; You can download a copy of the PHP manual from http://www.php.net/docs.php |
|
; and change docref_root to the base URL of your local copy including the |
|
; leading '/'. You must also specify the file extension being used including |
|
; the dot. PHP's default behavior is to leave these settings empty. |
|
; Note: Never use this feature for production boxes. |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.docref-root |
|
; Examples |
|
;docref_root = "/phpmanual/" |
|
|
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.docref-ext |
|
;docref_ext = .html |
|
|
|
; String to output before an error message. PHP's default behavior is to leave |
|
; this setting blank. |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.error-prepend-string |
|
; Example: |
|
;error_prepend_string = "<font color=#ff0000>" |
|
|
|
; String to output after an error message. PHP's default behavior is to leave |
|
; this setting blank. |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.error-append-string |
|
; Example: |
|
;error_append_string = "</font>" |
|
|
|
; Log errors to specified file. PHP's default behavior is to leave this value |
|
; empty. |
|
; http://www.php.net/manual/en/errorfunc.configuration.php#ini.error-log |
|
; Example: |
|
;error_log = php_errors.log |
|
; Log errors to syslog (Event Log on NT, not valid in Windows 95). |
|
;error_log = syslog |
|
|
|
;;;;;;;;;;;;;;;;; |
|
; Data Handling ; |
|
;;;;;;;;;;;;;;;;; |
|
|
|
; Note - track_vars is ALWAYS enabled as of PHP 4.0.3 |
|
|
|
; The separator used in PHP generated URLs to separate arguments. |
|
; PHP's default setting is "&". |
|
; http://www.php.net/manual/en/ini.core.php#ini.arg-separator.output |
|
; Example: |
|
;arg_separator.output = "&" |
|
|
|
; List of separator(s) used by PHP to parse input URLs into variables. |
|
; PHP's default setting is "&". |
|
; NOTE: Every character in this directive is considered as separator! |
|
; http://www.php.net/manual/en/ini.core.php#ini.arg-separator.input |
|
; Example: |
|
;arg_separator.input = ";&" |
|
|
|
; This directive determines which super global arrays are registered when PHP |