embedaddon/php/php.ini-production - view

File: [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / php.ini-production
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs - revision graph
Tue Feb 21 23:47:52 2012 UTC (12 years, 4 months ago) by misho
Branches: php, MAIN
CVS tags: v5_3_10, HEAD

php

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 = 17 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: ; Enables or disables the circular reference collector. 432: ; http://php.net/zend.enable-gc 433: zend.enable_gc = On 434: 435: ;;;;;;;;;;;;;;;;; 436: ; Miscellaneous ; 437: ;;;;;;;;;;;;;;;;; 438: 439: ; Decides whether PHP may expose the fact that it is installed on the server 440: ; (e.g. by adding its signature to the Web server header). It is no security 441: ; threat in any way, but it makes it possible to determine whether you use PHP 442: ; on your server or not. 443: ; http://php.net/expose-php 444: expose_php = On 445: 446: ;;;;;;;;;;;;;;;;;;; 447: ; Resource Limits ; 448: ;;;;;;;;;;;;;;;;;;; 449: 450: ; Maximum execution time of each script, in seconds 451: ; http://php.net/max-execution-time 452: ; Note: This directive is hardcoded to 0 for the CLI SAPI 453: max_execution_time = 30 454: 455: ; Maximum amount of time each script may spend parsing request data. It's a good 456: ; idea to limit this time on productions servers in order to eliminate unexpectedly 457: ; long running scripts. 458: ; Note: This directive is hardcoded to -1 for the CLI SAPI 459: ; Default Value: -1 (Unlimited) 460: ; Development Value: 60 (60 seconds) 461: ; Production Value: 60 (60 seconds) 462: ; http://php.net/max-input-time 463: max_input_time = 60 464: 465: ; Maximum input variable nesting level 466: ; http://php.net/max-input-nesting-level 467: ;max_input_nesting_level = 64 468: 469: ; How many GET/POST/COOKIE input variables may be accepted 470: ; max_input_vars = 1000 471: 472: ; Maximum amount of memory a script may consume (128MB) 473: ; http://php.net/memory-limit 474: memory_limit = 128M 475: 476: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 477: ; Error handling and logging ; 478: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 479: 480: ; This directive informs PHP of which errors, warnings and notices you would like 481: ; it to take action for. The recommended way of setting values for this 482: ; directive is through the use of the error level constants and bitwise 483: ; operators. The error level constants are below here for convenience as well as 484: ; some common settings and their meanings. 485: ; By default, PHP is set to take action on all errors, notices and warnings EXCEPT 486: ; those related to E_NOTICE and E_STRICT, which together cover best practices and 487: ; recommended coding standards in PHP. For performance reasons, this is the 488: ; recommend error reporting setting. Your production server shouldn't be wasting 489: ; resources complaining about best practices and coding standards. That's what 490: ; development servers and development settings are for. 491: ; Note: The php.ini-development file has this setting as E_ALL | E_STRICT. This 492: ; means it pretty much reports everything which is exactly what you want during 493: ; development and early testing. 494: ; 495: ; Error Level Constants: 496: ; E_ALL - All errors and warnings (includes E_STRICT as of PHP 6.0.0) 497: ; E_ERROR - fatal run-time errors 498: ; E_RECOVERABLE_ERROR - almost fatal run-time errors 499: ; E_WARNING - run-time warnings (non-fatal errors) 500: ; E_PARSE - compile-time parse errors 501: ; E_NOTICE - run-time notices (these are warnings which often result 502: ; from a bug in your code, but it's possible that it was 503: ; intentional (e.g., using an uninitialized variable and 504: ; relying on the fact it's automatically initialized to an 505: ; empty string) 506: ; E_STRICT - run-time notices, enable to have PHP suggest changes 507: ; to your code which will ensure the best interoperability 508: ; and forward compatibility of your code 509: ; E_CORE_ERROR - fatal errors that occur during PHP's initial startup 510: ; E_CORE_WARNING - warnings (non-fatal errors) that occur during PHP's 511: ; initial startup 512: ; E_COMPILE_ERROR - fatal compile-time errors 513: ; E_COMPILE_WARNING - compile-time warnings (non-fatal errors) 514: ; E_USER_ERROR - user-generated error message 515: ; E_USER_WARNING - user-generated warning message 516: ; E_USER_NOTICE - user-generated notice message 517: ; E_DEPRECATED - warn about code that will not work in future versions 518: ; of PHP 519: ; E_USER_DEPRECATED - user-generated deprecation warnings 520: ; 521: ; Common Values: 522: ; E_ALL & ~E_NOTICE (Show all errors, except for notices and coding standards warnings.) 523: ; E_ALL & ~E_NOTICE | E_STRICT (Show all errors, except for notices) 524: ; E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR (Show only errors) 525: ; E_ALL | E_STRICT (Show all errors, warnings and notices including coding standards.) 526: ; Default Value: E_ALL & ~E_NOTICE 527: ; Development Value: E_ALL | E_STRICT 528: ; Production Value: E_ALL & ~E_DEPRECATED 529: ; http://php.net/error-reporting 530: error_reporting = E_ALL & ~E_DEPRECATED 531: 532: ; This directive controls whether or not and where PHP will output errors, 533: ; notices and warnings too. Error output is very useful during development, but 534: ; it could be very dangerous in production environments. Depending on the code 535: ; which is triggering the error, sensitive information could potentially leak 536: ; out of your application such as database usernames and passwords or worse. 537: ; It's recommended that errors be logged on production servers rather than 538: ; having the errors sent to STDOUT. 539: ; Possible Values: 540: ; Off = Do not display any errors 541: ; stderr = Display errors to STDERR (affects only CGI/CLI binaries!) 542: ; On or stdout = Display errors to STDOUT 543: ; Default Value: On 544: ; Development Value: On 545: ; Production Value: Off 546: ; http://php.net/display-errors 547: display_errors = Off 548: 549: ; The display of errors which occur during PHP's startup sequence are handled 550: ; separately from display_errors. PHP's default behavior is to suppress those 551: ; errors from clients. Turning the display of startup errors on can be useful in 552: ; debugging configuration problems. But, it's strongly recommended that you 553: ; leave this setting off on production servers. 554: ; Default Value: Off 555: ; Development Value: On 556: ; Production Value: Off 557: ; http://php.net/display-startup-errors 558: display_startup_errors = Off 559: 560: ; Besides displaying errors, PHP can also log errors to locations such as a 561: ; server-specific log, STDERR, or a location specified by the error_log 562: ; directive found below. While errors should not be displayed on productions 563: ; servers they should still be monitored and logging is a great way to do that. 564: ; Default Value: Off 565: ; Development Value: On 566: ; Production Value: On 567: ; http://php.net/log-errors 568: log_errors = On 569: 570: ; Set maximum length of log_errors. In error_log information about the source is 571: ; added. The default is 1024 and 0 allows to not apply any maximum length at all. 572: ; http://php.net/log-errors-max-len 573: log_errors_max_len = 1024 574: 575: ; Do not log repeated messages. Repeated errors must occur in same file on same 576: ; line unless ignore_repeated_source is set true. 577: ; http://php.net/ignore-repeated-errors 578: ignore_repeated_errors = Off 579: 580: ; Ignore source of message when ignoring repeated messages. When this setting 581: ; is On you will not log errors with repeated messages from different files or 582: ; source lines. 583: ; http://php.net/ignore-repeated-source 584: ignore_repeated_source = Off 585: 586: ; If this parameter is set to Off, then memory leaks will not be shown (on 587: ; stdout or in the log). This has only effect in a debug compile, and if 588: ; error reporting includes E_WARNING in the allowed list 589: ; http://php.net/report-memleaks 590: report_memleaks = On 591: 592: ; This setting is on by default. 593: ;report_zend_debug = 0 594: 595: ; Store the last error/warning message in $php_errormsg (boolean). Setting this value 596: ; to On can assist in debugging and is appropriate for development servers. It should 597: ; however be disabled on production servers. 598: ; Default Value: Off 599: ; Development Value: On 600: ; Production Value: Off 601: ; http://php.net/track-errors 602: track_errors = Off 603: 604: ; Turn off normal error reporting and emit XML-RPC error XML 605: ; http://php.net/xmlrpc-errors 606: ;xmlrpc_errors = 0 607: 608: ; An XML-RPC faultCode 609: ;xmlrpc_error_number = 0 610: 611: ; When PHP displays or logs an error, it has the capability of inserting html 612: ; links to documentation related to that error. This directive controls whether 613: ; those HTML links appear in error messages or not. For performance and security 614: ; reasons, it's recommended you disable this on production servers. 615: ; Note: This directive is hardcoded to Off for the CLI SAPI 616: ; Default Value: On 617: ; Development Value: On 618: ; Production value: Off 619: ; http://php.net/html-errors 620: html_errors = Off 621: 622: ; If html_errors is set On PHP produces clickable error messages that direct 623: ; to a page describing the error or function causing the error in detail. 624: ; You can download a copy of the PHP manual from http://php.net/docs 625: ; and change docref_root to the base URL of your local copy including the 626: ; leading '/'. You must also specify the file extension being used including 627: ; the dot. PHP's default behavior is to leave these settings empty. 628: ; Note: Never use this feature for production boxes. 629: ; http://php.net/docref-root 630: ; Examples 631: ;docref_root = "/phpmanual/" 632: 633: ; http://php.net/docref-ext 634: ;docref_ext = .html 635: 636: ; String to output before an error message. PHP's default behavior is to leave 637: ; this setting blank. 638: ; http://php.net/error-prepend-string 639: ; Example: 640: ;error_prepend_string = "<span style='color: #ff0000'>" 641: 642: ; String to output after an error message. PHP's default behavior is to leave 643: ; this setting blank. 644: ; http://php.net/error-append-string 645: ; Example: 646: ;error_append_string = "</span>" 647: 648: ; Log errors to specified file. PHP's default behavior is to leave this value 649: ; empty. 650: ; http://php.net/error-log 651: ; Example: 652: ;error_log = php_errors.log 653: ; Log errors to syslog (Event Log on NT, not valid in Windows 95). 654: ;error_log = syslog 655: 656: ;windows.show_crt_warning 657: ; Default value: 0 658: ; Development value: 0 659: ; Production value: 0 660: 661: ;;;;;;;;;;;;;;;;; 662: ; Data Handling ; 663: ;;;;;;;;;;;;;;;;; 664: 665: ; The separator used in PHP generated URLs to separate arguments. 666: ; PHP's default setting is "&". 667: ; http://php.net/arg-separator.output 668: ; Example: 669: ;arg_separator.output = "&" 670: 671: ; List of separator(s) used by PHP to parse input URLs into variables. 672: ; PHP's default setting is "&". 673: ; NOTE: Every character in this directive is considered as separator! 674: ; http://php.net/arg-separator.input 675: ; Example: 676: ;arg_separator.input = ";&" 677: 678: ; This directive determines which super global arrays are registered when PHP 679: ; starts up. If the register_globals directive is enabled, it also determines 680: ; what order variables are populated into the global space. G,P,C,E & S are 681: ; abbreviations for the following respective super globals: GET, POST, COOKIE, 682: ; ENV and SERVER. There is a performance penalty paid for the registration of 683: ; these arrays and because ENV is not as commonly used as the others, ENV is 684: ; is not recommended on productions servers. You can still get access to 685: ; the environment variables through getenv() should you need to. 686: ; Default Value: "EGPCS" 687: ; Development Value: "GPCS" 688: ; Production Value: "GPCS"; 689: ; http://php.net/variables-order 690: variables_order = "GPCS" 691: 692: ; This directive determines which super global data (G,P,C,E & S) should 693: ; be registered into the super global array REQUEST. If so, it also determines 694: ; the order in which that data is registered. The values for this directive are 695: ; specified in the same manner as the variables_order directive, EXCEPT one. 696: ; Leaving this value empty will cause PHP to use the value set in the 697: ; variables_order directive. It does not mean it will leave the super globals 698: ; array REQUEST empty. 699: ; Default Value: None 700: ; Development Value: "GP" 701: ; Production Value: "GP" 702: ; http://php.net/request-order 703: request_order = "GP" 704: 705: ; Whether or not to register the EGPCS variables as global variables. You may 706: ; want to turn this off if you don't want to clutter your scripts' global scope 707: ; with user data. 708: ; You should do your best to write your scripts so that they do not require 709: ; register_globals to be on; Using form variables as globals can easily lead 710: ; to possible security problems, if the code is not very well thought of. 711: ; http://php.net/register-globals 712: register_globals = Off 713: 714: ; Determines whether the deprecated long $HTTP_*_VARS type predefined variables 715: ; are registered by PHP or not. As they are deprecated, we obviously don't 716: ; recommend you use them. They are on by default for compatibility reasons but 717: ; they are not recommended on production servers. 718: ; Default Value: On 719: ; Development Value: Off 720: ; Production Value: Off 721: ; http://php.net/register-long-arrays 722: register_long_arrays = Off 723: 724: ; This directive determines whether PHP registers $argv & $argc each time it 725: ; runs. $argv contains an array of all the arguments passed to PHP when a script 726: ; is invoked. $argc contains an integer representing the number of arguments 727: ; that were passed when the script was invoked. These arrays are extremely 728: ; useful when running scripts from the command line. When this directive is 729: ; enabled, registering these variables consumes CPU cycles and memory each time 730: ; a script is executed. For performance reasons, this feature should be disabled 731: ; on production servers. 732: ; Note: This directive is hardcoded to On for the CLI SAPI 733: ; Default Value: On 734: ; Development Value: Off 735: ; Production Value: Off 736: ; http://php.net/register-argc-argv 737: register_argc_argv = Off 738: 739: ; When enabled, the SERVER and ENV variables are created when they're first 740: ; used (Just In Time) instead of when the script starts. If these variables 741: ; are not used within a script, having this directive on will result in a 742: ; performance gain. The PHP directives register_globals, register_long_arrays, 743: ; and register_argc_argv must be disabled for this directive to have any affect. 744: ; http://php.net/auto-globals-jit 745: auto_globals_jit = On 746: 747: ; Maximum size of POST data that PHP will accept. 748: ; http://php.net/post-max-size 749: post_max_size = 8M 750: 751: ; Magic quotes are a preprocessing feature of PHP where PHP will attempt to 752: ; escape any character sequences in GET, POST, COOKIE and ENV data which might 753: ; otherwise corrupt data being placed in resources such as databases before 754: ; making that data available to you. Because of character encoding issues and 755: ; non-standard SQL implementations across many databases, it's not currently 756: ; possible for this feature to be 100% accurate. PHP's default behavior is to 757: ; enable the feature. We strongly recommend you use the escaping mechanisms 758: ; designed specifically for the database your using instead of relying on this 759: ; feature. Also note, this feature has been deprecated as of PHP 5.3.0 and is 760: ; scheduled for removal in PHP 6. 761: ; Default Value: On 762: ; Development Value: Off 763: ; Production Value: Off 764: ; http://php.net/magic-quotes-gpc 765: magic_quotes_gpc = Off 766: 767: ; Magic quotes for runtime-generated data, e.g. data from SQL, from exec(), etc. 768: ; http://php.net/magic-quotes-runtime 769: magic_quotes_runtime = Off 770: 771: ; Use Sybase-style magic quotes (escape ' with '' instead of \'). 772: ; http://php.net/magic-quotes-sybase 773: magic_quotes_sybase = Off 774: 775: ; Automatically add files before PHP document. 776: ; http://php.net/auto-prepend-file 777: auto_prepend_file = 778: 779: ; Automatically add files after PHP document. 780: ; http://php.net/auto-append-file 781: auto_append_file = 782: 783: ; By default, PHP will output a character encoding using 784: ; the Content-type: header. To disable sending of the charset, simply 785: ; set it to be empty. 786: ; 787: ; PHP's built-in default is text/html 788: ; http://php.net/default-mimetype 789: default_mimetype = "text/html" 790: 791: ; PHP's default character set is set to empty. 792: ; http://php.net/default-charset 793: ;default_charset = "iso-8859-1" 794: 795: ; Always populate the $HTTP_RAW_POST_DATA variable. PHP's default behavior is 796: ; to disable this feature. 797: ; http://php.net/always-populate-raw-post-data 798: ;always_populate_raw_post_data = On 799: 800: ;;;;;;;;;;;;;;;;;;;;;;;;; 801: ; Paths and Directories ; 802: ;;;;;;;;;;;;;;;;;;;;;;;;; 803: 804: ; UNIX: "/path1:/path2" 805: ;include_path = ".:/php/includes" 806: ; 807: ; Windows: "\path1;\path2" 808: ;include_path = ".;c:\php\includes" 809: ; 810: ; PHP's default setting for include_path is ".;/path/to/php/pear" 811: ; http://php.net/include-path 812: 813: ; The root of the PHP pages, used only if nonempty. 814: ; if PHP was not compiled with FORCE_REDIRECT, you SHOULD set doc_root 815: ; if you are running php as a CGI under any web server (other than IIS) 816: ; see documentation for security issues. The alternate is to use the 817: ; cgi.force_redirect configuration below 818: ; http://php.net/doc-root 819: doc_root = 820: 821: ; The directory under which PHP opens the script using /~username used only 822: ; if nonempty. 823: ; http://php.net/user-dir 824: user_dir = 825: 826: ; Directory in which the loadable extensions (modules) reside. 827: ; http://php.net/extension-dir 828: ; extension_dir = "./" 829: ; On windows: 830: ; extension_dir = "ext" 831: 832: ; Whether or not to enable the dl() function. The dl() function does NOT work 833: ; properly in multithreaded servers, such as IIS or Zeus, and is automatically 834: ; disabled on them. 835: ; http://php.net/enable-dl 836: enable_dl = Off 837: 838: ; cgi.force_redirect is necessary to provide security running PHP as a CGI under 839: ; most web servers. Left undefined, PHP turns this on by default. You can 840: ; turn it off here AT YOUR OWN RISK 841: ; **You CAN safely turn this off for IIS, in fact, you MUST.** 842: ; http://php.net/cgi.force-redirect 843: ;cgi.force_redirect = 1 844: 845: ; if cgi.nph is enabled it will force cgi to always sent Status: 200 with 846: ; every request. PHP's default behavior is to disable this feature. 847: ;cgi.nph = 1 848: 849: ; if cgi.force_redirect is turned on, and you are not running under Apache or Netscape 850: ; (iPlanet) web servers, you MAY need to set an environment variable name that PHP 851: ; will look for to know it is OK to continue execution. Setting this variable MAY 852: ; cause security issues, KNOW WHAT YOU ARE DOING FIRST. 853: ; http://php.net/cgi.redirect-status-env 854: ;cgi.redirect_status_env = ; 855: 856: ; cgi.fix_pathinfo provides *real* PATH_INFO/PATH_TRANSLATED support for CGI. PHP's 857: ; previous behaviour was to set PATH_TRANSLATED to SCRIPT_FILENAME, and to not grok 858: ; what PATH_INFO is. For more information on PATH_INFO, see the cgi specs. Setting 859: ; this to 1 will cause PHP CGI to fix its paths to conform to the spec. A setting 860: ; of zero causes PHP to behave as before. Default is 1. You should fix your scripts 861: ; to use SCRIPT_FILENAME rather than PATH_TRANSLATED. 862: ; http://php.net/cgi.fix-pathinfo 863: ;cgi.fix_pathinfo=1 864: 865: ; FastCGI under IIS (on WINNT based OS) supports the ability to impersonate 866: ; security tokens of the calling client. This allows IIS to define the 867: ; security context that the request runs under. mod_fastcgi under Apache 868: ; does not currently support this feature (03/17/2002) 869: ; Set to 1 if running under IIS. Default is zero. 870: ; http://php.net/fastcgi.impersonate 871: ;fastcgi.impersonate = 1; 872: 873: ; Disable logging through FastCGI connection. PHP's default behavior is to enable 874: ; this feature. 875: ;fastcgi.logging = 0 876: 877: ; cgi.rfc2616_headers configuration option tells PHP what type of headers to 878: ; use when sending HTTP response code. If it's set 0 PHP sends Status: header that 879: ; is supported by Apache. When this option is set to 1 PHP will send 880: ; RFC2616 compliant header. 881: ; Default is zero. 882: ; http://php.net/cgi.rfc2616-headers 883: ;cgi.rfc2616_headers = 0 884: 885: ;;;;;;;;;;;;;;;; 886: ; File Uploads ; 887: ;;;;;;;;;;;;;;;; 888: 889: ; Whether to allow HTTP file uploads. 890: ; http://php.net/file-uploads 891: file_uploads = On 892: 893: ; Temporary directory for HTTP uploaded files (will use system default if not 894: ; specified). 895: ; http://php.net/upload-tmp-dir 896: ;upload_tmp_dir = 897: 898: ; Maximum allowed size for uploaded files. 899: ; http://php.net/upload-max-filesize 900: upload_max_filesize = 2M 901: 902: ; Maximum number of files that can be uploaded via a single request 903: max_file_uploads = 20 904: 905: ;;;;;;;;;;;;;;;;;; 906: ; Fopen wrappers ; 907: ;;;;;;;;;;;;;;;;;; 908: 909: ; Whether to allow the treatment of URLs (like http:// or ftp://) as files. 910: ; http://php.net/allow-url-fopen 911: allow_url_fopen = On 912: 913: ; Whether to allow include/require to open URLs (like http:// or ftp://) as files. 914: ; http://php.net/allow-url-include 915: allow_url_include = Off 916: 917: ; Define the anonymous ftp password (your email address). PHP's default setting 918: ; for this is empty. 919: ; http://php.net/from 920: ;from="john@doe.com" 921: 922: ; Define the User-Agent string. PHP's default setting for this is empty. 923: ; http://php.net/user-agent 924: ;user_agent="PHP" 925: 926: ; Default timeout for socket based streams (seconds) 927: ; http://php.net/default-socket-timeout 928: default_socket_timeout = 60 929: 930: ; If your scripts have to deal with files from Macintosh systems, 931: ; or you are running on a Mac and need to deal with files from 932: ; unix or win32 systems, setting this flag will cause PHP to 933: ; automatically detect the EOL character in those files so that 934: ; fgets() and file() will work regardless of the source of the file. 935: ; http://php.net/auto-detect-line-endings 936: ;auto_detect_line_endings = Off 937: 938: ;;;;;;;;;;;;;;;;;;;;;; 939: ; Dynamic Extensions ; 940: ;;;;;;;;;;;;;;;;;;;;;; 941: 942: ; If you wish to have an extension loaded automatically, use the following 943: ; syntax: 944: ; 945: ; extension=modulename.extension 946: ; 947: ; For example, on Windows: 948: ; 949: ; extension=msql.dll 950: ; 951: ; ... or under UNIX: 952: ; 953: ; extension=msql.so 954: ; 955: ; ... or with a path: 956: ; 957: ; extension=/path/to/extension/msql.so 958: ; 959: ; If you only provide the name of the extension, PHP will look for it in its 960: ; default extension directory. 961: ; 962: ; Windows Extensions 963: ; Note that ODBC support is built in, so no dll is needed for it. 964: ; Note that many DLL files are located in the extensions/ (PHP 4) ext/ (PHP 5) 965: ; extension folders as well as the separate PECL DLL download (PHP 5). 966: ; Be sure to appropriately set the extension_dir directive. 967: ; 968: ;extension=php_bz2.dll 969: ;extension=php_curl.dll 970: ;extension=php_fileinfo.dll 971: ;extension=php_gd2.dll 972: ;extension=php_gettext.dll 973: ;extension=php_gmp.dll 974: ;extension=php_intl.dll 975: ;extension=php_imap.dll 976: ;extension=php_interbase.dll 977: ;extension=php_ldap.dll 978: ;extension=php_mbstring.dll 979: ;extension=php_exif.dll ; Must be after mbstring as it depends on it 980: ;extension=php_mysql.dll 981: ;extension=php_mysqli.dll 982: ;extension=php_oci8.dll ; Use with Oracle 10gR2 Instant Client 983: ;extension=php_oci8_11g.dll ; Use with Oracle 11gR2 Instant Client 984: ;extension=php_openssl.dll 985: ;extension=php_pdo_firebird.dll 986: ;extension=php_pdo_mssql.dll 987: ;extension=php_pdo_mysql.dll 988: ;extension=php_pdo_oci.dll 989: ;extension=php_pdo_odbc.dll 990: ;extension=php_pdo_pgsql.dll 991: ;extension=php_pdo_sqlite.dll 992: ;extension=php_pgsql.dll 993: ;extension=php_pspell.dll 994: ;extension=php_shmop.dll 995: 996: ; The MIBS data available in the PHP distribution must be installed. 997: ; See http://www.php.net/manual/en/snmp.installation.php 998: ;extension=php_snmp.dll 999: 1000: ;extension=php_soap.dll 1001: ;extension=php_sockets.dll 1002: ;extension=php_sqlite.dll 1003: ;extension=php_sqlite3.dll 1004: ;extension=php_sybase_ct.dll 1005: ;extension=php_tidy.dll 1006: ;extension=php_xmlrpc.dll 1007: ;extension=php_xsl.dll 1008: ;extension=php_zip.dll 1009: 1010: ;;;;;;;;;;;;;;;;;;; 1011: ; Module Settings ; 1012: ;;;;;;;;;;;;;;;;;;; 1013: 1014: [Date] 1015: ; Defines the default timezone used by the date functions 1016: ; http://php.net/date.timezone 1017: ;date.timezone = 1018: 1019: ; http://php.net/date.default-latitude 1020: ;date.default_latitude = 31.7667 1021: 1022: ; http://php.net/date.default-longitude 1023: ;date.default_longitude = 35.2333 1024: 1025: ; http://php.net/date.sunrise-zenith 1026: ;date.sunrise_zenith = 90.583333 1027: 1028: ; http://php.net/date.sunset-zenith 1029: ;date.sunset_zenith = 90.583333 1030: 1031: [filter] 1032: ; http://php.net/filter.default 1033: ;filter.default = unsafe_raw 1034: 1035: ; http://php.net/filter.default-flags 1036: ;filter.default_flags = 1037: 1038: [iconv] 1039: ;iconv.input_encoding = ISO-8859-1 1040: ;iconv.internal_encoding = ISO-8859-1 1041: ;iconv.output_encoding = ISO-8859-1 1042: 1043: [intl] 1044: ;intl.default_locale = 1045: ; This directive allows you to produce PHP errors when some error 1046: ; happens within intl functions. The value is the level of the error produced. 1047: ; Default is 0, which does not produce any errors. 1048: ;intl.error_level = E_WARNING 1049: 1050: [sqlite] 1051: ; http://php.net/sqlite.assoc-case 1052: ;sqlite.assoc_case = 0 1053: 1054: [sqlite3] 1055: ;sqlite3.extension_dir = 1056: 1057: [Pcre] 1058: ;PCRE library backtracking limit. 1059: ; http://php.net/pcre.backtrack-limit 1060: ;pcre.backtrack_limit=100000 1061: 1062: ;PCRE library recursion limit. 1063: ;Please note that if you set this value to a high number you may consume all 1064: ;the available process stack and eventually crash PHP (due to reaching the 1065: ;stack size limit imposed by the Operating System). 1066: ; http://php.net/pcre.recursion-limit 1067: ;pcre.recursion_limit=100000 1068: 1069: [Pdo] 1070: ; Whether to pool ODBC connections. Can be one of "strict", "relaxed" or "off" 1071: ; http://php.net/pdo-odbc.connection-pooling 1072: ;pdo_odbc.connection_pooling=strict 1073: 1074: ;pdo_odbc.db2_instance_name 1075: 1076: [Pdo_mysql] 1077: ; If mysqlnd is used: Number of cache slots for the internal result set cache 1078: ; http://php.net/pdo_mysql.cache_size 1079: pdo_mysql.cache_size = 2000 1080: 1081: ; Default socket name for local MySQL connects. If empty, uses the built-in 1082: ; MySQL defaults. 1083: ; http://php.net/pdo_mysql.default-socket 1084: pdo_mysql.default_socket= 1085: 1086: [Phar] 1087: ; http://php.net/phar.readonly 1088: ;phar.readonly = On 1089: 1090: ; http://php.net/phar.require-hash 1091: ;phar.require_hash = On 1092: 1093: ;phar.cache_list = 1094: 1095: [Syslog] 1096: ; Whether or not to define the various syslog variables (e.g. $LOG_PID, 1097: ; $LOG_CRON, etc.). Turning it off is a good idea performance-wise. In 1098: ; runtime, you can define these variables by calling define_syslog_variables(). 1099: ; http://php.net/define-syslog-variables 1100: define_syslog_variables = Off 1101: 1102: [mail function] 1103: ; For Win32 only. 1104: ; http://php.net/smtp 1105: SMTP = localhost 1106: ; http://php.net/smtp-port 1107: smtp_port = 25 1108: 1109: ; For Win32 only. 1110: ; http://php.net/sendmail-from 1111: ;sendmail_from = me@example.com 1112: 1113: ; For Unix only. You may supply arguments as well (default: "sendmail -t -i"). 1114: ; http://php.net/sendmail-path 1115: ;sendmail_path = 1116: 1117: ; Force the addition of the specified parameters to be passed as extra parameters 1118: ; to the sendmail binary. These parameters will always replace the value of 1119: ; the 5th parameter to mail(), even in safe mode. 1120: ;mail.force_extra_parameters = 1121: 1122: ; Add X-PHP-Originating-Script: that will include uid of the script followed by the filename 1123: mail.add_x_header = On 1124: 1125: ; The path to a log file that will log all mail() calls. Log entries include 1126: ; the full path of the script, line number, To address and headers. 1127: ;mail.log = 1128: 1129: [SQL] 1130: ; http://php.net/sql.safe-mode 1131: sql.safe_mode = Off 1132: 1133: [ODBC] 1134: ; http://php.net/odbc.default-db 1135: ;odbc.default_db = Not yet implemented 1136: 1137: ; http://php.net/odbc.default-user 1138: ;odbc.default_user = Not yet implemented 1139: 1140: ; http://php.net/odbc.default-pw 1141: ;odbc.default_pw = Not yet implemented 1142: 1143: ; Controls the ODBC cursor model. 1144: ; Default: SQL_CURSOR_STATIC (default). 1145: ;odbc.default_cursortype 1146: 1147: ; Allow or prevent persistent links. 1148: ; http://php.net/odbc.allow-persistent 1149: odbc.allow_persistent = On 1150: 1151: ; Check that a connection is still valid before reuse. 1152: ; http://php.net/odbc.check-persistent 1153: odbc.check_persistent = On 1154: 1155: ; Maximum number of persistent links. -1 means no limit. 1156: ; http://php.net/odbc.max-persistent 1157: odbc.max_persistent = -1 1158: 1159: ; Maximum number of links (persistent + non-persistent). -1 means no limit. 1160: ; http://php.net/odbc.max-links 1161: odbc.max_links = -1 1162: 1163: ; Handling of LONG fields. Returns number of bytes to variables. 0 means 1164: ; passthru. 1165: ; http://php.net/odbc.defaultlrl 1166: odbc.defaultlrl = 4096 1167: 1168: ; Handling of binary data. 0 means passthru, 1 return as is, 2 convert to char. 1169: ; See the documentation on odbc_binmode and odbc_longreadlen for an explanation 1170: ; of odbc.defaultlrl and odbc.defaultbinmode 1171: ; http://php.net/odbc.defaultbinmode 1172: odbc.defaultbinmode = 1 1173: 1174: ;birdstep.max_links = -1 1175: 1176: [Interbase] 1177: ; Allow or prevent persistent links. 1178: ibase.allow_persistent = 1 1179: 1180: ; Maximum number of persistent links. -1 means no limit. 1181: ibase.max_persistent = -1 1182: 1183: ; Maximum number of links (persistent + non-persistent). -1 means no limit. 1184: ibase.max_links = -1 1185: 1186: ; Default database name for ibase_connect(). 1187: ;ibase.default_db = 1188: 1189: ; Default username for ibase_connect(). 1190: ;ibase.default_user = 1191: 1192: ; Default password for ibase_connect(). 1193: ;ibase.default_password = 1194: 1195: ; Default charset for ibase_connect(). 1196: ;ibase.default_charset = 1197: 1198: ; Default timestamp format. 1199: ibase.timestampformat = "%Y-%m-%d %H:%M:%S" 1200: 1201: ; Default date format. 1202: ibase.dateformat = "%Y-%m-%d" 1203: 1204: ; Default time format. 1205: ibase.timeformat = "%H:%M:%S" 1206: 1207: [MySQL] 1208: ; Allow accessing, from PHP's perspective, local files with LOAD DATA statements 1209: ; http://php.net/mysql.allow_local_infile 1210: mysql.allow_local_infile = On 1211: 1212: ; Allow or prevent persistent links. 1213: ; http://php.net/mysql.allow-persistent 1214: mysql.allow_persistent = On 1215: 1216: ; If mysqlnd is used: Number of cache slots for the internal result set cache 1217: ; http://php.net/mysql.cache_size 1218: mysql.cache_size = 2000 1219: 1220: ; Maximum number of persistent links. -1 means no limit. 1221: ; http://php.net/mysql.max-persistent 1222: mysql.max_persistent = -1 1223: 1224: ; Maximum number of links (persistent + non-persistent). -1 means no limit. 1225: ; http://php.net/mysql.max-links 1226: mysql.max_links = -1 1227: 1228: ; Default port number for mysql_connect(). If unset, mysql_connect() will use 1229: ; the $MYSQL_TCP_PORT or the mysql-tcp entry in /etc/services or the 1230: ; compile-time value defined MYSQL_PORT (in that order). Win32 will only look 1231: ; at MYSQL_PORT. 1232: ; http://php.net/mysql.default-port 1233: mysql.default_port = 1234: 1235: ; Default socket name for local MySQL connects. If empty, uses the built-in 1236: ; MySQL defaults. 1237: ; http://php.net/mysql.default-socket 1238: mysql.default_socket = 1239: 1240: ; Default host for mysql_connect() (doesn't apply in safe mode). 1241: ; http://php.net/mysql.default-host 1242: mysql.default_host = 1243: 1244: ; Default user for mysql_connect() (doesn't apply in safe mode). 1245: ; http://php.net/mysql.default-user 1246: mysql.default_user = 1247: 1248: ; Default password for mysql_connect() (doesn't apply in safe mode). 1249: ; Note that this is generally a *bad* idea to store passwords in this file. 1250: ; *Any* user with PHP access can run 'echo get_cfg_var("mysql.default_password") 1251: ; and reveal this password! And of course, any users with read access to this 1252: ; file will be able to reveal the password as well. 1253: ; http://php.net/mysql.default-password 1254: mysql.default_password = 1255: 1256: ; Maximum time (in seconds) for connect timeout. -1 means no limit 1257: ; http://php.net/mysql.connect-timeout 1258: mysql.connect_timeout = 60 1259: 1260: ; Trace mode. When trace_mode is active (=On), warnings for table/index scans and 1261: ; SQL-Errors will be displayed. 1262: ; http://php.net/mysql.trace-mode 1263: mysql.trace_mode = Off 1264: 1265: [MySQLi] 1266: 1267: ; Maximum number of persistent links. -1 means no limit. 1268: ; http://php.net/mysqli.max-persistent 1269: mysqli.max_persistent = -1 1270: 1271: ; Allow accessing, from PHP's perspective, local files with LOAD DATA statements 1272: ; http://php.net/mysqli.allow_local_infile 1273: ;mysqli.allow_local_infile = On 1274: 1275: ; Allow or prevent persistent links. 1276: ; http://php.net/mysqli.allow-persistent 1277: mysqli.allow_persistent = On 1278: 1279: ; Maximum number of links. -1 means no limit. 1280: ; http://php.net/mysqli.max-links 1281: mysqli.max_links = -1 1282: 1283: ; If mysqlnd is used: Number of cache slots for the internal result set cache 1284: ; http://php.net/mysqli.cache_size 1285: mysqli.cache_size = 2000 1286: 1287: ; Default port number for mysqli_connect(). If unset, mysqli_connect() will use 1288: ; the $MYSQL_TCP_PORT or the mysql-tcp entry in /etc/services or the 1289: ; compile-time value defined MYSQL_PORT (in that order). Win32 will only look 1290: ; at MYSQL_PORT. 1291: ; http://php.net/mysqli.default-port 1292: mysqli.default_port = 3306 1293: 1294: ; Default socket name for local MySQL connects. If empty, uses the built-in 1295: ; MySQL defaults. 1296: ; http://php.net/mysqli.default-socket 1297: mysqli.default_socket = 1298: 1299: ; Default host for mysql_connect() (doesn't apply in safe mode). 1300: ; http://php.net/mysqli.default-host 1301: mysqli.default_host = 1302: 1303: ; Default user for mysql_connect() (doesn't apply in safe mode). 1304: ; http://php.net/mysqli.default-user 1305: mysqli.default_user = 1306: 1307: ; Default password for mysqli_connect() (doesn't apply in safe mode). 1308: ; Note that this is generally a *bad* idea to store passwords in this file. 1309: ; *Any* user with PHP access can run 'echo get_cfg_var("mysqli.default_pw") 1310: ; and reveal this password! And of course, any users with read access to this 1311: ; file will be able to reveal the password as well. 1312: ; http://php.net/mysqli.default-pw 1313: mysqli.default_pw = 1314: 1315: ; Allow or prevent reconnect 1316: mysqli.reconnect = Off 1317: 1318: [mysqlnd] 1319: ; Enable / Disable collection of general statistics by mysqlnd which can be 1320: ; used to tune and monitor MySQL operations. 1321: ; http://php.net/mysqlnd.collect_statistics 1322: mysqlnd.collect_statistics = On 1323: 1324: ; Enable / Disable collection of memory usage statistics by mysqlnd which can be 1325: ; used to tune and monitor MySQL operations. 1326: ; http://php.net/mysqlnd.collect_memory_statistics 1327: mysqlnd.collect_memory_statistics = Off 1328: 1329: ; Size of a pre-allocated buffer used when sending commands to MySQL in bytes. 1330: ; http://php.net/mysqlnd.net_cmd_buffer_size 1331: ;mysqlnd.net_cmd_buffer_size = 2048 1332: 1333: ; Size of a pre-allocated buffer used for reading data sent by the server in 1334: ; bytes. 1335: ; http://php.net/mysqlnd.net_read_buffer_size 1336: ;mysqlnd.net_read_buffer_size = 32768 1337: 1338: [OCI8] 1339: 1340: ; Connection: Enables privileged connections using external 1341: ; credentials (OCI_SYSOPER, OCI_SYSDBA) 1342: ; http://php.net/oci8.privileged-connect 1343: ;oci8.privileged_connect = Off 1344: 1345: ; Connection: The maximum number of persistent OCI8 connections per 1346: ; process. Using -1 means no limit. 1347: ; http://php.net/oci8.max-persistent 1348: ;oci8.max_persistent = -1 1349: 1350: ; Connection: The maximum number of seconds a process is allowed to 1351: ; maintain an idle persistent connection. Using -1 means idle 1352: ; persistent connections will be maintained forever. 1353: ; http://php.net/oci8.persistent-timeout 1354: ;oci8.persistent_timeout = -1 1355: 1356: ; Connection: The number of seconds that must pass before issuing a 1357: ; ping during oci_pconnect() to check the connection validity. When 1358: ; set to 0, each oci_pconnect() will cause a ping. Using -1 disables 1359: ; pings completely. 1360: ; http://php.net/oci8.ping-interval 1361: ;oci8.ping_interval = 60 1362: 1363: ; Connection: Set this to a user chosen connection class to be used 1364: ; for all pooled server requests with Oracle 11g Database Resident 1365: ; Connection Pooling (DRCP). To use DRCP, this value should be set to 1366: ; the same string for all web servers running the same application, 1367: ; the database pool must be configured, and the connection string must 1368: ; specify to use a pooled server. 1369: ;oci8.connection_class = 1370: 1371: ; High Availability: Using On lets PHP receive Fast Application 1372: ; Notification (FAN) events generated when a database node fails. The 1373: ; database must also be configured to post FAN events. 1374: ;oci8.events = Off 1375: 1376: ; Tuning: This option enables statement caching, and specifies how 1377: ; many statements to cache. Using 0 disables statement caching. 1378: ; http://php.net/oci8.statement-cache-size 1379: ;oci8.statement_cache_size = 20 1380: 1381: ; Tuning: Enables statement prefetching and sets the default number of 1382: ; rows that will be fetched automatically after statement execution. 1383: ; http://php.net/oci8.default-prefetch 1384: ;oci8.default_prefetch = 100 1385: 1386: ; Compatibility. Using On means oci_close() will not close 1387: ; oci_connect() and oci_new_connect() connections. 1388: ; http://php.net/oci8.old-oci-close-semantics 1389: ;oci8.old_oci_close_semantics = Off 1390: 1391: [PostgreSQL] 1392: ; Allow or prevent persistent links. 1393: ; http://php.net/pgsql.allow-persistent 1394: pgsql.allow_persistent = On 1395: 1396: ; Detect broken persistent links always with pg_pconnect(). 1397: ; Auto reset feature requires a little overheads. 1398: ; http://php.net/pgsql.auto-reset-persistent 1399: pgsql.auto_reset_persistent = Off 1400: 1401: ; Maximum number of persistent links. -1 means no limit. 1402: ; http://php.net/pgsql.max-persistent 1403: pgsql.max_persistent = -1 1404: 1405: ; Maximum number of links (persistent+non persistent). -1 means no limit. 1406: ; http://php.net/pgsql.max-links 1407: pgsql.max_links = -1 1408: 1409: ; Ignore PostgreSQL backends Notice message or not. 1410: ; Notice message logging require a little overheads. 1411: ; http://php.net/pgsql.ignore-notice 1412: pgsql.ignore_notice = 0 1413: 1414: ; Log PostgreSQL backends Notice message or not. 1415: ; Unless pgsql.ignore_notice=0, module cannot log notice message. 1416: ; http://php.net/pgsql.log-notice 1417: pgsql.log_notice = 0 1418: 1419: [Sybase-CT] 1420: ; Allow or prevent persistent links. 1421: ; http://php.net/sybct.allow-persistent 1422: sybct.allow_persistent = On 1423: 1424: ; Maximum number of persistent links. -1 means no limit. 1425: ; http://php.net/sybct.max-persistent 1426: sybct.max_persistent = -1 1427: 1428: ; Maximum number of links (persistent + non-persistent). -1 means no limit. 1429: ; http://php.net/sybct.max-links 1430: sybct.max_links = -1 1431: 1432: ; Minimum server message severity to display. 1433: ; http://php.net/sybct.min-server-severity 1434: sybct.min_server_severity = 10 1435: 1436: ; Minimum client message severity to display. 1437: ; http://php.net/sybct.min-client-severity 1438: sybct.min_client_severity = 10 1439: 1440: ; Set per-context timeout 1441: ; http://php.net/sybct.timeout 1442: ;sybct.timeout= 1443: 1444: ;sybct.packet_size 1445: 1446: ; The maximum time in seconds to wait for a connection attempt to succeed before returning failure. 1447: ; Default: one minute 1448: ;sybct.login_timeout= 1449: 1450: ; The name of the host you claim to be connecting from, for display by sp_who. 1451: ; Default: none 1452: ;sybct.hostname= 1453: 1454: ; Allows you to define how often deadlocks are to be retried. -1 means "forever". 1455: ; Default: 0 1456: ;sybct.deadlock_retry_count= 1457: 1458: [bcmath] 1459: ; Number of decimal digits for all bcmath functions. 1460: ; http://php.net/bcmath.scale 1461: bcmath.scale = 0 1462: 1463: [browscap] 1464: ; http://php.net/browscap 1465: ;browscap = extra/browscap.ini 1466: 1467: [Session] 1468: ; Handler used to store/retrieve data. 1469: ; http://php.net/session.save-handler 1470: session.save_handler = files 1471: 1472: ; Argument passed to save_handler. In the case of files, this is the path 1473: ; where data files are stored. Note: Windows users have to change this 1474: ; variable in order to use PHP's session functions. 1475: ; 1476: ; The path can be defined as: 1477: ; 1478: ; session.save_path = "N;/path" 1479: ; 1480: ; where N is an integer. Instead of storing all the session files in 1481: ; /path, what this will do is use subdirectories N-levels deep, and 1482: ; store the session data in those directories. This is useful if you 1483: ; or your OS have problems with lots of files in one directory, and is 1484: ; a more efficient layout for servers that handle lots of sessions. 1485: ; 1486: ; NOTE 1: PHP will not create this directory structure automatically. 1487: ; You can use the script in the ext/session dir for that purpose. 1488: ; NOTE 2: See the section on garbage collection below if you choose to 1489: ; use subdirectories for session storage 1490: ; 1491: ; The file storage module creates files using mode 600 by default. 1492: ; You can change that by using 1493: ; 1494: ; session.save_path = "N;MODE;/path" 1495: ; 1496: ; where MODE is the octal representation of the mode. Note that this 1497: ; does not overwrite the process's umask. 1498: ; http://php.net/session.save-path 1499: ;session.save_path = "/tmp" 1500: 1501: ; Whether to use cookies. 1502: ; http://php.net/session.use-cookies 1503: session.use_cookies = 1 1504: 1505: ; http://php.net/session.cookie-secure 1506: ;session.cookie_secure = 1507: 1508: ; This option forces PHP to fetch and use a cookie for storing and maintaining 1509: ; the session id. We encourage this operation as it's very helpful in combatting 1510: ; session hijacking when not specifying and managing your own session id. It is 1511: ; not the end all be all of session hijacking defense, but it's a good start. 1512: ; http://php.net/session.use-only-cookies 1513: session.use_only_cookies = 1 1514: 1515: ; Name of the session (used as cookie name). 1516: ; http://php.net/session.name 1517: session.name = PHPSESSID 1518: 1519: ; Initialize session on request startup. 1520: ; http://php.net/session.auto-start 1521: session.auto_start = 0 1522: 1523: ; Lifetime in seconds of cookie or, if 0, until browser is restarted. 1524: ; http://php.net/session.cookie-lifetime 1525: session.cookie_lifetime = 0 1526: 1527: ; The path for which the cookie is valid. 1528: ; http://php.net/session.cookie-path 1529: session.cookie_path = / 1530: 1531: ; The domain for which the cookie is valid. 1532: ; http://php.net/session.cookie-domain 1533: session.cookie_domain = 1534: 1535: ; Whether or not to add the httpOnly flag to the cookie, which makes it inaccessible to browser scripting languages such as JavaScript. 1536: ; http://php.net/session.cookie-httponly 1537: session.cookie_httponly = 1538: 1539: ; Handler used to serialize data. php is the standard serializer of PHP. 1540: ; http://php.net/session.serialize-handler 1541: session.serialize_handler = php 1542: 1543: ; Defines the probability that the 'garbage collection' process is started 1544: ; on every session initialization. The probability is calculated by using 1545: ; gc_probability/gc_divisor. Where session.gc_probability is the numerator 1546: ; and gc_divisor is the denominator in the equation. Setting this value to 1 1547: ; when the session.gc_divisor value is 100 will give you approximately a 1% chance 1548: ; the gc will run on any give request. 1549: ; Default Value: 1 1550: ; Development Value: 1 1551: ; Production Value: 1 1552: ; http://php.net/session.gc-probability 1553: session.gc_probability = 1 1554: 1555: ; Defines the probability that the 'garbage collection' process is started on every 1556: ; session initialization. The probability is calculated by using the following equation: 1557: ; gc_probability/gc_divisor. Where session.gc_probability is the numerator and 1558: ; session.gc_divisor is the denominator in the equation. Setting this value to 1 1559: ; when the session.gc_divisor value is 100 will give you approximately a 1% chance 1560: ; the gc will run on any give request. Increasing this value to 1000 will give you 1561: ; a 0.1% chance the gc will run on any give request. For high volume production servers, 1562: ; this is a more efficient approach. 1563: ; Default Value: 100 1564: ; Development Value: 1000 1565: ; Production Value: 1000 1566: ; http://php.net/session.gc-divisor 1567: session.gc_divisor = 1000 1568: 1569: ; After this number of seconds, stored data will be seen as 'garbage' and 1570: ; cleaned up by the garbage collection process. 1571: ; http://php.net/session.gc-maxlifetime 1572: session.gc_maxlifetime = 1440 1573: 1574: ; NOTE: If you are using the subdirectory option for storing session files 1575: ; (see session.save_path above), then garbage collection does *not* 1576: ; happen automatically. You will need to do your own garbage 1577: ; collection through a shell script, cron entry, or some other method. 1578: ; For example, the following script would is the equivalent of 1579: ; setting session.gc_maxlifetime to 1440 (1440 seconds = 24 minutes): 1580: ; find /path/to/sessions -cmin +24 | xargs rm 1581: 1582: ; PHP 4.2 and less have an undocumented feature/bug that allows you to 1583: ; to initialize a session variable in the global scope, even when register_globals 1584: ; is disabled. PHP 4.3 and later will warn you, if this feature is used. 1585: ; You can disable the feature and the warning separately. At this time, 1586: ; the warning is only displayed, if bug_compat_42 is enabled. This feature 1587: ; introduces some serious security problems if not handled correctly. It's 1588: ; recommended that you do not use this feature on production servers. But you 1589: ; should enable this on development servers and enable the warning as well. If you 1590: ; do not enable the feature on development servers, you won't be warned when it's 1591: ; used and debugging errors caused by this can be difficult to track down. 1592: ; Default Value: On 1593: ; Development Value: On 1594: ; Production Value: Off 1595: ; http://php.net/session.bug-compat-42 1596: session.bug_compat_42 = Off 1597: 1598: ; This setting controls whether or not you are warned by PHP when initializing a 1599: ; session value into the global space. session.bug_compat_42 must be enabled before 1600: ; these warnings can be issued by PHP. See the directive above for more information. 1601: ; Default Value: On 1602: ; Development Value: On 1603: ; Production Value: Off 1604: ; http://php.net/session.bug-compat-warn 1605: session.bug_compat_warn = Off 1606: 1607: ; Check HTTP Referer to invalidate externally stored URLs containing ids. 1608: ; HTTP_REFERER has to contain this substring for the session to be 1609: ; considered as valid. 1610: ; http://php.net/session.referer-check 1611: session.referer_check = 1612: 1613: ; How many bytes to read from the file. 1614: ; http://php.net/session.entropy-length 1615: session.entropy_length = 0 1616: 1617: ; Specified here to create the session id. 1618: ; http://php.net/session.entropy-file 1619: ; On systems that don't have /dev/urandom /dev/arandom can be used 1620: ; On windows, setting the entropy_length setting will activate the 1621: ; Windows random source (using the CryptoAPI) 1622: ;session.entropy_file = /dev/urandom 1623: 1624: ; Set to {nocache,private,public,} to determine HTTP caching aspects 1625: ; or leave this empty to avoid sending anti-caching headers. 1626: ; http://php.net/session.cache-limiter 1627: session.cache_limiter = nocache 1628: 1629: ; Document expires after n minutes. 1630: ; http://php.net/session.cache-expire 1631: session.cache_expire = 180 1632: 1633: ; trans sid support is disabled by default. 1634: ; Use of trans sid may risk your users security. 1635: ; Use this option with caution. 1636: ; - User may send URL contains active session ID 1637: ; to other person via. email/irc/etc. 1638: ; - URL that contains active session ID may be stored 1639: ; in publically accessible computer. 1640: ; - User may access your site with the same session ID 1641: ; always using URL stored in browser's history or bookmarks. 1642: ; http://php.net/session.use-trans-sid 1643: session.use_trans_sid = 0 1644: 1645: ; Select a hash function for use in generating session ids. 1646: ; Possible Values 1647: ; 0 (MD5 128 bits) 1648: ; 1 (SHA-1 160 bits) 1649: ; This option may also be set to the name of any hash function supported by 1650: ; the hash extension. A list of available hashes is returned by the hash_algos() 1651: ; function. 1652: ; http://php.net/session.hash-function 1653: session.hash_function = 0 1654: 1655: ; Define how many bits are stored in each character when converting 1656: ; the binary hash data to something readable. 1657: ; Possible values: 1658: ; 4 (4 bits: 0-9, a-f) 1659: ; 5 (5 bits: 0-9, a-v) 1660: ; 6 (6 bits: 0-9, a-z, A-Z, "-", ",") 1661: ; Default Value: 4 1662: ; Development Value: 5 1663: ; Production Value: 5 1664: ; http://php.net/session.hash-bits-per-character 1665: session.hash_bits_per_character = 5 1666: 1667: ; The URL rewriter will look for URLs in a defined set of HTML tags. 1668: ; form/fieldset are special; if you include them here, the rewriter will 1669: ; add a hidden <input> field with the info which is otherwise appended 1670: ; to URLs. If you want XHTML conformity, remove the form entry. 1671: ; Note that all valid entries require a "=", even if no value follows. 1672: ; Default Value: "a=href,area=href,frame=src,form=,fieldset=" 1673: ; Development Value: "a=href,area=href,frame=src,input=src,form=fakeentry" 1674: ; Production Value: "a=href,area=href,frame=src,input=src,form=fakeentry" 1675: ; http://php.net/url-rewriter.tags 1676: url_rewriter.tags = "a=href,area=href,frame=src,input=src,form=fakeentry" 1677: 1678: [MSSQL] 1679: ; Allow or prevent persistent links. 1680: mssql.allow_persistent = On 1681: 1682: ; Maximum number of persistent links. -1 means no limit. 1683: mssql.max_persistent = -1 1684: 1685: ; Maximum number of links (persistent+non persistent). -1 means no limit. 1686: mssql.max_links = -1 1687: 1688: ; Minimum error severity to display. 1689: mssql.min_error_severity = 10 1690: 1691: ; Minimum message severity to display. 1692: mssql.min_message_severity = 10 1693: 1694: ; Compatibility mode with old versions of PHP 3.0. 1695: mssql.compatability_mode = Off 1696: 1697: ; Connect timeout 1698: ;mssql.connect_timeout = 5 1699: 1700: ; Query timeout 1701: ;mssql.timeout = 60 1702: 1703: ; Valid range 0 - 2147483647. Default = 4096. 1704: ;mssql.textlimit = 4096 1705: 1706: ; Valid range 0 - 2147483647. Default = 4096. 1707: ;mssql.textsize = 4096 1708: 1709: ; Limits the number of records in each batch. 0 = all records in one batch. 1710: ;mssql.batchsize = 0 1711: 1712: ; Specify how datetime and datetim4 columns are returned 1713: ; On => Returns data converted to SQL server settings 1714: ; Off => Returns values as YYYY-MM-DD hh:mm:ss 1715: ;mssql.datetimeconvert = On 1716: 1717: ; Use NT authentication when connecting to the server 1718: mssql.secure_connection = Off 1719: 1720: ; Specify max number of processes. -1 = library default 1721: ; msdlib defaults to 25 1722: ; FreeTDS defaults to 4096 1723: ;mssql.max_procs = -1 1724: 1725: ; Specify client character set. 1726: ; If empty or not set the client charset from freetds.conf is used 1727: ; This is only used when compiled with FreeTDS 1728: ;mssql.charset = "ISO-8859-1" 1729: 1730: [Assertion] 1731: ; Assert(expr); active by default. 1732: ; http://php.net/assert.active 1733: ;assert.active = On 1734: 1735: ; Issue a PHP warning for each failed assertion. 1736: ; http://php.net/assert.warning 1737: ;assert.warning = On 1738: 1739: ; Don't bail out by default. 1740: ; http://php.net/assert.bail 1741: ;assert.bail = Off 1742: 1743: ; User-function to be called if an assertion fails. 1744: ; http://php.net/assert.callback 1745: ;assert.callback = 0 1746: 1747: ; Eval the expression with current error_reporting(). Set to true if you want 1748: ; error_reporting(0) around the eval(). 1749: ; http://php.net/assert.quiet-eval 1750: ;assert.quiet_eval = 0 1751: 1752: [COM] 1753: ; path to a file containing GUIDs, IIDs or filenames of files with TypeLibs 1754: ; http://php.net/com.typelib-file 1755: ;com.typelib_file = 1756: 1757: ; allow Distributed-COM calls 1758: ; http://php.net/com.allow-dcom 1759: ;com.allow_dcom = true 1760: 1761: ; autoregister constants of a components typlib on com_load() 1762: ; http://php.net/com.autoregister-typelib 1763: ;com.autoregister_typelib = true 1764: 1765: ; register constants casesensitive 1766: ; http://php.net/com.autoregister-casesensitive 1767: ;com.autoregister_casesensitive = false 1768: 1769: ; show warnings on duplicate constant registrations 1770: ; http://php.net/com.autoregister-verbose 1771: ;com.autoregister_verbose = true 1772: 1773: ; The default character set code-page to use when passing strings to and from COM objects. 1774: ; Default: system ANSI code page 1775: ;com.code_page= 1776: 1777: [mbstring] 1778: ; language for internal character representation. 1779: ; http://php.net/mbstring.language 1780: ;mbstring.language = Japanese 1781: 1782: ; internal/script encoding. 1783: ; Some encoding cannot work as internal encoding. 1784: ; (e.g. SJIS, BIG5, ISO-2022-*) 1785: ; http://php.net/mbstring.internal-encoding 1786: ;mbstring.internal_encoding = EUC-JP 1787: 1788: ; http input encoding. 1789: ; http://php.net/mbstring.http-input 1790: ;mbstring.http_input = auto 1791: 1792: ; http output encoding. mb_output_handler must be 1793: ; registered as output buffer to function 1794: ; http://php.net/mbstring.http-output 1795: ;mbstring.http_output = SJIS 1796: 1797: ; enable automatic encoding translation according to 1798: ; mbstring.internal_encoding setting. Input chars are 1799: ; converted to internal encoding by setting this to On. 1800: ; Note: Do _not_ use automatic encoding translation for 1801: ; portable libs/applications. 1802: ; http://php.net/mbstring.encoding-translation 1803: ;mbstring.encoding_translation = Off 1804: 1805: ; automatic encoding detection order. 1806: ; auto means 1807: ; http://php.net/mbstring.detect-order 1808: ;mbstring.detect_order = auto 1809: 1810: ; substitute_character used when character cannot be converted 1811: ; one from another 1812: ; http://php.net/mbstring.substitute-character 1813: ;mbstring.substitute_character = none; 1814: 1815: ; overload(replace) single byte functions by mbstring functions. 1816: ; mail(), ereg(), etc are overloaded by mb_send_mail(), mb_ereg(), 1817: ; etc. Possible values are 0,1,2,4 or combination of them. 1818: ; For example, 7 for overload everything. 1819: ; 0: No overload 1820: ; 1: Overload mail() function 1821: ; 2: Overload str*() functions 1822: ; 4: Overload ereg*() functions 1823: ; http://php.net/mbstring.func-overload 1824: ;mbstring.func_overload = 0 1825: 1826: ; enable strict encoding detection. 1827: ;mbstring.strict_detection = Off 1828: 1829: ; This directive specifies the regex pattern of content types for which mb_output_handler() 1830: ; is activated. 1831: ; Default: mbstring.http_output_conv_mimetype=^(text/|application/xhtml\+xml) 1832: ;mbstring.http_output_conv_mimetype= 1833: 1834: ; Allows to set script encoding. Only affects if PHP is compiled with --enable-zend-multibyte 1835: ; Default: "" 1836: ;mbstring.script_encoding= 1837: 1838: [gd] 1839: ; Tell the jpeg decode to ignore warnings and try to create 1840: ; a gd image. The warning will then be displayed as notices 1841: ; disabled by default 1842: ; http://php.net/gd.jpeg-ignore-warning 1843: ;gd.jpeg_ignore_warning = 0 1844: 1845: [exif] 1846: ; Exif UNICODE user comments are handled as UCS-2BE/UCS-2LE and JIS as JIS. 1847: ; With mbstring support this will automatically be converted into the encoding 1848: ; given by corresponding encode setting. When empty mbstring.internal_encoding 1849: ; is used. For the decode settings you can distinguish between motorola and 1850: ; intel byte order. A decode setting cannot be empty. 1851: ; http://php.net/exif.encode-unicode 1852: ;exif.encode_unicode = ISO-8859-15 1853: 1854: ; http://php.net/exif.decode-unicode-motorola 1855: ;exif.decode_unicode_motorola = UCS-2BE 1856: 1857: ; http://php.net/exif.decode-unicode-intel 1858: ;exif.decode_unicode_intel = UCS-2LE 1859: 1860: ; http://php.net/exif.encode-jis 1861: ;exif.encode_jis = 1862: 1863: ; http://php.net/exif.decode-jis-motorola 1864: ;exif.decode_jis_motorola = JIS 1865: 1866: ; http://php.net/exif.decode-jis-intel 1867: ;exif.decode_jis_intel = JIS 1868: 1869: [Tidy] 1870: ; The path to a default tidy configuration file to use when using tidy 1871: ; http://php.net/tidy.default-config 1872: ;tidy.default_config = /usr/local/lib/php/default.tcfg 1873: 1874: ; Should tidy clean and repair output automatically? 1875: ; WARNING: Do not use this option if you are generating non-html content 1876: ; such as dynamic images 1877: ; http://php.net/tidy.clean-output 1878: tidy.clean_output = Off 1879: 1880: [soap] 1881: ; Enables or disables WSDL caching feature. 1882: ; http://php.net/soap.wsdl-cache-enabled 1883: soap.wsdl_cache_enabled=1 1884: 1885: ; Sets the directory name where SOAP extension will put cache files. 1886: ; http://php.net/soap.wsdl-cache-dir 1887: soap.wsdl_cache_dir="/tmp" 1888: 1889: ; (time to live) Sets the number of second while cached file will be used 1890: ; instead of original one. 1891: ; http://php.net/soap.wsdl-cache-ttl 1892: soap.wsdl_cache_ttl=86400 1893: 1894: ; Sets the size of the cache limit. (Max. number of WSDL files to cache) 1895: soap.wsdl_cache_limit = 5 1896: 1897: [sysvshm] 1898: ; A default size of the shared memory segment 1899: ;sysvshm.init_mem = 10000 1900: 1901: [ldap] 1902: ; Sets the maximum number of open links or -1 for unlimited. 1903: ldap.max_links = -1 1904: 1905: [mcrypt] 1906: ; For more information about mcrypt settings see http://php.net/mcrypt-module-open 1907: 1908: ; Directory where to load mcrypt algorithms 1909: ; Default: Compiled in into libmcrypt (usually /usr/local/lib/libmcrypt) 1910: ;mcrypt.algorithms_dir= 1911: 1912: ; Directory where to load mcrypt modes 1913: ; Default: Compiled in into libmcrypt (usually /usr/local/lib/libmcrypt) 1914: ;mcrypt.modes_dir= 1915: 1916: [dba] 1917: ;dba.default_handler= 1918: 1919: [xsl] 1920: ; Write operations from within XSLT are disabled by default. 1921: ; XSL_SECPREF_CREATE_DIRECTORY | XSL_SECPREF_WRITE_NETWORK | XSL_SECPREF_WRITE_FILE = 44 1922: ; Set it to 0 to allow all operations 1923: ;xsl.security_prefs = 44 1924: 1925: ; Local Variables: 1926: ; tab-width: 4 1927: ; End: