Return to php.ini-development CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / elwix / config / etc / default |
1.1 ! misho 1: [PHP] ! 2: ! 3: ;;;;;;;;;;;;;;;;;;; ! 4: ; About php.ini ; ! 5: ;;;;;;;;;;;;;;;;;;; ! 6: ; PHP's initialization file, generally called php.ini, is responsible for ! 7: ; configuring many of the aspects of PHP's behavior. ! 8: ! 9: ; PHP attempts to find and load this configuration from a number of locations. ! 10: ; The following is a summary of its search order: ! 11: ; 1. SAPI module specific location. ! 12: ; 2. The PHPRC environment variable. (As of PHP 5.2.0) ! 13: ; 3. A number of predefined registry keys on Windows (As of PHP 5.2.0) ! 14: ; 4. Current working directory (except CLI) ! 15: ; 5. The web server's directory (for SAPI modules), or directory of PHP ! 16: ; (otherwise in Windows) ! 17: ; 6. The directory from the --with-config-file-path compile time option, or the ! 18: ; Windows directory (C:\windows or C:\winnt) ! 19: ; See the PHP docs for more specific information. ! 20: ; http://php.net/configuration.file ! 21: ! 22: ; The syntax of the file is extremely simple. Whitespace and Lines ! 23: ; beginning with a semicolon are silently ignored (as you probably guessed). ! 24: ; Section headers (e.g. [Foo]) are also silently ignored, even though ! 25: ; they might mean something in the future. ! 26: ! 27: ; Directives following the section heading [PATH=/www/mysite] only ! 28: ; apply to PHP files in the /www/mysite directory. Directives ! 29: ; following the section heading [HOST=www.example.com] only apply to ! 30: ; PHP files served from www.example.com. Directives set in these ! 31: ; special sections cannot be overridden by user-defined INI files or ! 32: ; at runtime. Currently, [PATH=] and [HOST=] sections only work under ! 33: ; CGI/FastCGI. ! 34: ; http://php.net/ini.sections ! 35: ! 36: ; Directives are specified using the following syntax: ! 37: ; directive = value ! 38: ; Directive names are *case sensitive* - foo=bar is different from FOO=bar. ! 39: ; Directives are variables used to configure PHP or PHP extensions. ! 40: ; There is no name validation. If PHP can't find an expected ! 41: ; directive because it is not set or is mistyped, a default value will be used. ! 42: ! 43: ; The value can be a string, a number, a PHP constant (e.g. E_ALL or M_PI), one ! 44: ; of the INI constants (On, Off, True, False, Yes, No and None) or an expression ! 45: ; (e.g. E_ALL & ~E_NOTICE), a quoted string ("bar"), or a reference to a ! 46: ; previously set variable or directive (e.g. ${foo}) ! 47: ! 48: ; Expressions in the INI file are limited to bitwise operators and parentheses: ! 49: ; | bitwise OR ! 50: ; ^ bitwise XOR ! 51: ; & bitwise AND ! 52: ; ~ bitwise NOT ! 53: ; ! boolean NOT ! 54: ! 55: ; Boolean flags can be turned on using the values 1, On, True or Yes. ! 56: ; They can be turned off using the values 0, Off, False or No. ! 57: ! 58: ; An empty string can be denoted by simply not writing anything after the equal ! 59: ; sign, or by using the None keyword: ! 60: ! 61: ; foo = ; sets foo to an empty string ! 62: ; foo = None ; sets foo to an empty string ! 63: ; foo = "None" ; sets foo to the string 'None' ! 64: ! 65: ; If you use constants in your value, and these constants belong to a ! 66: ; dynamically loaded extension (either a PHP extension or a Zend extension), ! 67: ; you may only use these constants *after* the line that loads the extension. ! 68: ! 69: ;;;;;;;;;;;;;;;;;;; ! 70: ; About this file ; ! 71: ;;;;;;;;;;;;;;;;;;; ! 72: ; PHP comes packaged with two INI files. One that is recommended to be used ! 73: ; in production environments and one that is recommended to be used in ! 74: ; development environments. ! 75: ! 76: ; php.ini-production contains settings which hold security, performance and ! 77: ; best practices at its core. But please be aware, these settings may break ! 78: ; compatibility with older or less security conscience applications. We ! 79: ; recommending using the production ini in production and testing environments. ! 80: ! 81: ; php.ini-development is very similar to its production variant, except it's ! 82: ; much more verbose when it comes to errors. We recommending using the ! 83: ; development version only in development environments as errors shown to ! 84: ; application users can inadvertently leak otherwise secure information. ! 85: ! 86: ;;;;;;;;;;;;;;;;;;; ! 87: ; Quick Reference ; ! 88: ;;;;;;;;;;;;;;;;;;; ! 89: ; The following are all the settings which are different in either the production ! 90: ; or development versions of the INIs with respect to PHP's default behavior. ! 91: ; Please see the actual settings later in the document for more details as to why ! 92: ; we recommend these changes in PHP's behavior. ! 93: ! 94: ; allow_call_time_pass_reference ! 95: ; Default Value: On ! 96: ; Development Value: Off ! 97: ; Production Value: Off ! 98: ! 99: ; display_errors ! 100: ; Default Value: On ! 101: ; Development Value: On ! 102: ; Production Value: Off ! 103: ! 104: ; display_startup_errors ! 105: ; Default Value: Off ! 106: ; Development Value: On ! 107: ; Production Value: Off ! 108: ! 109: ; error_reporting ! 110: ; Default Value: E_ALL & ~E_NOTICE ! 111: ; Development Value: E_ALL | E_STRICT ! 112: ; Production Value: E_ALL & ~E_DEPRECATED ! 113: ! 114: ; html_errors ! 115: ; Default Value: On ! 116: ; Development Value: On ! 117: ; Production value: Off ! 118: ! 119: ; log_errors ! 120: ; Default Value: Off ! 121: ; Development Value: On ! 122: ; Production Value: On ! 123: ! 124: ; magic_quotes_gpc ! 125: ; Default Value: On ! 126: ; Development Value: Off ! 127: ; Production Value: Off ! 128: ! 129: ; max_input_time ! 130: ; Default Value: -1 (Unlimited) ! 131: ; Development Value: 60 (60 seconds) ! 132: ; Production Value: 60 (60 seconds) ! 133: ! 134: ; output_buffering ! 135: ; Default Value: Off ! 136: ; Development Value: 4096 ! 137: ; Production Value: 4096 ! 138: ! 139: ; register_argc_argv ! 140: ; Default Value: On ! 141: ; Development Value: Off ! 142: ; Production Value: Off ! 143: ! 144: ; register_long_arrays ! 145: ; Default Value: On ! 146: ; Development Value: Off ! 147: ; Production Value: Off ! 148: ! 149: ; request_order ! 150: ; Default Value: None ! 151: ; Development Value: "GP" ! 152: ; Production Value: "GP" ! 153: ! 154: ; session.bug_compat_42 ! 155: ; Default Value: On ! 156: ; Development Value: On ! 157: ; Production Value: Off ! 158: ! 159: ; session.bug_compat_warn ! 160: ; Default Value: On ! 161: ; Development Value: On ! 162: ; Production Value: Off ! 163: ! 164: ; session.gc_divisor ! 165: ; Default Value: 100 ! 166: ; Development Value: 1000 ! 167: ; Production Value: 1000 ! 168: ! 169: ; session.hash_bits_per_character ! 170: ; Default Value: 4 ! 171: ; Development Value: 5 ! 172: ; Production Value: 5 ! 173: ! 174: ; short_open_tag ! 175: ; Default Value: On ! 176: ; Development Value: Off ! 177: ; Production Value: Off ! 178: ! 179: ; track_errors ! 180: ; Default Value: Off ! 181: ; Development Value: On ! 182: ; Production Value: Off ! 183: ! 184: ; url_rewriter.tags ! 185: ; Default Value: "a=href,area=href,frame=src,form=,fieldset=" ! 186: ; Development Value: "a=href,area=href,frame=src,input=src,form=fakeentry" ! 187: ; Production Value: "a=href,area=href,frame=src,input=src,form=fakeentry" ! 188: ! 189: ; variables_order ! 190: ; Default Value: "EGPCS" ! 191: ; Development Value: "GPCS" ! 192: ; Production Value: "GPCS" ! 193: ! 194: ;;;;;;;;;;;;;;;;;;;; ! 195: ; php.ini Options ; ! 196: ;;;;;;;;;;;;;;;;;;;; ! 197: ; Name for user-defined php.ini (.htaccess) files. Default is ".user.ini" ! 198: ;user_ini.filename = ".user.ini" ! 199: ! 200: ; To disable this feature set this option to empty value ! 201: ;user_ini.filename = ! 202: ! 203: ; TTL for user-defined php.ini files (time-to-live) in seconds. Default is 300 seconds (5 minutes) ! 204: ;user_ini.cache_ttl = 300 ! 205: ! 206: ;;;;;;;;;;;;;;;;;;;; ! 207: ; Language Options ; ! 208: ;;;;;;;;;;;;;;;;;;;; ! 209: ! 210: ; Enable the PHP scripting language engine under Apache. ! 211: ; http://php.net/engine ! 212: engine = On ! 213: ! 214: ; This directive determines whether or not PHP will recognize code between ! 215: ; <? and ?> tags as PHP source which should be processed as such. It's been ! 216: ; recommended for several years that you not use the short tag "short cut" and ! 217: ; instead to use the full <?php and ?> tag combination. With the wide spread use ! 218: ; of XML and use of these tags by other languages, the server can become easily ! 219: ; confused and end up parsing the wrong code in the wrong context. But because ! 220: ; this short cut has been a feature for such a long time, it's currently still ! 221: ; supported for backwards compatibility, but we recommend you don't use them. ! 222: ; Default Value: On ! 223: ; Development Value: Off ! 224: ; Production Value: Off ! 225: ; http://php.net/short-open-tag ! 226: short_open_tag = Off ! 227: ! 228: ; Allow ASP-style <% %> tags. ! 229: ; http://php.net/asp-tags ! 230: asp_tags = Off ! 231: ! 232: ; The number of significant digits displayed in floating point numbers. ! 233: ; http://php.net/precision ! 234: precision = 14 ! 235: ! 236: ; Enforce year 2000 compliance (will cause problems with non-compliant browsers) ! 237: ; http://php.net/y2k-compliance ! 238: y2k_compliance = On ! 239: ! 240: ; Output buffering is a mechanism for controlling how much output data ! 241: ; (excluding headers and cookies) PHP should keep internally before pushing that ! 242: ; data to the client. If your application's output exceeds this setting, PHP ! 243: ; will send that data in chunks of roughly the size you specify. ! 244: ; Turning on this setting and managing its maximum buffer size can yield some ! 245: ; interesting side-effects depending on your application and web server. ! 246: ; You may be able to send headers and cookies after you've already sent output ! 247: ; through print or echo. You also may see performance benefits if your server is ! 248: ; emitting less packets due to buffered output versus PHP streaming the output ! 249: ; as it gets it. On production servers, 4096 bytes is a good setting for performance ! 250: ; reasons. ! 251: ; Note: Output buffering can also be controlled via Output Buffering Control ! 252: ; functions. ! 253: ; Possible Values: ! 254: ; On = Enabled and buffer is unlimited. (Use with caution) ! 255: ; Off = Disabled ! 256: ; Integer = Enables the buffer and sets its maximum size in bytes. ! 257: ; Note: This directive is hardcoded to Off for the CLI SAPI ! 258: ; Default Value: Off ! 259: ; Development Value: 4096 ! 260: ; Production Value: 4096 ! 261: ; http://php.net/output-buffering ! 262: output_buffering = 4096 ! 263: ! 264: ; You can redirect all of the output of your scripts to a function. For ! 265: ; example, if you set output_handler to "mb_output_handler", character ! 266: ; encoding will be transparently converted to the specified encoding. ! 267: ; Setting any output handler automatically turns on output buffering. ! 268: ; Note: People who wrote portable scripts should not depend on this ini ! 269: ; directive. Instead, explicitly set the output handler using ob_start(). ! 270: ; Using this ini directive may cause problems unless you know what script ! 271: ; is doing. ! 272: ; Note: You cannot use both "mb_output_handler" with "ob_iconv_handler" ! 273: ; and you cannot use both "ob_gzhandler" and "zlib.output_compression". ! 274: ; Note: output_handler must be empty if this is set 'On' !!!! ! 275: ; Instead you must use zlib.output_handler. ! 276: ; http://php.net/output-handler ! 277: ;output_handler = ! 278: ! 279: ; Transparent output compression using the zlib library ! 280: ; Valid values for this option are 'off', 'on', or a specific buffer size ! 281: ; to be used for compression (default is 4KB) ! 282: ; Note: Resulting chunk size may vary due to nature of compression. PHP ! 283: ; outputs chunks that are few hundreds bytes each as a result of ! 284: ; compression. If you prefer a larger chunk size for better ! 285: ; performance, enable output_buffering in addition. ! 286: ; Note: You need to use zlib.output_handler instead of the standard ! 287: ; output_handler, or otherwise the output will be corrupted. ! 288: ; http://php.net/zlib.output-compression ! 289: zlib.output_compression = Off ! 290: ! 291: ; http://php.net/zlib.output-compression-level ! 292: ;zlib.output_compression_level = -1 ! 293: ! 294: ; You cannot specify additional output handlers if zlib.output_compression ! 295: ; is activated here. This setting does the same as output_handler but in ! 296: ; a different order. ! 297: ; http://php.net/zlib.output-handler ! 298: ;zlib.output_handler = ! 299: ! 300: ; Implicit flush tells PHP to tell the output layer to flush itself ! 301: ; automatically after every output block. This is equivalent to calling the ! 302: ; PHP function flush() after each and every call to print() or echo() and each ! 303: ; and every HTML block. Turning this option on has serious performance ! 304: ; implications and is generally recommended for debugging purposes only. ! 305: ; http://php.net/implicit-flush ! 306: ; Note: This directive is hardcoded to On for the CLI SAPI ! 307: implicit_flush = Off ! 308: ! 309: ; The unserialize callback function will be called (with the undefined class' ! 310: ; name as parameter), if the unserializer finds an undefined class ! 311: ; which should be instantiated. A warning appears if the specified function is ! 312: ; not defined, or if the function doesn't include/implement the missing class. ! 313: ; So only set this entry, if you really want to implement such a ! 314: ; callback-function. ! 315: unserialize_callback_func = ! 316: ! 317: ; When floats & doubles are serialized store serialize_precision significant ! 318: ; digits after the floating point. The default value ensures that when floats ! 319: ; are decoded with unserialize, the data will remain the same. ! 320: serialize_precision = 100 ! 321: ! 322: ; This directive allows you to enable and disable warnings which PHP will issue ! 323: ; if you pass a value by reference at function call time. Passing values by ! 324: ; reference at function call time is a deprecated feature which will be removed ! 325: ; from PHP at some point in the near future. The acceptable method for passing a ! 326: ; value by reference to a function is by declaring the reference in the functions ! 327: ; definition, not at call time. This directive does not disable this feature, it ! 328: ; only determines whether PHP will warn you about it or not. These warnings ! 329: ; should enabled in development environments only. ! 330: ; Default Value: On (Suppress warnings) ! 331: ; Development Value: Off (Issue warnings) ! 332: ; Production Value: Off (Issue warnings) ! 333: ; http://php.net/allow-call-time-pass-reference ! 334: allow_call_time_pass_reference = Off ! 335: ! 336: ; Safe Mode ! 337: ; http://php.net/safe-mode ! 338: ; ! 339: ; SECURITY NOTE: The FreeBSD Security Officer strongly recommend that ! 340: ; the PHP Safe Mode feature not be relied upon for security, since the ! 341: ; issues Safe Mode tries to handle cannot properly be handled in PHP ! 342: ; (primarily due to PHP's use of external libraries). While many bugs ! 343: ; in Safe Mode has been fixed it's very likely that more issues exist ! 344: ; which allows a user to bypass Safe Mode restrictions. ! 345: ; For increased security we always recommend to install the Suhosin ! 346: ; extension. ! 347: safe_mode = Off ! 348: ! 349: ; By default, Safe Mode does a UID compare check when ! 350: ; opening files. If you want to relax this to a GID compare, ! 351: ; then turn on safe_mode_gid. ! 352: ; http://php.net/safe-mode-gid ! 353: safe_mode_gid = Off ! 354: ! 355: ; When safe_mode is on, UID/GID checks are bypassed when ! 356: ; including files from this directory and its subdirectories. ! 357: ; (directory must also be in include_path or full path must ! 358: ; be used when including) ! 359: ; http://php.net/safe-mode-include-dir ! 360: safe_mode_include_dir = ! 361: ! 362: ; When safe_mode is on, only executables located in the safe_mode_exec_dir ! 363: ; will be allowed to be executed via the exec family of functions. ! 364: ; http://php.net/safe-mode-exec-dir ! 365: safe_mode_exec_dir = ! 366: ! 367: ; Setting certain environment variables may be a potential security breach. ! 368: ; This directive contains a comma-delimited list of prefixes. In Safe Mode, ! 369: ; the user may only alter environment variables whose names begin with the ! 370: ; prefixes supplied here. By default, users will only be able to set ! 371: ; environment variables that begin with PHP_ (e.g. PHP_FOO=BAR). ! 372: ; Note: If this directive is empty, PHP will let the user modify ANY ! 373: ; environment variable! ! 374: ; http://php.net/safe-mode-allowed-env-vars ! 375: safe_mode_allowed_env_vars = PHP_ ! 376: ! 377: ; This directive contains a comma-delimited list of environment variables that ! 378: ; the end user won't be able to change using putenv(). These variables will be ! 379: ; protected even if safe_mode_allowed_env_vars is set to allow to change them. ! 380: ; http://php.net/safe-mode-protected-env-vars ! 381: safe_mode_protected_env_vars = LD_LIBRARY_PATH ! 382: ! 383: ; open_basedir, if set, limits all file operations to the defined directory ! 384: ; and below. This directive makes most sense if used in a per-directory ! 385: ; or per-virtualhost web server configuration file. This directive is ! 386: ; *NOT* affected by whether Safe Mode is turned On or Off. ! 387: ; http://php.net/open-basedir ! 388: ;open_basedir = ! 389: ! 390: ; This directive allows you to disable certain functions for security reasons. ! 391: ; It receives a comma-delimited list of function names. This directive is ! 392: ; *NOT* affected by whether Safe Mode is turned On or Off. ! 393: ; http://php.net/disable-functions ! 394: disable_functions = ! 395: ! 396: ; This directive allows you to disable certain classes for security reasons. ! 397: ; It receives a comma-delimited list of class names. This directive is ! 398: ; *NOT* affected by whether Safe Mode is turned On or Off. ! 399: ; http://php.net/disable-classes ! 400: disable_classes = ! 401: ! 402: ; Colors for Syntax Highlighting mode. Anything that's acceptable in ! 403: ; <span style="color: ???????"> would work. ! 404: ; http://php.net/syntax-highlighting ! 405: ;highlight.string = #DD0000 ! 406: ;highlight.comment = #FF9900 ! 407: ;highlight.keyword = #007700 ! 408: ;highlight.bg = #FFFFFF ! 409: ;highlight.default = #0000BB ! 410: ;highlight.html = #000000 ! 411: ! 412: ; If enabled, the request will be allowed to complete even if the user aborts ! 413: ; the request. Consider enabling it if executing long requests, which may end up ! 414: ; being interrupted by the user or a browser timing out. PHP's default behavior ! 415: ; is to disable this feature. ! 416: ; http://php.net/ignore-user-abort ! 417: ;ignore_user_abort = On ! 418: ! 419: ; Determines the size of the realpath cache to be used by PHP. This value should ! 420: ; be increased on systems where PHP opens many files to reflect the quantity of ! 421: ; the file operations performed. ! 422: ; http://php.net/realpath-cache-size ! 423: ;realpath_cache_size = 16k ! 424: ! 425: ; Duration of time, in seconds for which to cache realpath information for a given ! 426: ; file or directory. For systems with rarely changing files, consider increasing this ! 427: ; value. ! 428: ; http://php.net/realpath-cache-ttl ! 429: ;realpath_cache_ttl = 120 ! 430: ! 431: ;;;;;;;;;;;;;;;;; ! 432: ; Miscellaneous ; ! 433: ;;;;;;;;;;;;;;;;; ! 434: ! 435: ; Decides whether PHP may expose the fact that it is installed on the server ! 436: ; (e.g. by adding its signature to the Web server header). It is no security ! 437: ; threat in any way, but it makes it possible to determine whether you use PHP ! 438: ; on your server or not. ! 439: ; http://php.net/expose-php ! 440: expose_php = On ! 441: ! 442: ;;;;;;;;;;;;;;;;;;; ! 443: ; Resource Limits ; ! 444: ;;;;;;;;;;;;;;;;;;; ! 445: ! 446: ; Maximum execution time of each script, in seconds ! 447: ; http://php.net/max-execution-time ! 448: ; Note: This directive is hardcoded to 0 for the CLI SAPI ! 449: max_execution_time = 30 ! 450: ! 451: ; Maximum amount of time each script may spend parsing request data. It's a good ! 452: ; idea to limit this time on productions servers in order to eliminate unexpectedly ! 453: ; long running scripts. ! 454: ; Note: This directive is hardcoded to -1 for the CLI SAPI ! 455: ; Default Value: -1 (Unlimited) ! 456: ; Development Value: 60 (60 seconds) ! 457: ; Production Value: 60 (60 seconds) ! 458: ; http://php.net/max-input-time ! 459: max_input_time = 60 ! 460: ! 461: ; Maximum input variable nesting level ! 462: ; http://php.net/max-input-nesting-level ! 463: ;max_input_nesting_level = 64 ! 464: ! 465: ; Maximum amount of memory a script may consume (128MB) ! 466: ; http://php.net/memory-limit ! 467: memory_limit = 128M ! 468: ! 469: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ! 470: ; Error handling and logging ; ! 471: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ! 472: ! 473: ; This directive informs PHP of which errors, warnings and notices you would like ! 474: ; it to take action for. The recommended way of setting values for this ! 475: ; directive is through the use of the error level constants and bitwise ! 476: ; operators. The error level constants are below here for convenience as well as ! 477: ; some common settings and their meanings. ! 478: ; By default, PHP is set to take action on all errors, notices and warnings EXCEPT ! 479: ; those related to E_NOTICE and E_STRICT, which together cover best practices and ! 480: ; recommended coding standards in PHP. For performance reasons, this is the ! 481: ; recommend error reporting setting. Your production server shouldn't be wasting ! 482: ; resources complaining about best practices and coding standards. That's what ! 483: ; development servers and development settings are for. ! 484: ; Note: The php.ini-development file has this setting as E_ALL | E_STRICT. This ! 485: ; means it pretty much reports everything which is exactly what you want during ! 486: ; development and early testing. ! 487: ; ! 488: ; Error Level Constants: ! 489: ; E_ALL - All errors and warnings (includes E_STRICT as of PHP 6.0.0) ! 490: ; E_ERROR - fatal run-time errors ! 491: ; E_RECOVERABLE_ERROR - almost fatal run-time errors ! 492: ; E_WARNING - run-time warnings (non-fatal errors) ! 493: ; E_PARSE - compile-time parse errors ! 494: ; E_NOTICE - run-time notices (these are warnings which often result ! 495: ; from a bug in your code, but it's possible that it was ! 496: ; intentional (e.g., using an uninitialized variable and ! 497: ; relying on the fact it's automatically initialized to an ! 498: ; empty string) ! 499: ; E_STRICT - run-time notices, enable to have PHP suggest changes ! 500: ; to your code which will ensure the best interoperability ! 501: ; and forward compatibility of your code ! 502: ; E_CORE_ERROR - fatal errors that occur during PHP's initial startup ! 503: ; E_CORE_WARNING - warnings (non-fatal errors) that occur during PHP's ! 504: ; initial startup ! 505: ; E_COMPILE_ERROR - fatal compile-time errors ! 506: ; E_COMPILE_WARNING - compile-time warnings (non-fatal errors) ! 507: ; E_USER_ERROR - user-generated error message ! 508: ; E_USER_WARNING - user-generated warning message ! 509: ; E_USER_NOTICE - user-generated notice message ! 510: ; E_DEPRECATED - warn about code that will not work in future versions ! 511: ; of PHP ! 512: ; E_USER_DEPRECATED - user-generated deprecation warnings ! 513: ; ! 514: ; Common Values: ! 515: ; E_ALL & ~E_NOTICE (Show all errors, except for notices and coding standards warnings.) ! 516: ; E_ALL & ~E_NOTICE | E_STRICT (Show all errors, except for notices) ! 517: ; E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR (Show only errors) ! 518: ; E_ALL | E_STRICT (Show all errors, warnings and notices including coding standards.) ! 519: ; Default Value: E_ALL & ~E_NOTICE ! 520: ; Development Value: E_ALL | E_STRICT ! 521: ; Production Value: E_ALL & ~E_DEPRECATED ! 522: ; http://php.net/error-reporting ! 523: error_reporting = E_ALL | E_STRICT ! 524: ! 525: ; This directive controls whether or not and where PHP will output errors, ! 526: ; notices and warnings too. Error output is very useful during development, but ! 527: ; it could be very dangerous in production environments. Depending on the code ! 528: ; which is triggering the error, sensitive information could potentially leak ! 529: ; out of your application such as database usernames and passwords or worse. ! 530: ; It's recommended that errors be logged on production servers rather than ! 531: ; having the errors sent to STDOUT. ! 532: ; Possible Values: ! 533: ; Off = Do not display any errors ! 534: ; stderr = Display errors to STDERR (affects only CGI/CLI binaries!) ! 535: ; On or stdout = Display errors to STDOUT ! 536: ; Default Value: On ! 537: ; Development Value: On ! 538: ; Production Value: Off ! 539: ; http://php.net/display-errors ! 540: display_errors = On ! 541: ! 542: ; The display of errors which occur during PHP's startup sequence are handled ! 543: ; separately from display_errors. PHP's default behavior is to suppress those ! 544: ; errors from clients. Turning the display of startup errors on can be useful in ! 545: ; debugging configuration problems. But, it's strongly recommended that you ! 546: ; leave this setting off on production servers. ! 547: ; Default Value: Off ! 548: ; Development Value: On ! 549: ; Production Value: Off ! 550: ; http://php.net/display-startup-errors ! 551: display_startup_errors = On ! 552: ! 553: ; Besides displaying errors, PHP can also log errors to locations such as a ! 554: ; server-specific log, STDERR, or a location specified by the error_log ! 555: ; directive found below. While errors should not be displayed on productions ! 556: ; servers they should still be monitored and logging is a great way to do that. ! 557: ; Default Value: Off ! 558: ; Development Value: On ! 559: ; Production Value: On ! 560: ; http://php.net/log-errors ! 561: log_errors = On ! 562: ! 563: ; Set maximum length of log_errors. In error_log information about the source is ! 564: ; added. The default is 1024 and 0 allows to not apply any maximum length at all. ! 565: ; http://php.net/log-errors-max-len ! 566: log_errors_max_len = 1024 ! 567: ! 568: ; Do not log repeated messages. Repeated errors must occur in same file on same ! 569: ; line unless ignore_repeated_source is set true. ! 570: ; http://php.net/ignore-repeated-errors ! 571: ignore_repeated_errors = Off ! 572: ! 573: ; Ignore source of message when ignoring repeated messages. When this setting ! 574: ; is On you will not log errors with repeated messages from different files or ! 575: ; source lines. ! 576: ; http://php.net/ignore-repeated-source ! 577: ignore_repeated_source = Off ! 578: ! 579: ; If this parameter is set to Off, then memory leaks will not be shown (on ! 580: ; stdout or in the log). This has only effect in a debug compile, and if ! 581: ; error reporting includes E_WARNING in the allowed list ! 582: ; http://php.net/report-memleaks ! 583: report_memleaks = On ! 584: ! 585: ; This setting is on by default. ! 586: ;report_zend_debug = 0 ! 587: ! 588: ; Store the last error/warning message in $php_errormsg (boolean). Setting this value ! 589: ; to On can assist in debugging and is appropriate for development servers. It should ! 590: ; however be disabled on production servers. ! 591: ; Default Value: Off ! 592: ; Development Value: On ! 593: ; Production Value: Off ! 594: ; http://php.net/track-errors ! 595: track_errors = On ! 596: ! 597: ; Turn off normal error reporting and emit XML-RPC error XML ! 598: ; http://php.net/xmlrpc-errors ! 599: ;xmlrpc_errors = 0 ! 600: ! 601: ; An XML-RPC faultCode ! 602: ;xmlrpc_error_number = 0 ! 603: ! 604: ; When PHP displays or logs an error, it has the capability of inserting html ! 605: ; links to documentation related to that error. This directive controls whether ! 606: ; those HTML links appear in error messages or not. For performance and security ! 607: ; reasons, it's recommended you disable this on production servers. ! 608: ; Note: This directive is hardcoded to Off for the CLI SAPI ! 609: ; Default Value: On ! 610: ; Development Value: On ! 611: ; Production value: Off ! 612: ; http://php.net/html-errors ! 613: html_errors = On ! 614: ! 615: ; If html_errors is set On PHP produces clickable error messages that direct ! 616: ; to a page describing the error or function causing the error in detail. ! 617: ; You can download a copy of the PHP manual from http://php.net/docs ! 618: ; and change docref_root to the base URL of your local copy including the ! 619: ; leading '/'. You must also specify the file extension being used including ! 620: ; the dot. PHP's default behavior is to leave these settings empty. ! 621: ; Note: Never use this feature for production boxes. ! 622: ; http://php.net/docref-root ! 623: ; Examples ! 624: ;docref_root = "/phpmanual/" ! 625: ! 626: ; http://php.net/docref-ext ! 627: ;docref_ext = .html ! 628: ! 629: ; String to output before an error message. PHP's default behavior is to leave ! 630: ; this setting blank. ! 631: ; http://php.net/error-prepend-string ! 632: ; Example: ! 633: ;error_prepend_string = "<font color=#ff0000>" ! 634: ! 635: ; String to output after an error message. PHP's default behavior is to leave ! 636: ; this setting blank. ! 637: ; http://php.net/error-append-string ! 638: ; Example: ! 639: ;error_append_string = "</font>" ! 640: ! 641: ; Log errors to specified file. PHP's default behavior is to leave this value ! 642: ; empty. ! 643: ; http://php.net/error-log ! 644: ; Example: ! 645: ;error_log = php_errors.log ! 646: ; Log errors to syslog (Event Log on NT, not valid in Windows 95). ! 647: ;error_log = syslog ! 648: ! 649: ;;;;;;;;;;;;;;;;; ! 650: ; Data Handling ; ! 651: ;;;;;;;;;;;;;;;;; ! 652: ! 653: ; The separator used in PHP generated URLs to separate arguments. ! 654: ; PHP's default setting is "&". ! 655: ; http://php.net/arg-separator.output ! 656: ; Example: ! 657: ;arg_separator.output = "&" ! 658: ! 659: ; List of separator(s) used by PHP to parse input URLs into variables. ! 660: ; PHP's default setting is "&". ! 661: ; NOTE: Every character in this directive is considered as separator! ! 662: ; http://php.net/arg-separator.input ! 663: ; Example: ! 664: ;arg_separator.input = ";&" ! 665: ! 666: ; This directive determines which super global arrays are registered when PHP ! 667: ; starts up. If the register_globals directive is enabled, it also determines ! 668: ; what order variables are populated into the global space. G,P,C,E & S are ! 669: ; abbreviations for the following respective super globals: GET, POST, COOKIE, ! 670: ; ENV and SERVER. There is a performance penalty paid for the registration of ! 671: ; these arrays and because ENV is not as commonly used as the others, ENV is ! 672: ; is not recommended on productions servers. You can still get access to ! 673: ; the environment variables through getenv() should you need to. ! 674: ; Default Value: "EGPCS" ! 675: ; Development Value: "GPCS" ! 676: ; Production Value: "GPCS"; ! 677: ; http://php.net/variables-order ! 678: variables_order = "GPCS" ! 679: ! 680: ; This directive determines which super global data (G,P,C,E & S) should ! 681: ; be registered into the super global array REQUEST. If so, it also determines ! 682: ; the order in which that data is registered. The values for this directive are ! 683: ; specified in the same manner as the variables_order directive, EXCEPT one. ! 684: ; Leaving this value empty will cause PHP to use the value set in the ! 685: ; variables_order directive. It does not mean it will leave the super globals ! 686: ; array REQUEST empty. ! 687: ; Default Value: None ! 688: ; Development Value: "GP" ! 689: ; Production Value: "GP" ! 690: ; http://php.net/request-order ! 691: request_order = "GP" ! 692: ! 693: ; Whether or not to register the EGPCS variables as global variables. You may ! 694: ; want to turn this off if you don't want to clutter your scripts' global scope ! 695: ; with user data. ! 696: ; You should do your best to write your scripts so that they do not require ! 697: ; register_globals to be on; Using form variables as globals can easily lead ! 698: ; to possible security problems, if the code is not very well thought of. ! 699: ; http://php.net/register-globals ! 700: register_globals = Off ! 701: ! 702: ; Determines whether the deprecated long $HTTP_*_VARS type predefined variables ! 703: ; are registered by PHP or not. As they are deprecated, we obviously don't ! 704: ; recommend you use them. They are on by default for compatibility reasons but ! 705: ; they are not recommended on production servers. ! 706: ; Default Value: On ! 707: ; Development Value: Off ! 708: ; Production Value: Off ! 709: ; http://php.net/register-long-arrays ! 710: register_long_arrays = Off ! 711: ! 712: ; This directive determines whether PHP registers $argv & $argc each time it ! 713: ; runs. $argv contains an array of all the arguments passed to PHP when a script ! 714: ; is invoked. $argc contains an integer representing the number of arguments ! 715: ; that were passed when the script was invoked. These arrays are extremely ! 716: ; useful when running scripts from the command line. When this directive is ! 717: ; enabled, registering these variables consumes CPU cycles and memory each time ! 718: ; a script is executed. For performance reasons, this feature should be disabled ! 719: ; on production servers. ! 720: ; Note: This directive is hardcoded to On for the CLI SAPI ! 721: ; Default Value: On ! 722: ; Development Value: Off ! 723: ; Production Value: Off ! 724: ; http://php.net/register-argc-argv ! 725: register_argc_argv = Off ! 726: ! 727: ; When enabled, the SERVER and ENV variables are created when they're first ! 728: ; used (Just In Time) instead of when the script starts. If these variables ! 729: ; are not used within a script, having this directive on will result in a ! 730: ; performance gain. The PHP directives register_globals, register_long_arrays, ! 731: ; and register_argc_argv must be disabled for this directive to have any affect. ! 732: ; http://php.net/auto-globals-jit ! 733: auto_globals_jit = On ! 734: ! 735: ; Maximum size of POST data that PHP will accept. ! 736: ; http://php.net/post-max-size ! 737: post_max_size = 8M ! 738: ! 739: ; Magic quotes are a preprocessing feature of PHP where PHP will attempt to ! 740: ; escape any character sequences in GET, POST, COOKIE and ENV data which might ! 741: ; otherwise corrupt data being placed in resources such as databases before ! 742: ; making that data available to you. Because of character encoding issues and ! 743: ; non-standard SQL implementations across many databases, it's not currently ! 744: ; possible for this feature to be 100% accurate. PHP's default behavior is to ! 745: ; enable the feature. We strongly recommend you use the escaping mechanisms ! 746: ; designed specifically for the database your using instead of relying on this ! 747: ; feature. Also note, this feature has been deprecated as of PHP 5.3.0 and is ! 748: ; scheduled for removal in PHP 6. ! 749: ; Default Value: On ! 750: ; Development Value: Off ! 751: ; Production Value: Off ! 752: ; http://php.net/magic-quotes-gpc ! 753: magic_quotes_gpc = Off ! 754: ! 755: ; Magic quotes for runtime-generated data, e.g. data from SQL, from exec(), etc. ! 756: ; http://php.net/magic-quotes-runtime ! 757: magic_quotes_runtime = Off ! 758: ! 759: ; Use Sybase-style magic quotes (escape ' with '' instead of \'). ! 760: ; http://php.net/magic-quotes-sybase ! 761: magic_quotes_sybase = Off ! 762: ! 763: ; Automatically add files before PHP document. ! 764: ; http://php.net/auto-prepend-file ! 765: auto_prepend_file = ! 766: ! 767: ; Automatically add files after PHP document. ! 768: ; http://php.net/auto-append-file ! 769: auto_append_file = ! 770: ! 771: ; By default, PHP will output a character encoding using ! 772: ; the Content-type: header. To disable sending of the charset, simply ! 773: ; set it to be empty. ! 774: ; ! 775: ; PHP's built-in default is text/html ! 776: ; http://php.net/default-mimetype ! 777: default_mimetype = "text/html" ! 778: ! 779: ; PHP's default character set is set to empty. ! 780: ; http://php.net/default-charset ! 781: ;default_charset = "iso-8859-1" ! 782: ! 783: ; Always populate the $HTTP_RAW_POST_DATA variable. PHP's default behavior is ! 784: ; to disable this feature. ! 785: ; http://php.net/always-populate-raw-post-data ! 786: ;always_populate_raw_post_data = On ! 787: ! 788: ;;;;;;;;;;;;;;;;;;;;;;;;; ! 789: ; Paths and Directories ; ! 790: ;;;;;;;;;;;;;;;;;;;;;;;;; ! 791: ! 792: ; UNIX: "/path1:/path2" ! 793: ;include_path = ".:/php/includes" ! 794: ; ! 795: ; Windows: "\path1;\path2" ! 796: ;include_path = ".;c:\php\includes" ! 797: ; ! 798: ; PHP's default setting for include_path is ".;/path/to/php/pear" ! 799: ; http://php.net/include-path ! 800: ! 801: ; The root of the PHP pages, used only if nonempty. ! 802: ; if PHP was not compiled with FORCE_REDIRECT, you SHOULD set doc_root ! 803: ; if you are running php as a CGI under any web server (other than IIS) ! 804: ; see documentation for security issues. The alternate is to use the ! 805: ; cgi.force_redirect configuration below ! 806: ; http://php.net/doc-root ! 807: doc_root = ! 808: ! 809: ; The directory under which PHP opens the script using /~username used only ! 810: ; if nonempty. ! 811: ; http://php.net/user-dir ! 812: user_dir = ! 813: ! 814: ; Directory in which the loadable extensions (modules) reside. ! 815: ; http://php.net/extension-dir ! 816: ; extension_dir = "./" ! 817: ; On windows: ! 818: ; extension_dir = "ext" ! 819: ! 820: ; Whether or not to enable the dl() function. The dl() function does NOT work ! 821: ; properly in multithreaded servers, such as IIS or Zeus, and is automatically ! 822: ; disabled on them. ! 823: ; http://php.net/enable-dl ! 824: enable_dl = Off ! 825: ! 826: ; cgi.force_redirect is necessary to provide security running PHP as a CGI under ! 827: ; most web servers. Left undefined, PHP turns this on by default. You can ! 828: ; turn it off here AT YOUR OWN RISK ! 829: ; **You CAN safely turn this off for IIS, in fact, you MUST.** ! 830: ; http://php.net/cgi.force-redirect ! 831: ;cgi.force_redirect = 1 ! 832: ! 833: ; if cgi.nph is enabled it will force cgi to always sent Status: 200 with ! 834: ; every request. PHP's default behavior is to disable this feature. ! 835: ;cgi.nph = 1 ! 836: ! 837: ; if cgi.force_redirect is turned on, and you are not running under Apache or Netscape ! 838: ; (iPlanet) web servers, you MAY need to set an environment variable name that PHP ! 839: ; will look for to know it is OK to continue execution. Setting this variable MAY ! 840: ; cause security issues, KNOW WHAT YOU ARE DOING FIRST. ! 841: ; http://php.net/cgi.redirect-status-env ! 842: ;cgi.redirect_status_env = ; ! 843: ! 844: ; cgi.fix_pathinfo provides *real* PATH_INFO/PATH_TRANSLATED support for CGI. PHP's ! 845: ; previous behaviour was to set PATH_TRANSLATED to SCRIPT_FILENAME, and to not grok ! 846: ; what PATH_INFO is. For more information on PATH_INFO, see the cgi specs. Setting ! 847: ; this to 1 will cause PHP CGI to fix its paths to conform to the spec. A setting ! 848: ; of zero causes PHP to behave as before. Default is 1. You should fix your scripts ! 849: ; to use SCRIPT_FILENAME rather than PATH_TRANSLATED. ! 850: ; http://php.net/cgi.fix-pathinfo ! 851: ;cgi.fix_pathinfo=1 ! 852: ! 853: ; FastCGI under IIS (on WINNT based OS) supports the ability to impersonate ! 854: ; security tokens of the calling client. This allows IIS to define the ! 855: ; security context that the request runs under. mod_fastcgi under Apache ! 856: ; does not currently support this feature (03/17/2002) ! 857: ; Set to 1 if running under IIS. Default is zero. ! 858: ; http://php.net/fastcgi.impersonate ! 859: ;fastcgi.impersonate = 1; ! 860: ! 861: ; Disable logging through FastCGI connection. PHP's default behavior is to enable ! 862: ; this feature. ! 863: ;fastcgi.logging = 0 ! 864: ! 865: ; cgi.rfc2616_headers configuration option tells PHP what type of headers to ! 866: ; use when sending HTTP response code. If it's set 0 PHP sends Status: header that ! 867: ; is supported by Apache. When this option is set to 1 PHP will send ! 868: ; RFC2616 compliant header. ! 869: ; Default is zero. ! 870: ; http://php.net/cgi.rfc2616-headers ! 871: ;cgi.rfc2616_headers = 0 ! 872: ! 873: ;;;;;;;;;;;;;;;; ! 874: ; File Uploads ; ! 875: ;;;;;;;;;;;;;;;; ! 876: ! 877: ; Whether to allow HTTP file uploads. ! 878: ; http://php.net/file-uploads ! 879: file_uploads = On ! 880: ! 881: ; Temporary directory for HTTP uploaded files (will use system default if not ! 882: ; specified). ! 883: ; http://php.net/upload-tmp-dir ! 884: ;upload_tmp_dir = ! 885: ! 886: ; Maximum allowed size for uploaded files. ! 887: ; http://php.net/upload-max-filesize ! 888: upload_max_filesize = 2M ! 889: ! 890: ; Maximum number of files that can be uploaded via a single request ! 891: max_file_uploads = 20 ! 892: ! 893: ;;;;;;;;;;;;;;;;;; ! 894: ; Fopen wrappers ; ! 895: ;;;;;;;;;;;;;;;;;; ! 896: ! 897: ; Whether to allow the treatment of URLs (like http:// or ftp://) as files. ! 898: ; http://php.net/allow-url-fopen ! 899: allow_url_fopen = On ! 900: ! 901: ; Whether to allow include/require to open URLs (like http:// or ftp://) as files. ! 902: ; http://php.net/allow-url-include ! 903: allow_url_include = Off ! 904: ! 905: ; Define the anonymous ftp password (your email address). PHP's default setting ! 906: ; for this is empty. ! 907: ; http://php.net/from ! 908: ;from="john@doe.com" ! 909: ! 910: ; Define the User-Agent string. PHP's default setting for this is empty. ! 911: ; http://php.net/user-agent ! 912: ;user_agent="PHP" ! 913: ! 914: ; Default timeout for socket based streams (seconds) ! 915: ; http://php.net/default-socket-timeout ! 916: default_socket_timeout = 60 ! 917: ! 918: ; If your scripts have to deal with files from Macintosh systems, ! 919: ; or you are running on a Mac and need to deal with files from ! 920: ; unix or win32 systems, setting this flag will cause PHP to ! 921: ; automatically detect the EOL character in those files so that ! 922: ; fgets() and file() will work regardless of the source of the file. ! 923: ; http://php.net/auto-detect-line-endings ! 924: ;auto_detect_line_endings = Off ! 925: ! 926: ;;;;;;;;;;;;;;;;;;;;;; ! 927: ; Dynamic Extensions ; ! 928: ;;;;;;;;;;;;;;;;;;;;;; ! 929: ! 930: ; If you wish to have an extension loaded automatically, use the following ! 931: ; syntax: ! 932: ; ! 933: ; extension=modulename.extension ! 934: ; ! 935: ; For example, on Windows: ! 936: ; ! 937: ; extension=msql.dll ! 938: ; ! 939: ; ... or under UNIX: ! 940: ; ! 941: ; extension=msql.so ! 942: ; ! 943: ; ... or with a path: ! 944: ; ! 945: ; extension=/path/to/extension/msql.so ! 946: ; ! 947: ; If you only provide the name of the extension, PHP will look for it in its ! 948: ; default extension directory. ! 949: ; ! 950: ; Windows Extensions ! 951: ; Note that ODBC support is built in, so no dll is needed for it. ! 952: ; Note that many DLL files are located in the extensions/ (PHP 4) ext/ (PHP 5) ! 953: ; extension folders as well as the separate PECL DLL download (PHP 5). ! 954: ; Be sure to appropriately set the extension_dir directive. ! 955: ; ! 956: ;extension=php_bz2.dll ! 957: ;extension=php_curl.dll ! 958: ;extension=php_dba.dll ! 959: ;extension=php_exif.dll ! 960: ;extension=php_fileinfo.dll ! 961: ;extension=php_gd2.dll ! 962: ;extension=php_gettext.dll ! 963: ;extension=php_gmp.dll ! 964: ;extension=php_intl.dll ! 965: ;extension=php_imap.dll ! 966: ;extension=php_interbase.dll ! 967: ;extension=php_ldap.dll ! 968: ;extension=php_mbstring.dll ! 969: ;extension=php_ming.dll ! 970: ;extension=php_mssql.dll ! 971: ;extension=php_mysql.dll ! 972: ;extension=php_mysqli.dll ! 973: ;extension=php_oci8.dll ; Use with Oracle 10gR2 Instant Client ! 974: ;extension=php_oci8_11g.dll ; Use with Oracle 11g Instant Client ! 975: ;extension=php_openssl.dll ! 976: ;extension=php_pdo_firebird.dll ! 977: ;extension=php_pdo_mssql.dll ! 978: ;extension=php_pdo_mysql.dll ! 979: ;extension=php_pdo_oci.dll ! 980: ;extension=php_pdo_odbc.dll ! 981: ;extension=php_pdo_pgsql.dll ! 982: ;extension=php_pdo_sqlite.dll ! 983: ;extension=php_pgsql.dll ! 984: ;extension=php_phar.dll ! 985: ;extension=php_pspell.dll ! 986: ;extension=php_shmop.dll ! 987: ;extension=php_snmp.dll ! 988: ;extension=php_soap.dll ! 989: ;extension=php_sockets.dll ! 990: ;extension=php_sqlite.dll ! 991: ;extension=php_sqlite3.dll ! 992: ;extension=php_sybase_ct.dll ! 993: ;extension=php_tidy.dll ! 994: ;extension=php_xmlrpc.dll ! 995: ;extension=php_xsl.dll ! 996: ;extension=php_zip.dll ! 997: ! 998: ;;;;;;;;;;;;;;;;;;; ! 999: ; Module Settings ; ! 1000: ;;;;;;;;;;;;;;;;;;; ! 1001: ! 1002: [Date] ! 1003: ; Defines the default timezone used by the date functions ! 1004: ; http://php.net/date.timezone ! 1005: ;date.timezone = ! 1006: ! 1007: ; http://php.net/date.default-latitude ! 1008: ;date.default_latitude = 31.7667 ! 1009: ! 1010: ; http://php.net/date.default-longitude ! 1011: ;date.default_longitude = 35.2333 ! 1012: ! 1013: ; http://php.net/date.sunrise-zenith ! 1014: ;date.sunrise_zenith = 90.583333 ! 1015: ! 1016: ; http://php.net/date.sunset-zenith ! 1017: ;date.sunset_zenith = 90.583333 ! 1018: ! 1019: [filter] ! 1020: ; http://php.net/filter.default ! 1021: ;filter.default = unsafe_raw ! 1022: ! 1023: ; http://php.net/filter.default-flags ! 1024: ;filter.default_flags = ! 1025: ! 1026: [iconv] ! 1027: ;iconv.input_encoding = ISO-8859-1 ! 1028: ;iconv.internal_encoding = ISO-8859-1 ! 1029: ;iconv.output_encoding = ISO-8859-1 ! 1030: ! 1031: [intl] ! 1032: ;intl.default_locale = ! 1033: ; This directive allows you to produce PHP errors when some error ! 1034: ; happens within intl functions. The value is the level of the error produced. ! 1035: ; Default is 0, which does not produce any errors. ! 1036: ;intl.error_level = E_WARNING ! 1037: ! 1038: [sqlite] ! 1039: ; http://php.net/sqlite.assoc-case ! 1040: ;sqlite.assoc_case = 0 ! 1041: ! 1042: [sqlite3] ! 1043: ;sqlite3.extension_dir = ! 1044: ! 1045: [Pcre] ! 1046: ;PCRE library backtracking limit. ! 1047: ; http://php.net/pcre.backtrack-limit ! 1048: ;pcre.backtrack_limit=100000 ! 1049: ! 1050: ;PCRE library recursion limit. ! 1051: ;Please note that if you set this value to a high number you may consume all ! 1052: ;the available process stack and eventually crash PHP (due to reaching the ! 1053: ;stack size limit imposed by the Operating System). ! 1054: ; http://php.net/pcre.recursion-limit ! 1055: ;pcre.recursion_limit=100000 ! 1056: ! 1057: [Pdo] ! 1058: ; Whether to pool ODBC connections. Can be one of "strict", "relaxed" or "off" ! 1059: ; http://php.net/pdo-odbc.connection-pooling ! 1060: ;pdo_odbc.connection_pooling=strict ! 1061: ! 1062: ;pdo_odbc.db2_instance_name ! 1063: ! 1064: [Pdo_mysql] ! 1065: ; If mysqlnd is used: Number of cache slots for the internal result set cache ! 1066: ; http://php.net/pdo_mysql.cache_size ! 1067: pdo_mysql.cache_size = 2000 ! 1068: ! 1069: ; Default socket name for local MySQL connects. If empty, uses the built-in ! 1070: ; MySQL defaults. ! 1071: ; http://php.net/pdo_mysql.default-socket ! 1072: pdo_mysql.default_socket= ! 1073: ! 1074: [Phar] ! 1075: ; http://php.net/phar.readonly ! 1076: ;phar.readonly = On ! 1077: ! 1078: ; http://php.net/phar.require-hash ! 1079: ;phar.require_hash = On ! 1080: ! 1081: ;phar.cache_list = ! 1082: ! 1083: [Syslog] ! 1084: ; Whether or not to define the various syslog variables (e.g. $LOG_PID, ! 1085: ; $LOG_CRON, etc.). Turning it off is a good idea performance-wise. In ! 1086: ; runtime, you can define these variables by calling define_syslog_variables(). ! 1087: ; http://php.net/define-syslog-variables ! 1088: define_syslog_variables = Off ! 1089: ! 1090: [mail function] ! 1091: ; For Win32 only. ! 1092: ; http://php.net/smtp ! 1093: SMTP = localhost ! 1094: ; http://php.net/smtp-port ! 1095: smtp_port = 25 ! 1096: ! 1097: ; For Win32 only. ! 1098: ; http://php.net/sendmail-from ! 1099: ;sendmail_from = me@example.com ! 1100: ! 1101: ; For Unix only. You may supply arguments as well (default: "sendmail -t -i"). ! 1102: ; http://php.net/sendmail-path ! 1103: ;sendmail_path = ! 1104: ! 1105: ; Force the addition of the specified parameters to be passed as extra parameters ! 1106: ; to the sendmail binary. These parameters will always replace the value of ! 1107: ; the 5th parameter to mail(), even in safe mode. ! 1108: ;mail.force_extra_parameters = ! 1109: ! 1110: ; Add X-PHP-Originating-Script: that will include uid of the script followed by the filename ! 1111: mail.add_x_header = On ! 1112: ! 1113: ; Log all mail() calls including the full path of the script, line #, to address and headers ! 1114: ;mail.log = ! 1115: ! 1116: [SQL] ! 1117: ; http://php.net/sql.safe-mode ! 1118: sql.safe_mode = Off ! 1119: ! 1120: [ODBC] ! 1121: ; http://php.net/odbc.default-db ! 1122: ;odbc.default_db = Not yet implemented ! 1123: ! 1124: ; http://php.net/odbc.default-user ! 1125: ;odbc.default_user = Not yet implemented ! 1126: ! 1127: ; http://php.net/odbc.default-pw ! 1128: ;odbc.default_pw = Not yet implemented ! 1129: ! 1130: ; Controls the ODBC cursor model. ! 1131: ; Default: SQL_CURSOR_STATIC (default). ! 1132: ;odbc.default_cursortype ! 1133: ! 1134: ; Allow or prevent persistent links. ! 1135: ; http://php.net/odbc.allow-persistent ! 1136: odbc.allow_persistent = On ! 1137: ! 1138: ; Check that a connection is still valid before reuse. ! 1139: ; http://php.net/odbc.check-persistent ! 1140: odbc.check_persistent = On ! 1141: ! 1142: ; Maximum number of persistent links. -1 means no limit. ! 1143: ; http://php.net/odbc.max-persistent ! 1144: odbc.max_persistent = -1 ! 1145: ! 1146: ; Maximum number of links (persistent + non-persistent). -1 means no limit. ! 1147: ; http://php.net/odbc.max-links ! 1148: odbc.max_links = -1 ! 1149: ! 1150: ; Handling of LONG fields. Returns number of bytes to variables. 0 means ! 1151: ; passthru. ! 1152: ; http://php.net/odbc.defaultlrl ! 1153: odbc.defaultlrl = 4096 ! 1154: ! 1155: ; Handling of binary data. 0 means passthru, 1 return as is, 2 convert to char. ! 1156: ; See the documentation on odbc_binmode and odbc_longreadlen for an explanation ! 1157: ; of odbc.defaultlrl and odbc.defaultbinmode ! 1158: ; http://php.net/odbc.defaultbinmode ! 1159: odbc.defaultbinmode = 1 ! 1160: ! 1161: ;birdstep.max_links = -1 ! 1162: ! 1163: [Interbase] ! 1164: ; Allow or prevent persistent links. ! 1165: ibase.allow_persistent = 1 ! 1166: ! 1167: ; Maximum number of persistent links. -1 means no limit. ! 1168: ibase.max_persistent = -1 ! 1169: ! 1170: ; Maximum number of links (persistent + non-persistent). -1 means no limit. ! 1171: ibase.max_links = -1 ! 1172: ! 1173: ; Default database name for ibase_connect(). ! 1174: ;ibase.default_db = ! 1175: ! 1176: ; Default username for ibase_connect(). ! 1177: ;ibase.default_user = ! 1178: ! 1179: ; Default password for ibase_connect(). ! 1180: ;ibase.default_password = ! 1181: ! 1182: ; Default charset for ibase_connect(). ! 1183: ;ibase.default_charset = ! 1184: ! 1185: ; Default timestamp format. ! 1186: ibase.timestampformat = "%Y-%m-%d %H:%M:%S" ! 1187: ! 1188: ; Default date format. ! 1189: ibase.dateformat = "%Y-%m-%d" ! 1190: ! 1191: ; Default time format. ! 1192: ibase.timeformat = "%H:%M:%S" ! 1193: ! 1194: [MySQL] ! 1195: ; Allow accessing, from PHP's perspective, local files with LOAD DATA statements ! 1196: ; http://php.net/mysql.allow_local_infile ! 1197: mysql.allow_local_infile = On ! 1198: ! 1199: ; Allow or prevent persistent links. ! 1200: ; http://php.net/mysql.allow-persistent ! 1201: mysql.allow_persistent = On ! 1202: ! 1203: ; If mysqlnd is used: Number of cache slots for the internal result set cache ! 1204: ; http://php.net/mysql.cache_size ! 1205: mysql.cache_size = 2000 ! 1206: ! 1207: ; Maximum number of persistent links. -1 means no limit. ! 1208: ; http://php.net/mysql.max-persistent ! 1209: mysql.max_persistent = -1 ! 1210: ! 1211: ; Maximum number of links (persistent + non-persistent). -1 means no limit. ! 1212: ; http://php.net/mysql.max-links ! 1213: mysql.max_links = -1 ! 1214: ! 1215: ; Default port number for mysql_connect(). If unset, mysql_connect() will use ! 1216: ; the $MYSQL_TCP_PORT or the mysql-tcp entry in /etc/services or the ! 1217: ; compile-time value defined MYSQL_PORT (in that order). Win32 will only look ! 1218: ; at MYSQL_PORT. ! 1219: ; http://php.net/mysql.default-port ! 1220: mysql.default_port = ! 1221: ! 1222: ; Default socket name for local MySQL connects. If empty, uses the built-in ! 1223: ; MySQL defaults. ! 1224: ; http://php.net/mysql.default-socket ! 1225: mysql.default_socket = ! 1226: ! 1227: ; Default host for mysql_connect() (doesn't apply in safe mode). ! 1228: ; http://php.net/mysql.default-host ! 1229: mysql.default_host = ! 1230: ! 1231: ; Default user for mysql_connect() (doesn't apply in safe mode). ! 1232: ; http://php.net/mysql.default-user ! 1233: mysql.default_user = ! 1234: ! 1235: ; Default password for mysql_connect() (doesn't apply in safe mode). ! 1236: ; Note that this is generally a *bad* idea to store passwords in this file. ! 1237: ; *Any* user with PHP access can run 'echo get_cfg_var("mysql.default_password") ! 1238: ; and reveal this password! And of course, any users with read access to this ! 1239: ; file will be able to reveal the password as well. ! 1240: ; http://php.net/mysql.default-password ! 1241: mysql.default_password = ! 1242: ! 1243: ; Maximum time (in seconds) for connect timeout. -1 means no limit ! 1244: ; http://php.net/mysql.connect-timeout ! 1245: mysql.connect_timeout = 60 ! 1246: ! 1247: ; Trace mode. When trace_mode is active (=On), warnings for table/index scans and ! 1248: ; SQL-Errors will be displayed. ! 1249: ; http://php.net/mysql.trace-mode ! 1250: mysql.trace_mode = Off ! 1251: ! 1252: [MySQLi] ! 1253: ! 1254: ; Maximum number of persistent links. -1 means no limit. ! 1255: ; http://php.net/mysqli.max-persistent ! 1256: mysqli.max_persistent = -1 ! 1257: ! 1258: ; Maximum number of links. -1 means no limit. ! 1259: ; http://php.net/mysqli.max-links ! 1260: mysqli.max_links = -1 ! 1261: ! 1262: ; If mysqlnd is used: Number of cache slots for the internal result set cache ! 1263: ; http://php.net/mysqli.cache_size ! 1264: mysqli.cache_size = 2000 ! 1265: ! 1266: ; Default port number for mysqli_connect(). If unset, mysqli_connect() will use ! 1267: ; the $MYSQL_TCP_PORT or the mysql-tcp entry in /etc/services or the ! 1268: ; compile-time value defined MYSQL_PORT (in that order). Win32 will only look ! 1269: ; at MYSQL_PORT. ! 1270: ; http://php.net/mysqli.default-port ! 1271: mysqli.default_port = 3306 ! 1272: ! 1273: ; Default socket name for local MySQL connects. If empty, uses the built-in ! 1274: ; MySQL defaults. ! 1275: ; http://php.net/mysqli.default-socket ! 1276: mysqli.default_socket = ! 1277: ! 1278: ; Default host for mysql_connect() (doesn't apply in safe mode). ! 1279: ; http://php.net/mysqli.default-host ! 1280: mysqli.default_host = ! 1281: ! 1282: ; Default user for mysql_connect() (doesn't apply in safe mode). ! 1283: ; http://php.net/mysqli.default-user ! 1284: mysqli.default_user = ! 1285: ! 1286: ; Default password for mysqli_connect() (doesn't apply in safe mode). ! 1287: ; Note that this is generally a *bad* idea to store passwords in this file. ! 1288: ; *Any* user with PHP access can run 'echo get_cfg_var("mysqli.default_pw") ! 1289: ; and reveal this password! And of course, any users with read access to this ! 1290: ; file will be able to reveal the password as well. ! 1291: ; http://php.net/mysqli.default-pw ! 1292: mysqli.default_pw = ! 1293: ! 1294: ; Allow or prevent reconnect ! 1295: mysqli.reconnect = Off ! 1296: ! 1297: [mysqlnd] ! 1298: ; Enable / Disable collection of general statstics by mysqlnd which can be ! 1299: ; used to tune and monitor MySQL operations. ! 1300: ; http://php.net/mysqlnd.collect_statistics ! 1301: mysqlnd.collect_statistics = On ! 1302: ! 1303: ; Enable / Disable collection of memory usage statstics by mysqlnd which can be ! 1304: ; used to tune and monitor MySQL operations. ! 1305: ; http://php.net/mysqlnd.collect_memory_statistics ! 1306: mysqlnd.collect_memory_statistics = On ! 1307: ! 1308: ; Size of a pre-allocated buffer used when sending commands to MySQL in bytes. ! 1309: ; http://php.net/mysqlnd.net_cmd_buffer_size ! 1310: ;mysqlnd.net_cmd_buffer_size = 2048 ! 1311: ! 1312: ; Size of a pre-allocated buffer used for reading data sent by the server in ! 1313: ; bytes. ! 1314: ; http://php.net/mysqlnd.net_read_buffer_size ! 1315: ;mysqlnd.net_read_buffer_size = 32768 ! 1316: ! 1317: [OCI8] ! 1318: ! 1319: ; Connection: Enables privileged connections using external ! 1320: ; credentials (OCI_SYSOPER, OCI_SYSDBA) ! 1321: ; http://php.net/oci8.privileged-connect ! 1322: ;oci8.privileged_connect = Off ! 1323: ! 1324: ; Connection: The maximum number of persistent OCI8 connections per ! 1325: ; process. Using -1 means no limit. ! 1326: ; http://php.net/oci8.max-persistent ! 1327: ;oci8.max_persistent = -1 ! 1328: ! 1329: ; Connection: The maximum number of seconds a process is allowed to ! 1330: ; maintain an idle persistent connection. Using -1 means idle ! 1331: ; persistent connections will be maintained forever. ! 1332: ; http://php.net/oci8.persistent-timeout ! 1333: ;oci8.persistent_timeout = -1 ! 1334: ! 1335: ; Connection: The number of seconds that must pass before issuing a ! 1336: ; ping during oci_pconnect() to check the connection validity. When ! 1337: ; set to 0, each oci_pconnect() will cause a ping. Using -1 disables ! 1338: ; pings completely. ! 1339: ; http://php.net/oci8.ping-interval ! 1340: ;oci8.ping_interval = 60 ! 1341: ! 1342: ; Connection: Set this to a user chosen connection class to be used ! 1343: ; for all pooled server requests with Oracle 11g Database Resident ! 1344: ; Connection Pooling (DRCP). To use DRCP, this value should be set to ! 1345: ; the same string for all web servers running the same application, ! 1346: ; the database pool must be configured, and the connection string must ! 1347: ; specify to use a pooled server. ! 1348: ;oci8.connection_class = ! 1349: ! 1350: ; High Availability: Using On lets PHP receive Fast Application ! 1351: ; Notification (FAN) events generated when a database node fails. The ! 1352: ; database must also be configured to post FAN events. ! 1353: ;oci8.events = Off ! 1354: ! 1355: ; Tuning: This option enables statement caching, and specifies how ! 1356: ; many statements to cache. Using 0 disables statement caching. ! 1357: ; http://php.net/oci8.statement-cache-size ! 1358: ;oci8.statement_cache_size = 20 ! 1359: ! 1360: ; Tuning: Enables statement prefetching and sets the default number of ! 1361: ; rows that will be fetched automatically after statement execution. ! 1362: ; http://php.net/oci8.default-prefetch ! 1363: ;oci8.default_prefetch = 100 ! 1364: ! 1365: ; Compatibility. Using On means oci_close() will not close ! 1366: ; oci_connect() and oci_new_connect() connections. ! 1367: ; http://php.net/oci8.old-oci-close-semantics ! 1368: ;oci8.old_oci_close_semantics = Off ! 1369: ! 1370: [PostgresSQL] ! 1371: ; Allow or prevent persistent links. ! 1372: ; http://php.net/pgsql.allow-persistent ! 1373: pgsql.allow_persistent = On ! 1374: ! 1375: ; Detect broken persistent links always with pg_pconnect(). ! 1376: ; Auto reset feature requires a little overheads. ! 1377: ; http://php.net/pgsql.auto-reset-persistent ! 1378: pgsql.auto_reset_persistent = Off ! 1379: ! 1380: ; Maximum number of persistent links. -1 means no limit. ! 1381: ; http://php.net/pgsql.max-persistent ! 1382: pgsql.max_persistent = -1 ! 1383: ! 1384: ; Maximum number of links (persistent+non persistent). -1 means no limit. ! 1385: ; http://php.net/pgsql.max-links ! 1386: pgsql.max_links = -1 ! 1387: ! 1388: ; Ignore PostgreSQL backends Notice message or not. ! 1389: ; Notice message logging require a little overheads. ! 1390: ; http://php.net/pgsql.ignore-notice ! 1391: pgsql.ignore_notice = 0 ! 1392: ! 1393: ; Log PostgreSQL backends Noitce message or not. ! 1394: ; Unless pgsql.ignore_notice=0, module cannot log notice message. ! 1395: ; http://php.net/pgsql.log-notice ! 1396: pgsql.log_notice = 0 ! 1397: ! 1398: [Sybase-CT] ! 1399: ; Allow or prevent persistent links. ! 1400: ; http://php.net/sybct.allow-persistent ! 1401: sybct.allow_persistent = On ! 1402: ! 1403: ; Maximum number of persistent links. -1 means no limit. ! 1404: ; http://php.net/sybct.max-persistent ! 1405: sybct.max_persistent = -1 ! 1406: ! 1407: ; Maximum number of links (persistent + non-persistent). -1 means no limit. ! 1408: ; http://php.net/sybct.max-links ! 1409: sybct.max_links = -1 ! 1410: ! 1411: ; Minimum server message severity to display. ! 1412: ; http://php.net/sybct.min-server-severity ! 1413: sybct.min_server_severity = 10 ! 1414: ! 1415: ; Minimum client message severity to display. ! 1416: ; http://php.net/sybct.min-client-severity ! 1417: sybct.min_client_severity = 10 ! 1418: ! 1419: ; Set per-context timeout ! 1420: ; http://php.net/sybct.timeout ! 1421: ;sybct.timeout= ! 1422: ! 1423: ;sybct.packet_size ! 1424: ! 1425: ; The maximum time in seconds to wait for a connection attempt to succeed before returning failure. ! 1426: ; Default: one minute ! 1427: ;sybct.login_timeout= ! 1428: ! 1429: ; The name of the host you claim to be connecting from, for display by sp_who. ! 1430: ; Default: none ! 1431: ;sybct.hostname= ! 1432: ! 1433: ; Allows you to define how often deadlocks are to be retried. -1 means "forever". ! 1434: ; Default: 0 ! 1435: ;sybct.deadlock_retry_count= ! 1436: ! 1437: [bcmath] ! 1438: ; Number of decimal digits for all bcmath functions. ! 1439: ; http://php.net/bcmath.scale ! 1440: bcmath.scale = 0 ! 1441: ! 1442: [browscap] ! 1443: ; http://php.net/browscap ! 1444: ;browscap = extra/browscap.ini ! 1445: ! 1446: [Session] ! 1447: ; Handler used to store/retrieve data. ! 1448: ; http://php.net/session.save-handler ! 1449: session.save_handler = files ! 1450: ! 1451: ; Argument passed to save_handler. In the case of files, this is the path ! 1452: ; where data files are stored. Note: Windows users have to change this ! 1453: ; variable in order to use PHP's session functions. ! 1454: ; ! 1455: ; The path can be defined as: ! 1456: ; ! 1457: ; session.save_path = "N;/path" ! 1458: ; ! 1459: ; where N is an integer. Instead of storing all the session files in ! 1460: ; /path, what this will do is use subdirectories N-levels deep, and ! 1461: ; store the session data in those directories. This is useful if you ! 1462: ; or your OS have problems with lots of files in one directory, and is ! 1463: ; a more efficient layout for servers that handle lots of sessions. ! 1464: ; ! 1465: ; NOTE 1: PHP will not create this directory structure automatically. ! 1466: ; You can use the script in the ext/session dir for that purpose. ! 1467: ; NOTE 2: See the section on garbage collection below if you choose to ! 1468: ; use subdirectories for session storage ! 1469: ; ! 1470: ; The file storage module creates files using mode 600 by default. ! 1471: ; You can change that by using ! 1472: ; ! 1473: ; session.save_path = "N;MODE;/path" ! 1474: ; ! 1475: ; where MODE is the octal representation of the mode. Note that this ! 1476: ; does not overwrite the process's umask. ! 1477: ; http://php.net/session.save-path ! 1478: ;session.save_path = "/tmp" ! 1479: ! 1480: ; Whether to use cookies. ! 1481: ; http://php.net/session.use-cookies ! 1482: session.use_cookies = 1 ! 1483: ! 1484: ; http://php.net/session.cookie-secure ! 1485: ;session.cookie_secure = ! 1486: ! 1487: ; This option forces PHP to fetch and use a cookie for storing and maintaining ! 1488: ; the session id. We encourage this operation as it's very helpful in combatting ! 1489: ; session hijacking when not specifying and managing your own session id. It is ! 1490: ; not the end all be all of session hijacking defense, but it's a good start. ! 1491: ; http://php.net/session.use-only-cookies ! 1492: session.use_only_cookies = 1 ! 1493: ! 1494: ; Name of the session (used as cookie name). ! 1495: ; http://php.net/session.name ! 1496: session.name = PHPSESSID ! 1497: ! 1498: ; Initialize session on request startup. ! 1499: ; http://php.net/session.auto-start ! 1500: session.auto_start = 0 ! 1501: ! 1502: ; Lifetime in seconds of cookie or, if 0, until browser is restarted. ! 1503: ; http://php.net/session.cookie-lifetime ! 1504: session.cookie_lifetime = 0 ! 1505: ! 1506: ; The path for which the cookie is valid. ! 1507: ; http://php.net/session.cookie-path ! 1508: session.cookie_path = / ! 1509: ! 1510: ; The domain for which the cookie is valid. ! 1511: ; http://php.net/session.cookie-domain ! 1512: session.cookie_domain = ! 1513: ! 1514: ; Whether or not to add the httpOnly flag to the cookie, which makes it inaccessible to browser scripting languages such as JavaScript. ! 1515: ; http://php.net/session.cookie-httponly ! 1516: session.cookie_httponly = ! 1517: ! 1518: ; Handler used to serialize data. php is the standard serializer of PHP. ! 1519: ; http://php.net/session.serialize-handler ! 1520: session.serialize_handler = php ! 1521: ! 1522: ; Defines the probability that the 'garbage collection' process is started ! 1523: ; on every session initialization. The probability is calculated by using ! 1524: ; gc_probability/gc_divisor. Where session.gc_probability is the numerator ! 1525: ; and gc_divisor is the denominator in the equation. Setting this value to 1 ! 1526: ; when the session.gc_divisor value is 100 will give you approximately a 1% chance ! 1527: ; the gc will run on any give request. ! 1528: ; Default Value: 1 ! 1529: ; Development Value: 1 ! 1530: ; Production Value: 1 ! 1531: ; http://php.net/session.gc-probability ! 1532: session.gc_probability = 1 ! 1533: ! 1534: ; Defines the probability that the 'garbage collection' process is started on every ! 1535: ; session initialization. The probability is calculated by using the following equation: ! 1536: ; gc_probability/gc_divisor. Where session.gc_probability is the numerator and ! 1537: ; session.gc_divisor is the denominator in the equation. Setting this value to 1 ! 1538: ; when the session.gc_divisor value is 100 will give you approximately a 1% chance ! 1539: ; the gc will run on any give request. Increasing this value to 1000 will give you ! 1540: ; a 0.1% chance the gc will run on any give request. For high volume production servers, ! 1541: ; this is a more efficient approach. ! 1542: ; Default Value: 100 ! 1543: ; Development Value: 1000 ! 1544: ; Production Value: 1000 ! 1545: ; http://php.net/session.gc-divisor ! 1546: session.gc_divisor = 1000 ! 1547: ! 1548: ; After this number of seconds, stored data will be seen as 'garbage' and ! 1549: ; cleaned up by the garbage collection process. ! 1550: ; http://php.net/session.gc-maxlifetime ! 1551: session.gc_maxlifetime = 1440 ! 1552: ! 1553: ; NOTE: If you are using the subdirectory option for storing session files ! 1554: ; (see session.save_path above), then garbage collection does *not* ! 1555: ; happen automatically. You will need to do your own garbage ! 1556: ; collection through a shell script, cron entry, or some other method. ! 1557: ; For example, the following script would is the equivalent of ! 1558: ; setting session.gc_maxlifetime to 1440 (1440 seconds = 24 minutes): ! 1559: ; cd /path/to/sessions; find -cmin +24 | xargs rm ! 1560: ! 1561: ; PHP 4.2 and less have an undocumented feature/bug that allows you to ! 1562: ; to initialize a session variable in the global scope, even when register_globals ! 1563: ; is disabled. PHP 4.3 and later will warn you, if this feature is used. ! 1564: ; You can disable the feature and the warning separately. At this time, ! 1565: ; the warning is only displayed, if bug_compat_42 is enabled. This feature ! 1566: ; introduces some serious security problems if not handled correctly. It's ! 1567: ; recommended that you do not use this feature on production servers. But you ! 1568: ; should enable this on development servers and enable the warning as well. If you ! 1569: ; do not enable the feature on development servers, you won't be warned when it's ! 1570: ; used and debugging errors caused by this can be difficult to track down. ! 1571: ; Default Value: On ! 1572: ; Development Value: On ! 1573: ; Production Value: Off ! 1574: ; http://php.net/session.bug-compat-42 ! 1575: session.bug_compat_42 = On ! 1576: ! 1577: ; This setting controls whether or not you are warned by PHP when initializing a ! 1578: ; session value into the global space. session.bug_compat_42 must be enabled before ! 1579: ; these warnings can be issued by PHP. See the directive above for more information. ! 1580: ; Default Value: On ! 1581: ; Development Value: On ! 1582: ; Production Value: Off ! 1583: ; http://php.net/session.bug-compat-warn ! 1584: session.bug_compat_warn = On ! 1585: ! 1586: ; Check HTTP Referer to invalidate externally stored URLs containing ids. ! 1587: ; HTTP_REFERER has to contain this substring for the session to be ! 1588: ; considered as valid. ! 1589: ; http://php.net/session.referer-check ! 1590: session.referer_check = ! 1591: ! 1592: ; How many bytes to read from the file. ! 1593: ; http://php.net/session.entropy-length ! 1594: session.entropy_length = 0 ! 1595: ! 1596: ; Specified here to create the session id. ! 1597: ; http://php.net/session.entropy-file ! 1598: ;session.entropy_file = /dev/urandom ! 1599: session.entropy_file = ! 1600: ! 1601: ; http://php.net/session.entropy-length ! 1602: ;session.entropy_length = 16 ! 1603: ! 1604: ; Set to {nocache,private,public,} to determine HTTP caching aspects ! 1605: ; or leave this empty to avoid sending anti-caching headers. ! 1606: ; http://php.net/session.cache-limiter ! 1607: session.cache_limiter = nocache ! 1608: ! 1609: ; Document expires after n minutes. ! 1610: ; http://php.net/session.cache-expire ! 1611: session.cache_expire = 180 ! 1612: ! 1613: ; trans sid support is disabled by default. ! 1614: ; Use of trans sid may risk your users security. ! 1615: ; Use this option with caution. ! 1616: ; - User may send URL contains active session ID ! 1617: ; to other person via. email/irc/etc. ! 1618: ; - URL that contains active session ID may be stored ! 1619: ; in publically accessible computer. ! 1620: ; - User may access your site with the same session ID ! 1621: ; always using URL stored in browser's history or bookmarks. ! 1622: ; http://php.net/session.use-trans-sid ! 1623: session.use_trans_sid = 0 ! 1624: ! 1625: ; Select a hash function for use in generating session ids. ! 1626: ; Possible Values ! 1627: ; 0 (MD5 128 bits) ! 1628: ; 1 (SHA-1 160 bits) ! 1629: ; This option may also be set to the name of any hash function supported by ! 1630: ; the hash extension. A list of available hashes is returned by the hash_alogs() ! 1631: ; function. ! 1632: ; http://php.net/session.hash-function ! 1633: session.hash_function = 0 ! 1634: ! 1635: ; Define how many bits are stored in each character when converting ! 1636: ; the binary hash data to something readable. ! 1637: ; Possible values: ! 1638: ; 4 (4 bits: 0-9, a-f) ! 1639: ; 5 (5 bits: 0-9, a-v) ! 1640: ; 6 (6 bits: 0-9, a-z, A-Z, "-", ",") ! 1641: ; Default Value: 4 ! 1642: ; Development Value: 5 ! 1643: ; Production Value: 5 ! 1644: ; http://php.net/session.hash-bits-per-character ! 1645: session.hash_bits_per_character = 5 ! 1646: ! 1647: ; The URL rewriter will look for URLs in a defined set of HTML tags. ! 1648: ; form/fieldset are special; if you include them here, the rewriter will ! 1649: ; add a hidden <input> field with the info which is otherwise appended ! 1650: ; to URLs. If you want XHTML conformity, remove the form entry. ! 1651: ; Note that all valid entries require a "=", even if no value follows. ! 1652: ; Default Value: "a=href,area=href,frame=src,form=,fieldset=" ! 1653: ; Development Value: "a=href,area=href,frame=src,input=src,form=fakeentry" ! 1654: ; Production Value: "a=href,area=href,frame=src,input=src,form=fakeentry" ! 1655: ; http://php.net/url-rewriter.tags ! 1656: url_rewriter.tags = "a=href,area=href,frame=src,input=src,form=fakeentry" ! 1657: ! 1658: [MSSQL] ! 1659: ; Allow or prevent persistent links. ! 1660: mssql.allow_persistent = On ! 1661: ! 1662: ; Maximum number of persistent links. -1 means no limit. ! 1663: mssql.max_persistent = -1 ! 1664: ! 1665: ; Maximum number of links (persistent+non persistent). -1 means no limit. ! 1666: mssql.max_links = -1 ! 1667: ! 1668: ; Minimum error severity to display. ! 1669: mssql.min_error_severity = 10 ! 1670: ! 1671: ; Minimum message severity to display. ! 1672: mssql.min_message_severity = 10 ! 1673: ! 1674: ; Compatibility mode with old versions of PHP 3.0. ! 1675: mssql.compatability_mode = Off ! 1676: ! 1677: ; Connect timeout ! 1678: ;mssql.connect_timeout = 5 ! 1679: ! 1680: ; Query timeout ! 1681: ;mssql.timeout = 60 ! 1682: ! 1683: ; Valid range 0 - 2147483647. Default = 4096. ! 1684: ;mssql.textlimit = 4096 ! 1685: ! 1686: ; Valid range 0 - 2147483647. Default = 4096. ! 1687: ;mssql.textsize = 4096 ! 1688: ! 1689: ; Limits the number of records in each batch. 0 = all records in one batch. ! 1690: ;mssql.batchsize = 0 ! 1691: ! 1692: ; Specify how datetime and datetim4 columns are returned ! 1693: ; On => Returns data converted to SQL server settings ! 1694: ; Off => Returns values as YYYY-MM-DD hh:mm:ss ! 1695: ;mssql.datetimeconvert = On ! 1696: ! 1697: ; Use NT authentication when connecting to the server ! 1698: mssql.secure_connection = Off ! 1699: ! 1700: ; Specify max number of processes. -1 = library default ! 1701: ; msdlib defaults to 25 ! 1702: ; FreeTDS defaults to 4096 ! 1703: ;mssql.max_procs = -1 ! 1704: ! 1705: ; Specify client character set. ! 1706: ; If empty or not set the client charset from freetds.comf is used ! 1707: ; This is only used when compiled with FreeTDS ! 1708: ;mssql.charset = "ISO-8859-1" ! 1709: ! 1710: [Assertion] ! 1711: ; Assert(expr); active by default. ! 1712: ; http://php.net/assert.active ! 1713: ;assert.active = On ! 1714: ! 1715: ; Issue a PHP warning for each failed assertion. ! 1716: ; http://php.net/assert.warning ! 1717: ;assert.warning = On ! 1718: ! 1719: ; Don't bail out by default. ! 1720: ; http://php.net/assert.bail ! 1721: ;assert.bail = Off ! 1722: ! 1723: ; User-function to be called if an assertion fails. ! 1724: ; http://php.net/assert.callback ! 1725: ;assert.callback = 0 ! 1726: ! 1727: ; Eval the expression with current error_reporting(). Set to true if you want ! 1728: ; error_reporting(0) around the eval(). ! 1729: ; http://php.net/assert.quiet-eval ! 1730: ;assert.quiet_eval = 0 ! 1731: ! 1732: [COM] ! 1733: ; path to a file containing GUIDs, IIDs or filenames of files with TypeLibs ! 1734: ; http://php.net/com.typelib-file ! 1735: ;com.typelib_file = ! 1736: ! 1737: ; allow Distributed-COM calls ! 1738: ; http://php.net/com.allow-dcom ! 1739: ;com.allow_dcom = true ! 1740: ! 1741: ; autoregister constants of a components typlib on com_load() ! 1742: ; http://php.net/com.autoregister-typelib ! 1743: ;com.autoregister_typelib = true ! 1744: ! 1745: ; register constants casesensitive ! 1746: ; http://php.net/com.autoregister-casesensitive ! 1747: ;com.autoregister_casesensitive = false ! 1748: ! 1749: ; show warnings on duplicate constant registrations ! 1750: ; http://php.net/com.autoregister-verbose ! 1751: ;com.autoregister_verbose = true ! 1752: ! 1753: ; The default character set code-page to use when passing strings to and from COM objects. ! 1754: ; Default: system ANSI code page ! 1755: ;com.code_page= ! 1756: ! 1757: [mbstring] ! 1758: ; language for internal character representation. ! 1759: ; http://php.net/mbstring.language ! 1760: ;mbstring.language = Japanese ! 1761: ! 1762: ; internal/script encoding. ! 1763: ; Some encoding cannot work as internal encoding. ! 1764: ; (e.g. SJIS, BIG5, ISO-2022-*) ! 1765: ; http://php.net/mbstring.internal-encoding ! 1766: ;mbstring.internal_encoding = EUC-JP ! 1767: ! 1768: ; http input encoding. ! 1769: ; http://php.net/mbstring.http-input ! 1770: ;mbstring.http_input = auto ! 1771: ! 1772: ; http output encoding. mb_output_handler must be ! 1773: ; registered as output buffer to function ! 1774: ; http://php.net/mbstring.http-output ! 1775: ;mbstring.http_output = SJIS ! 1776: ! 1777: ; enable automatic encoding translation according to ! 1778: ; mbstring.internal_encoding setting. Input chars are ! 1779: ; converted to internal encoding by setting this to On. ! 1780: ; Note: Do _not_ use automatic encoding translation for ! 1781: ; portable libs/applications. ! 1782: ; http://php.net/mbstring.encoding-translation ! 1783: ;mbstring.encoding_translation = Off ! 1784: ! 1785: ; automatic encoding detection order. ! 1786: ; auto means ! 1787: ; http://php.net/mbstring.detect-order ! 1788: ;mbstring.detect_order = auto ! 1789: ! 1790: ; substitute_character used when character cannot be converted ! 1791: ; one from another ! 1792: ; http://php.net/mbstring.substitute-character ! 1793: ;mbstring.substitute_character = none; ! 1794: ! 1795: ; overload(replace) single byte functions by mbstring functions. ! 1796: ; mail(), ereg(), etc are overloaded by mb_send_mail(), mb_ereg(), ! 1797: ; etc. Possible values are 0,1,2,4 or combination of them. ! 1798: ; For example, 7 for overload everything. ! 1799: ; 0: No overload ! 1800: ; 1: Overload mail() function ! 1801: ; 2: Overload str*() functions ! 1802: ; 4: Overload ereg*() functions ! 1803: ; http://php.net/mbstring.func-overload ! 1804: ;mbstring.func_overload = 0 ! 1805: ! 1806: ; enable strict encoding detection. ! 1807: ;mbstring.strict_detection = Off ! 1808: ! 1809: ; This directive specifies the regex pattern of content types for which mb_output_handler() ! 1810: ; is activated. ! 1811: ; Default: mbstring.http_output_conv_mimetype=^(text/|application/xhtml\+xml) ! 1812: ;mbstring.http_output_conv_mimetype= ! 1813: ! 1814: ; Allows to set script encoding. Only affects if PHP is compiled with --enable-zend-multibyte ! 1815: ; Default: "" ! 1816: ;mbstring.script_encoding= ! 1817: ! 1818: [gd] ! 1819: ; Tell the jpeg decode to ignore warnings and try to create ! 1820: ; a gd image. The warning will then be displayed as notices ! 1821: ; disabled by default ! 1822: ; http://php.net/gd.jpeg-ignore-warning ! 1823: ;gd.jpeg_ignore_warning = 0 ! 1824: ! 1825: [exif] ! 1826: ; Exif UNICODE user comments are handled as UCS-2BE/UCS-2LE and JIS as JIS. ! 1827: ; With mbstring support this will automatically be converted into the encoding ! 1828: ; given by corresponding encode setting. When empty mbstring.internal_encoding ! 1829: ; is used. For the decode settings you can distinguish between motorola and ! 1830: ; intel byte order. A decode setting cannot be empty. ! 1831: ; http://php.net/exif.encode-unicode ! 1832: ;exif.encode_unicode = ISO-8859-15 ! 1833: ! 1834: ; http://php.net/exif.decode-unicode-motorola ! 1835: ;exif.decode_unicode_motorola = UCS-2BE ! 1836: ! 1837: ; http://php.net/exif.decode-unicode-intel ! 1838: ;exif.decode_unicode_intel = UCS-2LE ! 1839: ! 1840: ; http://php.net/exif.encode-jis ! 1841: ;exif.encode_jis = ! 1842: ! 1843: ; http://php.net/exif.decode-jis-motorola ! 1844: ;exif.decode_jis_motorola = JIS ! 1845: ! 1846: ; http://php.net/exif.decode-jis-intel ! 1847: ;exif.decode_jis_intel = JIS ! 1848: ! 1849: [Tidy] ! 1850: ; The path to a default tidy configuration file to use when using tidy ! 1851: ; http://php.net/tidy.default-config ! 1852: ;tidy.default_config = /usr/local/lib/php/default.tcfg ! 1853: ! 1854: ; Should tidy clean and repair output automatically? ! 1855: ; WARNING: Do not use this option if you are generating non-html content ! 1856: ; such as dynamic images ! 1857: ; http://php.net/tidy.clean-output ! 1858: tidy.clean_output = Off ! 1859: ! 1860: [soap] ! 1861: ; Enables or disables WSDL caching feature. ! 1862: ; http://php.net/soap.wsdl-cache-enabled ! 1863: soap.wsdl_cache_enabled=1 ! 1864: ! 1865: ; Sets the directory name where SOAP extension will put cache files. ! 1866: ; http://php.net/soap.wsdl-cache-dir ! 1867: soap.wsdl_cache_dir="/tmp" ! 1868: ! 1869: ; (time to live) Sets the number of second while cached file will be used ! 1870: ; instead of original one. ! 1871: ; http://php.net/soap.wsdl-cache-ttl ! 1872: soap.wsdl_cache_ttl=86400 ! 1873: ! 1874: ; Sets the size of the cache limit. (Max. number of WSDL files to cache) ! 1875: soap.wsdl_cache_limit = 5 ! 1876: ! 1877: [sysvshm] ! 1878: ; A default size of the shared memory segment ! 1879: ;sysvshm.init_mem = 10000 ! 1880: ! 1881: [ldap] ! 1882: ; Sets the maximum number of open links or -1 for unlimited. ! 1883: ldap.max_links = -1 ! 1884: ! 1885: [mcrypt] ! 1886: ; For more information about mcrypt settings see http://php.net/mcrypt-module-open ! 1887: ! 1888: ; Directory where to load mcrypt algorithms ! 1889: ; Default: Compiled in into libmcrypt (usually /usr/local/lib/libmcrypt) ! 1890: ;mcrypt.algorithms_dir= ! 1891: ! 1892: ; Directory where to load mcrypt modes ! 1893: ; Default: Compiled in into libmcrypt (usually /usr/local/lib/libmcrypt) ! 1894: ;mcrypt.modes_dir= ! 1895: ! 1896: [dba] ! 1897: ;dba.default_handler= ! 1898: ! 1899: ; Local Variables: ! 1900: ; tab-width: 4 ! 1901: ; End: