elwix/config/etc/default/php.ini-production - view

File: [ELWIX - Embedded LightWeight unIX -] / elwix / config / etc / default / Attic / php.ini-production
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs - revision graph
Tue Jul 5 23:43:00 2011 UTC (13 years ago) by misho
Branches: misho
CVS tags: start, elwix2_3, elwix2_2, elwix2_1, elwix2_0, elwix1_9_mips, elwix1_9, elwix1_8, elwix1_7, elwix1_6, elwix1_5, elwix1_4, Patch1, ELWIX2_2p0, ELWIX2_1, ELWIX2_0, ELWIX1_9, ELWIX1_8, ELWIX1_7, ELWIX1_6, ELWIX1_5

ELWIX project

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_DEPRECATED 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 = Off 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 = Off 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 = Off 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 = Off 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: ; Allow accessing, from PHP's perspective, local files with LOAD DATA statements 1259: ; http://php.net/mysqli.allow_local_infile 1260: ;mysqli.allow_local_infile = On 1261: 1262: ; Allow or prevent persistent links. 1263: ; http://php.net/mysqli.allow-persistent 1264: mysqli.allow_persistent = On 1265: 1266: ; Maximum number of links. -1 means no limit. 1267: ; http://php.net/mysqli.max-links 1268: mysqli.max_links = -1 1269: 1270: ; If mysqlnd is used: Number of cache slots for the internal result set cache 1271: ; http://php.net/mysqli.cache_size 1272: mysqli.cache_size = 2000 1273: 1274: ; Default port number for mysqli_connect(). If unset, mysqli_connect() will use 1275: ; the $MYSQL_TCP_PORT or the mysql-tcp entry in /etc/services or the 1276: ; compile-time value defined MYSQL_PORT (in that order). Win32 will only look 1277: ; at MYSQL_PORT. 1278: ; http://php.net/mysqli.default-port 1279: mysqli.default_port = 3306 1280: 1281: ; Default socket name for local MySQL connects. If empty, uses the built-in 1282: ; MySQL defaults. 1283: ; http://php.net/mysqli.default-socket 1284: mysqli.default_socket = 1285: 1286: ; Default host for mysql_connect() (doesn't apply in safe mode). 1287: ; http://php.net/mysqli.default-host 1288: mysqli.default_host = 1289: 1290: ; Default user for mysql_connect() (doesn't apply in safe mode). 1291: ; http://php.net/mysqli.default-user 1292: mysqli.default_user = 1293: 1294: ; Default password for mysqli_connect() (doesn't apply in safe mode). 1295: ; Note that this is generally a *bad* idea to store passwords in this file. 1296: ; *Any* user with PHP access can run 'echo get_cfg_var("mysqli.default_pw") 1297: ; and reveal this password! And of course, any users with read access to this 1298: ; file will be able to reveal the password as well. 1299: ; http://php.net/mysqli.default-pw 1300: mysqli.default_pw = 1301: 1302: ; Allow or prevent reconnect 1303: mysqli.reconnect = Off 1304: 1305: [mysqlnd] 1306: ; Enable / Disable collection of general statstics by mysqlnd which can be 1307: ; used to tune and monitor MySQL operations. 1308: ; http://php.net/mysqlnd.collect_statistics 1309: mysqlnd.collect_statistics = On 1310: 1311: ; Enable / Disable collection of memory usage statstics by mysqlnd which can be 1312: ; used to tune and monitor MySQL operations. 1313: ; http://php.net/mysqlnd.collect_memory_statistics 1314: mysqlnd.collect_memory_statistics = Off 1315: 1316: ; Size of a pre-allocated buffer used when sending commands to MySQL in bytes. 1317: ; http://php.net/mysqlnd.net_cmd_buffer_size 1318: ;mysqlnd.net_cmd_buffer_size = 2048 1319: 1320: ; Size of a pre-allocated buffer used for reading data sent by the server in 1321: ; bytes. 1322: ; http://php.net/mysqlnd.net_read_buffer_size 1323: ;mysqlnd.net_read_buffer_size = 32768 1324: 1325: [OCI8] 1326: 1327: ; Connection: Enables privileged connections using external 1328: ; credentials (OCI_SYSOPER, OCI_SYSDBA) 1329: ; http://php.net/oci8.privileged-connect 1330: ;oci8.privileged_connect = Off 1331: 1332: ; Connection: The maximum number of persistent OCI8 connections per 1333: ; process. Using -1 means no limit. 1334: ; http://php.net/oci8.max-persistent 1335: ;oci8.max_persistent = -1 1336: 1337: ; Connection: The maximum number of seconds a process is allowed to 1338: ; maintain an idle persistent connection. Using -1 means idle 1339: ; persistent connections will be maintained forever. 1340: ; http://php.net/oci8.persistent-timeout 1341: ;oci8.persistent_timeout = -1 1342: 1343: ; Connection: The number of seconds that must pass before issuing a 1344: ; ping during oci_pconnect() to check the connection validity. When 1345: ; set to 0, each oci_pconnect() will cause a ping. Using -1 disables 1346: ; pings completely. 1347: ; http://php.net/oci8.ping-interval 1348: ;oci8.ping_interval = 60 1349: 1350: ; Connection: Set this to a user chosen connection class to be used 1351: ; for all pooled server requests with Oracle 11g Database Resident 1352: ; Connection Pooling (DRCP). To use DRCP, this value should be set to 1353: ; the same string for all web servers running the same application, 1354: ; the database pool must be configured, and the connection string must 1355: ; specify to use a pooled server. 1356: ;oci8.connection_class = 1357: 1358: ; High Availability: Using On lets PHP receive Fast Application 1359: ; Notification (FAN) events generated when a database node fails. The 1360: ; database must also be configured to post FAN events. 1361: ;oci8.events = Off 1362: 1363: ; Tuning: This option enables statement caching, and specifies how 1364: ; many statements to cache. Using 0 disables statement caching. 1365: ; http://php.net/oci8.statement-cache-size 1366: ;oci8.statement_cache_size = 20 1367: 1368: ; Tuning: Enables statement prefetching and sets the default number of 1369: ; rows that will be fetched automatically after statement execution. 1370: ; http://php.net/oci8.default-prefetch 1371: ;oci8.default_prefetch = 100 1372: 1373: ; Compatibility. Using On means oci_close() will not close 1374: ; oci_connect() and oci_new_connect() connections. 1375: ; http://php.net/oci8.old-oci-close-semantics 1376: ;oci8.old_oci_close_semantics = Off 1377: 1378: [PostgresSQL] 1379: ; Allow or prevent persistent links. 1380: ; http://php.net/pgsql.allow-persistent 1381: pgsql.allow_persistent = On 1382: 1383: ; Detect broken persistent links always with pg_pconnect(). 1384: ; Auto reset feature requires a little overheads. 1385: ; http://php.net/pgsql.auto-reset-persistent 1386: pgsql.auto_reset_persistent = Off 1387: 1388: ; Maximum number of persistent links. -1 means no limit. 1389: ; http://php.net/pgsql.max-persistent 1390: pgsql.max_persistent = -1 1391: 1392: ; Maximum number of links (persistent+non persistent). -1 means no limit. 1393: ; http://php.net/pgsql.max-links 1394: pgsql.max_links = -1 1395: 1396: ; Ignore PostgreSQL backends Notice message or not. 1397: ; Notice message logging require a little overheads. 1398: ; http://php.net/pgsql.ignore-notice 1399: pgsql.ignore_notice = 0 1400: 1401: ; Log PostgreSQL backends Noitce message or not. 1402: ; Unless pgsql.ignore_notice=0, module cannot log notice message. 1403: ; http://php.net/pgsql.log-notice 1404: pgsql.log_notice = 0 1405: 1406: [Sybase-CT] 1407: ; Allow or prevent persistent links. 1408: ; http://php.net/sybct.allow-persistent 1409: sybct.allow_persistent = On 1410: 1411: ; Maximum number of persistent links. -1 means no limit. 1412: ; http://php.net/sybct.max-persistent 1413: sybct.max_persistent = -1 1414: 1415: ; Maximum number of links (persistent + non-persistent). -1 means no limit. 1416: ; http://php.net/sybct.max-links 1417: sybct.max_links = -1 1418: 1419: ; Minimum server message severity to display. 1420: ; http://php.net/sybct.min-server-severity 1421: sybct.min_server_severity = 10 1422: 1423: ; Minimum client message severity to display. 1424: ; http://php.net/sybct.min-client-severity 1425: sybct.min_client_severity = 10 1426: 1427: ; Set per-context timeout 1428: ; http://php.net/sybct.timeout 1429: ;sybct.timeout= 1430: 1431: ;sybct.packet_size 1432: 1433: ; The maximum time in seconds to wait for a connection attempt to succeed before returning failure. 1434: ; Default: one minute 1435: ;sybct.login_timeout= 1436: 1437: ; The name of the host you claim to be connecting from, for display by sp_who. 1438: ; Default: none 1439: ;sybct.hostname= 1440: 1441: ; Allows you to define how often deadlocks are to be retried. -1 means "forever". 1442: ; Default: 0 1443: ;sybct.deadlock_retry_count= 1444: 1445: [bcmath] 1446: ; Number of decimal digits for all bcmath functions. 1447: ; http://php.net/bcmath.scale 1448: bcmath.scale = 0 1449: 1450: [browscap] 1451: ; http://php.net/browscap 1452: ;browscap = extra/browscap.ini 1453: 1454: [Session] 1455: ; Handler used to store/retrieve data. 1456: ; http://php.net/session.save-handler 1457: session.save_handler = files 1458: 1459: ; Argument passed to save_handler. In the case of files, this is the path 1460: ; where data files are stored. Note: Windows users have to change this 1461: ; variable in order to use PHP's session functions. 1462: ; 1463: ; The path can be defined as: 1464: ; 1465: ; session.save_path = "N;/path" 1466: ; 1467: ; where N is an integer. Instead of storing all the session files in 1468: ; /path, what this will do is use subdirectories N-levels deep, and 1469: ; store the session data in those directories. This is useful if you 1470: ; or your OS have problems with lots of files in one directory, and is 1471: ; a more efficient layout for servers that handle lots of sessions. 1472: ; 1473: ; NOTE 1: PHP will not create this directory structure automatically. 1474: ; You can use the script in the ext/session dir for that purpose. 1475: ; NOTE 2: See the section on garbage collection below if you choose to 1476: ; use subdirectories for session storage 1477: ; 1478: ; The file storage module creates files using mode 600 by default. 1479: ; You can change that by using 1480: ; 1481: ; session.save_path = "N;MODE;/path" 1482: ; 1483: ; where MODE is the octal representation of the mode. Note that this 1484: ; does not overwrite the process's umask. 1485: ; http://php.net/session.save-path 1486: ;session.save_path = "/tmp" 1487: 1488: ; Whether to use cookies. 1489: ; http://php.net/session.use-cookies 1490: session.use_cookies = 1 1491: 1492: ; http://php.net/session.cookie-secure 1493: ;session.cookie_secure = 1494: 1495: ; This option forces PHP to fetch and use a cookie for storing and maintaining 1496: ; the session id. We encourage this operation as it's very helpful in combatting 1497: ; session hijacking when not specifying and managing your own session id. It is 1498: ; not the end all be all of session hijacking defense, but it's a good start. 1499: ; http://php.net/session.use-only-cookies 1500: session.use_only_cookies = 1 1501: 1502: ; Name of the session (used as cookie name). 1503: ; http://php.net/session.name 1504: session.name = PHPSESSID 1505: 1506: ; Initialize session on request startup. 1507: ; http://php.net/session.auto-start 1508: session.auto_start = 0 1509: 1510: ; Lifetime in seconds of cookie or, if 0, until browser is restarted. 1511: ; http://php.net/session.cookie-lifetime 1512: session.cookie_lifetime = 0 1513: 1514: ; The path for which the cookie is valid. 1515: ; http://php.net/session.cookie-path 1516: session.cookie_path = / 1517: 1518: ; The domain for which the cookie is valid. 1519: ; http://php.net/session.cookie-domain 1520: session.cookie_domain = 1521: 1522: ; Whether or not to add the httpOnly flag to the cookie, which makes it inaccessible to browser scripting languages such as JavaScript. 1523: ; http://php.net/session.cookie-httponly 1524: session.cookie_httponly = 1525: 1526: ; Handler used to serialize data. php is the standard serializer of PHP. 1527: ; http://php.net/session.serialize-handler 1528: session.serialize_handler = php 1529: 1530: ; Defines the probability that the 'garbage collection' process is started 1531: ; on every session initialization. The probability is calculated by using 1532: ; gc_probability/gc_divisor. Where session.gc_probability is the numerator 1533: ; and gc_divisor is the denominator in the equation. Setting this value to 1 1534: ; when the session.gc_divisor value is 100 will give you approximately a 1% chance 1535: ; the gc will run on any give request. 1536: ; Default Value: 1 1537: ; Development Value: 1 1538: ; Production Value: 1 1539: ; http://php.net/session.gc-probability 1540: session.gc_probability = 1 1541: 1542: ; Defines the probability that the 'garbage collection' process is started on every 1543: ; session initialization. The probability is calculated by using the following equation: 1544: ; gc_probability/gc_divisor. Where session.gc_probability is the numerator and 1545: ; session.gc_divisor is the denominator in the equation. Setting this value to 1 1546: ; when the session.gc_divisor value is 100 will give you approximately a 1% chance 1547: ; the gc will run on any give request. Increasing this value to 1000 will give you 1548: ; a 0.1% chance the gc will run on any give request. For high volume production servers, 1549: ; this is a more efficient approach. 1550: ; Default Value: 100 1551: ; Development Value: 1000 1552: ; Production Value: 1000 1553: ; http://php.net/session.gc-divisor 1554: session.gc_divisor = 1000 1555: 1556: ; After this number of seconds, stored data will be seen as 'garbage' and 1557: ; cleaned up by the garbage collection process. 1558: ; http://php.net/session.gc-maxlifetime 1559: session.gc_maxlifetime = 1440 1560: 1561: ; NOTE: If you are using the subdirectory option for storing session files 1562: ; (see session.save_path above), then garbage collection does *not* 1563: ; happen automatically. You will need to do your own garbage 1564: ; collection through a shell script, cron entry, or some other method. 1565: ; For example, the following script would is the equivalent of 1566: ; setting session.gc_maxlifetime to 1440 (1440 seconds = 24 minutes): 1567: ; cd /path/to/sessions; find -cmin +24 | xargs rm 1568: 1569: ; PHP 4.2 and less have an undocumented feature/bug that allows you to 1570: ; to initialize a session variable in the global scope, even when register_globals 1571: ; is disabled. PHP 4.3 and later will warn you, if this feature is used. 1572: ; You can disable the feature and the warning separately. At this time, 1573: ; the warning is only displayed, if bug_compat_42 is enabled. This feature 1574: ; introduces some serious security problems if not handled correctly. It's 1575: ; recommended that you do not use this feature on production servers. But you 1576: ; should enable this on development servers and enable the warning as well. If you 1577: ; do not enable the feature on development servers, you won't be warned when it's 1578: ; used and debugging errors caused by this can be difficult to track down. 1579: ; Default Value: On 1580: ; Development Value: On 1581: ; Production Value: Off 1582: ; http://php.net/session.bug-compat-42 1583: session.bug_compat_42 = Off 1584: 1585: ; This setting controls whether or not you are warned by PHP when initializing a 1586: ; session value into the global space. session.bug_compat_42 must be enabled before 1587: ; these warnings can be issued by PHP. See the directive above for more information. 1588: ; Default Value: On 1589: ; Development Value: On 1590: ; Production Value: Off 1591: ; http://php.net/session.bug-compat-warn 1592: session.bug_compat_warn = Off 1593: 1594: ; Check HTTP Referer to invalidate externally stored URLs containing ids. 1595: ; HTTP_REFERER has to contain this substring for the session to be 1596: ; considered as valid. 1597: ; http://php.net/session.referer-check 1598: session.referer_check = 1599: 1600: ; How many bytes to read from the file. 1601: ; http://php.net/session.entropy-length 1602: session.entropy_length = 0 1603: 1604: ; Specified here to create the session id. 1605: ; http://php.net/session.entropy-file 1606: ;session.entropy_file = /dev/urandom 1607: session.entropy_file = 1608: 1609: ; http://php.net/session.entropy-length 1610: ;session.entropy_length = 16 1611: 1612: ; Set to {nocache,private,public,} to determine HTTP caching aspects 1613: ; or leave this empty to avoid sending anti-caching headers. 1614: ; http://php.net/session.cache-limiter 1615: session.cache_limiter = nocache 1616: 1617: ; Document expires after n minutes. 1618: ; http://php.net/session.cache-expire 1619: session.cache_expire = 180 1620: 1621: ; trans sid support is disabled by default. 1622: ; Use of trans sid may risk your users security. 1623: ; Use this option with caution. 1624: ; - User may send URL contains active session ID 1625: ; to other person via. email/irc/etc. 1626: ; - URL that contains active session ID may be stored 1627: ; in publically accessible computer. 1628: ; - User may access your site with the same session ID 1629: ; always using URL stored in browser's history or bookmarks. 1630: ; http://php.net/session.use-trans-sid 1631: session.use_trans_sid = 0 1632: 1633: ; Select a hash function for use in generating session ids. 1634: ; Possible Values 1635: ; 0 (MD5 128 bits) 1636: ; 1 (SHA-1 160 bits) 1637: ; This option may also be set to the name of any hash function supported by 1638: ; the hash extension. A list of available hashes is returned by the hash_alogs() 1639: ; function. 1640: ; http://php.net/session.hash-function 1641: session.hash_function = 0 1642: 1643: ; Define how many bits are stored in each character when converting 1644: ; the binary hash data to something readable. 1645: ; Possible values: 1646: ; 4 (4 bits: 0-9, a-f) 1647: ; 5 (5 bits: 0-9, a-v) 1648: ; 6 (6 bits: 0-9, a-z, A-Z, "-", ",") 1649: ; Default Value: 4 1650: ; Development Value: 5 1651: ; Production Value: 5 1652: ; http://php.net/session.hash-bits-per-character 1653: session.hash_bits_per_character = 5 1654: 1655: ; The URL rewriter will look for URLs in a defined set of HTML tags. 1656: ; form/fieldset are special; if you include them here, the rewriter will 1657: ; add a hidden <input> field with the info which is otherwise appended 1658: ; to URLs. If you want XHTML conformity, remove the form entry. 1659: ; Note that all valid entries require a "=", even if no value follows. 1660: ; Default Value: "a=href,area=href,frame=src,form=,fieldset=" 1661: ; Development Value: "a=href,area=href,frame=src,input=src,form=fakeentry" 1662: ; Production Value: "a=href,area=href,frame=src,input=src,form=fakeentry" 1663: ; http://php.net/url-rewriter.tags 1664: url_rewriter.tags = "a=href,area=href,frame=src,input=src,form=fakeentry" 1665: 1666: [MSSQL] 1667: ; Allow or prevent persistent links. 1668: mssql.allow_persistent = On 1669: 1670: ; Maximum number of persistent links. -1 means no limit. 1671: mssql.max_persistent = -1 1672: 1673: ; Maximum number of links (persistent+non persistent). -1 means no limit. 1674: mssql.max_links = -1 1675: 1676: ; Minimum error severity to display. 1677: mssql.min_error_severity = 10 1678: 1679: ; Minimum message severity to display. 1680: mssql.min_message_severity = 10 1681: 1682: ; Compatibility mode with old versions of PHP 3.0. 1683: mssql.compatability_mode = Off 1684: 1685: ; Connect timeout 1686: ;mssql.connect_timeout = 5 1687: 1688: ; Query timeout 1689: ;mssql.timeout = 60 1690: 1691: ; Valid range 0 - 2147483647. Default = 4096. 1692: ;mssql.textlimit = 4096 1693: 1694: ; Valid range 0 - 2147483647. Default = 4096. 1695: ;mssql.textsize = 4096 1696: 1697: ; Limits the number of records in each batch. 0 = all records in one batch. 1698: ;mssql.batchsize = 0 1699: 1700: ; Specify how datetime and datetim4 columns are returned 1701: ; On => Returns data converted to SQL server settings 1702: ; Off => Returns values as YYYY-MM-DD hh:mm:ss 1703: ;mssql.datetimeconvert = On 1704: 1705: ; Use NT authentication when connecting to the server 1706: mssql.secure_connection = Off 1707: 1708: ; Specify max number of processes. -1 = library default 1709: ; msdlib defaults to 25 1710: ; FreeTDS defaults to 4096 1711: ;mssql.max_procs = -1 1712: 1713: ; Specify client character set. 1714: ; If empty or not set the client charset from freetds.comf is used 1715: ; This is only used when compiled with FreeTDS 1716: ;mssql.charset = "ISO-8859-1" 1717: 1718: [Assertion] 1719: ; Assert(expr); active by default. 1720: ; http://php.net/assert.active 1721: ;assert.active = On 1722: 1723: ; Issue a PHP warning for each failed assertion. 1724: ; http://php.net/assert.warning 1725: ;assert.warning = On 1726: 1727: ; Don't bail out by default. 1728: ; http://php.net/assert.bail 1729: ;assert.bail = Off 1730: 1731: ; User-function to be called if an assertion fails. 1732: ; http://php.net/assert.callback 1733: ;assert.callback = 0 1734: 1735: ; Eval the expression with current error_reporting(). Set to true if you want 1736: ; error_reporting(0) around the eval(). 1737: ; http://php.net/assert.quiet-eval 1738: ;assert.quiet_eval = 0 1739: 1740: [COM] 1741: ; path to a file containing GUIDs, IIDs or filenames of files with TypeLibs 1742: ; http://php.net/com.typelib-file 1743: ;com.typelib_file = 1744: 1745: ; allow Distributed-COM calls 1746: ; http://php.net/com.allow-dcom 1747: ;com.allow_dcom = true 1748: 1749: ; autoregister constants of a components typlib on com_load() 1750: ; http://php.net/com.autoregister-typelib 1751: ;com.autoregister_typelib = true 1752: 1753: ; register constants casesensitive 1754: ; http://php.net/com.autoregister-casesensitive 1755: ;com.autoregister_casesensitive = false 1756: 1757: ; show warnings on duplicate constant registrations 1758: ; http://php.net/com.autoregister-verbose 1759: ;com.autoregister_verbose = true 1760: 1761: ; The default character set code-page to use when passing strings to and from COM objects. 1762: ; Default: system ANSI code page 1763: ;com.code_page= 1764: 1765: [mbstring] 1766: ; language for internal character representation. 1767: ; http://php.net/mbstring.language 1768: ;mbstring.language = Japanese 1769: 1770: ; internal/script encoding. 1771: ; Some encoding cannot work as internal encoding. 1772: ; (e.g. SJIS, BIG5, ISO-2022-*) 1773: ; http://php.net/mbstring.internal-encoding 1774: ;mbstring.internal_encoding = EUC-JP 1775: 1776: ; http input encoding. 1777: ; http://php.net/mbstring.http-input 1778: ;mbstring.http_input = auto 1779: 1780: ; http output encoding. mb_output_handler must be 1781: ; registered as output buffer to function 1782: ; http://php.net/mbstring.http-output 1783: ;mbstring.http_output = SJIS 1784: 1785: ; enable automatic encoding translation according to 1786: ; mbstring.internal_encoding setting. Input chars are 1787: ; converted to internal encoding by setting this to On. 1788: ; Note: Do _not_ use automatic encoding translation for 1789: ; portable libs/applications. 1790: ; http://php.net/mbstring.encoding-translation 1791: ;mbstring.encoding_translation = Off 1792: 1793: ; automatic encoding detection order. 1794: ; auto means 1795: ; http://php.net/mbstring.detect-order 1796: ;mbstring.detect_order = auto 1797: 1798: ; substitute_character used when character cannot be converted 1799: ; one from another 1800: ; http://php.net/mbstring.substitute-character 1801: ;mbstring.substitute_character = none; 1802: 1803: ; overload(replace) single byte functions by mbstring functions. 1804: ; mail(), ereg(), etc are overloaded by mb_send_mail(), mb_ereg(), 1805: ; etc. Possible values are 0,1,2,4 or combination of them. 1806: ; For example, 7 for overload everything. 1807: ; 0: No overload 1808: ; 1: Overload mail() function 1809: ; 2: Overload str*() functions 1810: ; 4: Overload ereg*() functions 1811: ; http://php.net/mbstring.func-overload 1812: ;mbstring.func_overload = 0 1813: 1814: ; enable strict encoding detection. 1815: ;mbstring.strict_detection = Off 1816: 1817: ; This directive specifies the regex pattern of content types for which mb_output_handler() 1818: ; is activated. 1819: ; Default: mbstring.http_output_conv_mimetype=^(text/|application/xhtml\+xml) 1820: ;mbstring.http_output_conv_mimetype= 1821: 1822: ; Allows to set script encoding. Only affects if PHP is compiled with --enable-zend-multibyte 1823: ; Default: "" 1824: ;mbstring.script_encoding= 1825: 1826: [gd] 1827: ; Tell the jpeg decode to ignore warnings and try to create 1828: ; a gd image. The warning will then be displayed as notices 1829: ; disabled by default 1830: ; http://php.net/gd.jpeg-ignore-warning 1831: ;gd.jpeg_ignore_warning = 0 1832: 1833: [exif] 1834: ; Exif UNICODE user comments are handled as UCS-2BE/UCS-2LE and JIS as JIS. 1835: ; With mbstring support this will automatically be converted into the encoding 1836: ; given by corresponding encode setting. When empty mbstring.internal_encoding 1837: ; is used. For the decode settings you can distinguish between motorola and 1838: ; intel byte order. A decode setting cannot be empty. 1839: ; http://php.net/exif.encode-unicode 1840: ;exif.encode_unicode = ISO-8859-15 1841: 1842: ; http://php.net/exif.decode-unicode-motorola 1843: ;exif.decode_unicode_motorola = UCS-2BE 1844: 1845: ; http://php.net/exif.decode-unicode-intel 1846: ;exif.decode_unicode_intel = UCS-2LE 1847: 1848: ; http://php.net/exif.encode-jis 1849: ;exif.encode_jis = 1850: 1851: ; http://php.net/exif.decode-jis-motorola 1852: ;exif.decode_jis_motorola = JIS 1853: 1854: ; http://php.net/exif.decode-jis-intel 1855: ;exif.decode_jis_intel = JIS 1856: 1857: [Tidy] 1858: ; The path to a default tidy configuration file to use when using tidy 1859: ; http://php.net/tidy.default-config 1860: ;tidy.default_config = /usr/local/lib/php/default.tcfg 1861: 1862: ; Should tidy clean and repair output automatically? 1863: ; WARNING: Do not use this option if you are generating non-html content 1864: ; such as dynamic images 1865: ; http://php.net/tidy.clean-output 1866: tidy.clean_output = Off 1867: 1868: [soap] 1869: ; Enables or disables WSDL caching feature. 1870: ; http://php.net/soap.wsdl-cache-enabled 1871: soap.wsdl_cache_enabled=1 1872: 1873: ; Sets the directory name where SOAP extension will put cache files. 1874: ; http://php.net/soap.wsdl-cache-dir 1875: soap.wsdl_cache_dir="/tmp" 1876: 1877: ; (time to live) Sets the number of second while cached file will be used 1878: ; instead of original one. 1879: ; http://php.net/soap.wsdl-cache-ttl 1880: soap.wsdl_cache_ttl=86400 1881: 1882: ; Sets the size of the cache limit. (Max. number of WSDL files to cache) 1883: soap.wsdl_cache_limit = 5 1884: 1885: [sysvshm] 1886: ; A default size of the shared memory segment 1887: ;sysvshm.init_mem = 10000 1888: 1889: [ldap] 1890: ; Sets the maximum number of open links or -1 for unlimited. 1891: ldap.max_links = -1 1892: 1893: [mcrypt] 1894: ; For more information about mcrypt settings see http://php.net/mcrypt-module-open 1895: 1896: ; Directory where to load mcrypt algorithms 1897: ; Default: Compiled in into libmcrypt (usually /usr/local/lib/libmcrypt) 1898: ;mcrypt.algorithms_dir= 1899: 1900: ; Directory where to load mcrypt modes 1901: ; Default: Compiled in into libmcrypt (usually /usr/local/lib/libmcrypt) 1902: ;mcrypt.modes_dir= 1903: 1904: [dba] 1905: ;dba.default_handler= 1906: 1907: ; Local Variables: 1908: ; tab-width: 4 1909: ; End: