codekingpro/portable-devtools
116k
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.
13; 3. A number of predefined registry keys on Windows
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 (usually C:\windows)
19; See the PHP docs for more specific information.
20; https://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; https://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-conscious 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 is
82; much more verbose when it comes to errors. We recommend using the
83; development version only in development environments, as errors shown to
84; application users can inadvertently leak otherwise secure information.
85
86; This is the php.ini-development INI file.
87
88;;;;;;;;;;;;;;;;;;;
89; Quick Reference ;
90;;;;;;;;;;;;;;;;;;;
91
92; The following are all the settings which are different in either the production
93; or development versions of the INIs with respect to PHP's default behavior.
94; Please see the actual settings later in the document for more details as to why
95; we recommend these changes in PHP's behavior.
96
97; display_errors
98; Default Value: On
99; Development Value: On
100; Production Value: Off
101
102; display_startup_errors
103; Default Value: On
104; Development Value: On
105; Production Value: Off
106
107; error_reporting
108; Default Value: E_ALL
109; Development Value: E_ALL
110; Production Value: E_ALL & ~E_DEPRECATED
111
112; log_errors
113; Default Value: Off
114; Development Value: On
115; Production Value: On
116
117; max_input_time
118; Default Value: -1 (Unlimited)
119; Development Value: 60 (60 seconds)
120; Production Value: 60 (60 seconds)
121
122; mysqlnd.collect_memory_statistics
123; Default Value: Off
124; Development Value: On
125; Production Value: Off
126
127; output_buffering
128; Default Value: Off
129; Development Value: 4096
130; Production Value: 4096
131
132; request_order
133; Default Value: None
134; Development Value: "GP"
135; Production Value: "GP"
136
137; session.gc_divisor
138; Default Value: 100
139; Development Value: 1000
140; Production Value: 1000
141
142; short_open_tag
143; Default Value: On
144; Development Value: Off
145; Production Value: Off
146
147; variables_order
148; Default Value: "EGPCS"
149; Development Value: "GPCS"
150; Production Value: "GPCS"
151
152; zend.assertions
153; Default Value: 1
154; Development Value: 1
155; Production Value: -1
156
157; zend.exception_ignore_args
158; Default Value: Off
159; Development Value: Off
160; Production Value: On
161
162; zend.exception_string_param_max_len
163; Default Value: 15
164; Development Value: 15
165; Production Value: 0
166
167;;;;;;;;;;;;;;;;;;;;
168; php.ini Options ;
169;;;;;;;;;;;;;;;;;;;;
170; Name for user-defined php.ini (.htaccess) files. Default is ".user.ini"
171;user_ini.filename = ".user.ini"
172
173; To disable this feature set this option to an empty value
174;user_ini.filename =
175
176; TTL for user-defined php.ini files (time-to-live) in seconds. Default is 300 seconds (5 minutes)
177;user_ini.cache_ttl = 300
178
179;;;;;;;;;;;;;;;;;;;;
180; Language Options ;
181;;;;;;;;;;;;;;;;;;;;
182
183; Enable the PHP scripting language engine under Apache.
184; https://php.net/engine
185engine = On
186
187; This directive determines whether or not PHP will recognize code between
188; <? and ?> tags as PHP source which should be processed as such. It is
189; generally recommended that <?php and ?> should be used and that this feature
190; should be disabled, as enabling it may result in issues when generating XML
191; documents, however this remains supported for backward compatibility reasons.
192; Note that this directive does not control the <?= shorthand tag, which can be
193; used regardless of this directive.
194; Default Value: On
195; Development Value: Off
196; Production Value: Off
197; https://php.net/short-open-tag
198short_open_tag = Off
199
200; The number of significant digits displayed in floating point numbers.
201; https://php.net/precision
202precision = 14
203
204; Output buffering is a mechanism for controlling how much output data
205; (excluding headers and cookies) PHP should keep internally before pushing that
206; data to the client. If your application's output exceeds this setting, PHP
207; will send that data in chunks of roughly the size you specify.
208; Turning on this setting and managing its maximum buffer size can yield some
209; interesting side-effects depending on your application and web server.
210; You may be able to send headers and cookies after you've already sent output
211; through print or echo. You also may see performance benefits if your server is
212; emitting less packets due to buffered output versus PHP streaming the output
213; as it gets it. On production servers, 4096 bytes is a good setting for performance
214; reasons.
215; Note: Output buffering can also be controlled via Output Buffering Control
216; functions.
217; Possible Values:
218; On = Enabled and buffer is unlimited. (Use with caution)
219; Off = Disabled
220; Integer = Enables the buffer and sets its maximum size in bytes.
221; Note: This directive is hardcoded to Off for the CLI SAPI
222; Default Value: Off
223; Development Value: 4096
224; Production Value: 4096
225; https://php.net/output-buffering
226output_buffering = 4096
227
228; You can redirect all of the output of your scripts to a function. For
229; example, if you set output_handler to "mb_output_handler", character
230; encoding will be transparently converted to the specified encoding.
231; Setting any output handler automatically turns on output buffering.
232; Note: People who wrote portable scripts should not depend on this ini
233; directive. Instead, explicitly set the output handler using ob_start().
234; Using this ini directive may cause problems unless you know what script
235; is doing.
236; Note: You cannot use both "mb_output_handler" with "ob_iconv_handler"
237; and you cannot use both "ob_gzhandler" and "zlib.output_compression".
238; Note: output_handler must be empty if this is set 'On' !!!!
239; Instead you must use zlib.output_handler.
240; https://php.net/output-handler
241;output_handler =
242
243; URL rewriter function rewrites URL on the fly by using
244; output buffer. You can set target tags by this configuration.
245; "form" tag is special tag. It will add hidden input tag to pass values.
246; Refer to session.trans_sid_tags for usage.
247; Default Value: "form="
248; Development Value: "form="
249; Production Value: "form="
250;url_rewriter.tags
251
252; URL rewriter will not rewrite absolute URL nor form by default. To enable
253; absolute URL rewrite, allowed hosts must be defined at RUNTIME.
254; Refer to session.trans_sid_hosts for more details.
255; Default Value: ""
256; Development Value: ""
257; Production Value: ""
258;url_rewriter.hosts
259
260; Transparent output compression using the zlib library
261; Valid values for this option are 'off', 'on', or a specific buffer size
262; to be used for compression (default is 4KB)
263; Note: Resulting chunk size may vary due to nature of compression. PHP
264; outputs chunks that are few hundreds bytes each as a result of
265; compression. If you prefer a larger chunk size for better
266; performance, enable output_buffering in addition.
267; Note: You need to use zlib.output_handler instead of the standard
268; output_handler, or otherwise the output will be corrupted.
269; https://php.net/zlib.output-compression
270zlib.output_compression = Off
271
272; https://php.net/zlib.output-compression-level
273;zlib.output_compression_level = -1
274
275; You cannot specify additional output handlers if zlib.output_compression
276; is activated here. This setting does the same as output_handler but in
277; a different order.
278; https://php.net/zlib.output-handler
279;zlib.output_handler =
280
281; Implicit flush tells PHP to tell the output layer to flush itself
282; automatically after every output block. This is equivalent to calling the
283; PHP function flush() after each and every call to print() or echo() and each
284; and every HTML block. Turning this option on has serious performance
285; implications and is generally recommended for debugging purposes only.
286; https://php.net/implicit-flush
287; Note: This directive is hardcoded to On for the CLI SAPI
288implicit_flush = Off
289
290; The unserialize callback function will be called (with the undefined class'
291; name as parameter), if the unserializer finds an undefined class
292; which should be instantiated. A warning appears if the specified function is
293; not defined, or if the function doesn't include/implement the missing class.
294; So only set this entry, if you really want to implement such a
295; callback-function.
296unserialize_callback_func =
297
298; The unserialize_max_depth specifies the default depth limit for unserialized
299; structures. Setting the depth limit too high may result in stack overflows
300; during unserialization. The unserialize_max_depth ini setting can be
301; overridden by the max_depth option on individual unserialize() calls.
302; A value of 0 disables the depth limit.
303;unserialize_max_depth = 4096
304
305; When floats & doubles are serialized, store serialize_precision significant
306; digits after the floating point. The default value ensures that when floats
307; are decoded with unserialize, the data will remain the same.
308; The value is also used for json_encode when encoding double values.
309; If -1 is used, then dtoa mode 0 is used which automatically select the best
310; precision.
311serialize_precision = -1
312
313; open_basedir, if set, limits all file operations to the defined directory
314; and below. This directive makes most sense if used in a per-directory
315; or per-virtualhost web server configuration file.
316; Note: disables the realpath cache
317; https://php.net/open-basedir
318;open_basedir =
319
320; This directive allows you to disable certain functions.
321; It receives a comma-delimited list of function names.
322; https://php.net/disable-functions
323disable_functions =
324
325; Colors for Syntax Highlighting mode. Anything that's acceptable in
326; <span style="color: ???????"> would work.
327; https://php.net/syntax-highlighting
328;highlight.string = #DD0000
329;highlight.comment = #FF9900
330;highlight.keyword = #007700
331;highlight.default = #0000BB
332;highlight.html = #000000
333
334; If enabled, the request will be allowed to complete even if the user aborts
335; the request. Consider enabling it if executing long requests, which may end up
336; being interrupted by the user or a browser timing out. PHP's default behavior
337; is to disable this feature.
338; https://php.net/ignore-user-abort
339;ignore_user_abort = On
340
341; Determines the size of the realpath cache to be used by PHP. This value should
342; be increased on systems where PHP opens many files to reflect the quantity of
343; the file operations performed.
344; Note: if open_basedir is set, the cache is disabled
345; https://php.net/realpath-cache-size
346;realpath_cache_size = 4096k
347
348; Duration of time, in seconds for which to cache realpath information for a given
349; file or directory. For systems with rarely changing files, consider increasing this
350; value.
351; https://php.net/realpath-cache-ttl
352;realpath_cache_ttl = 120
353
354; Enables or disables the circular reference collector.
355; https://php.net/zend.enable-gc
356zend.enable_gc = On
357
358; If enabled, scripts may be written in encodings that are incompatible with
359; the scanner. CP936, Big5, CP949 and Shift_JIS are the examples of such
360; encodings. To use this feature, mbstring extension must be enabled.
361;zend.multibyte = Off
362
363; Allows to set the default encoding for the scripts. This value will be used
364; unless "declare(encoding=...)" directive appears at the top of the script.
365; Only affects if zend.multibyte is set.
366;zend.script_encoding =
367
368; Allows to include or exclude arguments from stack traces generated for exceptions.
369; In production, it is recommended to turn this setting on to prohibit the output
370; of sensitive information in stack traces
371; Default Value: Off
372; Development Value: Off
373; Production Value: On
374zend.exception_ignore_args = Off
375
376; Allows setting the maximum string length in an argument of a stringified stack trace
377; to a value between 0 and 1000000.
378; This has no effect when zend.exception_ignore_args is enabled.
379; Default Value: 15
380; Development Value: 15
381; Production Value: 0
382zend.exception_string_param_max_len = 15
383
384;;;;;;;;;;;;;;;;;
385; Miscellaneous ;
386;;;;;;;;;;;;;;;;;
387
388; Decides whether PHP may expose the fact that it is installed on the server
389; (e.g. by adding its signature to the Web server header). It is no security
390; threat in any way, but it makes it possible to determine whether you use PHP
391; on your server or not.
392; https://php.net/expose-php
393expose_php = On
394
395;;;;;;;;;;;;;;;;;;;
396; Resource Limits ;
397;;;;;;;;;;;;;;;;;;;
398
399; Maximum execution time of each script, in seconds
400; https://php.net/max-execution-time
401; Note: This directive is hardcoded to 0 for the CLI SAPI
402max_execution_time = 30
403
404; Maximum amount of time each script may spend parsing request data. It's a good
405; idea to limit this time on productions servers in order to eliminate unexpectedly
406; long running scripts.
407; Note: This directive is hardcoded to -1 for the CLI SAPI
408; Default Value: -1 (Unlimited)
409; Development Value: 60 (60 seconds)
410; Production Value: 60 (60 seconds)
411; https://php.net/max-input-time
412max_input_time = 60
413
414; Maximum input variable nesting level
415; https://php.net/max-input-nesting-level
416;max_input_nesting_level = 64
417
418; How many GET/POST/COOKIE input variables may be accepted
419;max_input_vars = 1000
420
421; How many multipart body parts (combined input variable and file uploads) may
422; be accepted.
423; Default Value: -1 (Sum of max_input_vars and max_file_uploads)
424;max_multipart_body_parts = 1500
425
426; Maximum amount of memory a script may consume
427; https://php.net/memory-limit
428memory_limit = 128M
429max_memory_limit = -1
430
431;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
432; Error handling and logging ;
433;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
434
435; This directive informs PHP of which errors, warnings and notices you would like
436; it to take action for. The recommended way of setting values for this
437; directive is through the use of the error level constants and bitwise
438; operators. The error level constants are below here for convenience as well as
439; some common settings and their meanings.
440; By default, PHP is set to take action on all errors, notices and warnings EXCEPT
441; those related to E_NOTICE, which together cover best practices and
442; recommended coding standards in PHP. For performance reasons, this is the
443; recommend error reporting setting. Your production server shouldn't be wasting
444; resources complaining about best practices and coding standards. That's what
445; development servers and development settings are for.
446; Note: The php.ini-development file has this setting as E_ALL. This
447; means it pretty much reports everything which is exactly what you want during
448; development and early testing.
449;
450; Error Level Constants:
451; E_ALL - All errors and warnings
452; E_ERROR - fatal run-time errors
453; E_RECOVERABLE_ERROR - almost fatal run-time errors
454; E_WARNING - run-time warnings (non-fatal errors)
455; E_PARSE - compile-time parse errors
456; E_NOTICE - run-time notices (these are warnings which often result
457; from a bug in your code, but it's possible that it was
458; intentional (e.g., using an uninitialized variable and
459; relying on the fact it is automatically initialized to an
460; empty string)
461; E_CORE_ERROR - fatal errors that occur during PHP's initial startup
462; E_CORE_WARNING - warnings (non-fatal errors) that occur during PHP's
463; initial startup
464; E_COMPILE_ERROR - fatal compile-time errors
465; E_COMPILE_WARNING - compile-time warnings (non-fatal errors)
466; E_USER_ERROR - user-generated error message
467; E_USER_WARNING - user-generated warning message
468; E_USER_NOTICE - user-generated notice message
469; E_DEPRECATED - warn about code that will not work in future versions
470; of PHP
471; E_USER_DEPRECATED - user-generated deprecation warnings
472;
473; Common Values:
474; E_ALL (Show all errors, warnings and notices including coding standards.)
475; E_ALL & ~E_NOTICE (Show all errors, except for notices)
476; E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR (Show only errors)
477; Default Value: E_ALL
478; Development Value: E_ALL
479; Production Value: E_ALL & ~E_DEPRECATED
480; https://php.net/error-reporting
481error_reporting = E_ALL
482
483; This directive controls whether or not and where PHP will output errors,
484; notices and warnings too. Error output is very useful during development, but
485; it could be very dangerous in production environments. Depending on the code
486; which is triggering the error, sensitive information could potentially leak
487; out of your application such as database usernames and passwords or worse.
488; For production environments, we recommend logging errors rather than
489; sending them to STDOUT.
490; Possible Values:
491; Off = Do not display any errors
492; stderr = Display errors to STDERR (affects only CGI/CLI binaries!)
493; On or stdout = Display errors to STDOUT
494; Default Value: On
495; Development Value: On
496; Production Value: Off
497; https://php.net/display-errors
498display_errors = On
499
500; The display of errors which occur during PHP's startup sequence are handled
501; separately from display_errors. We strongly recommend you set this to 'off'
502; for production servers to avoid leaking configuration details.
503; Default Value: On
504; Development Value: On
505; Production Value: Off
506; https://php.net/display-startup-errors
507display_startup_errors = On
508
509; Besides displaying errors, PHP can also log errors to locations such as a
510; server-specific log, STDERR, or a location specified by the error_log
511; directive found below. While errors should not be displayed on productions
512; servers they should still be monitored and logging is a great way to do that.
513; Default Value: Off
514; Development Value: On
515; Production Value: On
516; https://php.net/log-errors
517log_errors = On
518
519; Do not log repeated messages. Repeated errors must occur in same file on same
520; line unless ignore_repeated_source is set true.
521; https://php.net/ignore-repeated-errors
522ignore_repeated_errors = Off
523
524; Ignore source of message when ignoring repeated messages. When this setting
525; is On you will not log errors with repeated messages from different files or
526; source lines.
527; https://php.net/ignore-repeated-source
528ignore_repeated_source = Off
529
530; This setting is off by default.
531;report_zend_debug = 0
532
533; Turn off normal error reporting and emit XML-RPC error XML
534; https://php.net/xmlrpc-errors
535;xmlrpc_errors = 0
536
537; An XML-RPC faultCode
538;xmlrpc_error_number = 0
539
540; When PHP displays or logs an error, it has the capability of formatting the
541; error message as HTML for easier reading. This directive controls whether
542; the error message is formatted as HTML or not.
543; Note: This directive is hardcoded to Off for the CLI SAPI
544; https://php.net/html-errors
545;html_errors = On
546
547; If html_errors is set to On *and* docref_root is not empty, then PHP
548; produces clickable error messages that direct to a page describing the error
549; or function causing the error in detail.
550; You can download a copy of the PHP manual from https://php.net/docs
551; and change docref_root to the base URL of your local copy including the
552; leading '/'. You must also specify the file extension being used including
553; the dot. PHP's default behavior is to leave these settings empty, in which
554; case no links to documentation are generated.
555; Note: Never use this feature for production boxes.
556; https://php.net/docref-root
557; Examples
558;docref_root = "/phpmanual/"
559
560; https://php.net/docref-ext
561;docref_ext = .html
562
563; String to output before an error message. PHP's default behavior is to leave
564; this setting blank.
565; https://php.net/error-prepend-string
566; Example:
567;error_prepend_string = "<span style='color: #ff0000'>"
568
569; String to output after an error message. PHP's default behavior is to leave
570; this setting blank.
571; https://php.net/error-append-string
572; Example:
573;error_append_string = "</span>"
574
575; Log errors to specified file. PHP's default behavior is to leave this value
576; empty.
577; https://php.net/error-log
578; Example:
579;error_log = php_errors.log
580; Log errors to syslog (Event Log on Windows).
581;error_log = syslog
582
583; The syslog ident is a string which is prepended to every message logged
584; to syslog. Only used when error_log is set to syslog.
585;syslog.ident = php
586
587; The syslog facility is used to specify what type of program is logging
588; the message. Only used when error_log is set to syslog.
589;syslog.facility = user
590
591; Set this to disable filtering control characters (the default).
592; Some loggers only accept NVT-ASCII, others accept anything that's not
593; control characters. If your logger accepts everything, then no filtering
594; is needed at all.
595; Allowed values are:
596; ascii (all printable ASCII characters and NL)
597; no-ctrl (all characters except control characters)
598; all (all characters)
599; raw (like "all", but messages are not split at newlines)
600; https://php.net/syslog.filter
601;syslog.filter = ascii
602
603;windows.show_crt_warning
604; Default value: 0
605; Development value: 0
606; Production value: 0
607
608; This directive controls whether PHP will output the backtrace of fatal errors.
609; Default Value: On
610; Development Value: On
611; Production Value: On
612;fatal_error_backtraces = On
613
614;;;;;;;;;;;;;;;;;
615; Data Handling ;
616;;;;;;;;;;;;;;;;;
617
618; The separator used in PHP generated URLs to separate arguments.
619; PHP's default setting is "&".
620; https://php.net/arg-separator.output
621; Example:
622;arg_separator.output = "&"
623
624; List of separator(s) used by PHP to parse input URLs into variables.
625; PHP's default setting is "&".
626; NOTE: Every character in this directive is considered as separator!
627; https://php.net/arg-separator.input
628; Example:
629;arg_separator.input = ";&"
630
631; This directive determines which super global arrays are registered when PHP
632; starts up. G,P,C,E & S are abbreviations for the following respective super
633; globals: GET, POST, COOKIE, ENV and SERVER. There is a performance penalty
634; paid for the registration of these arrays and because ENV is not as commonly
635; used as the others, ENV is not recommended on productions servers. You
636; can still get access to the environment variables through getenv() should you
637; need to.
638; Default Value: "EGPCS"
639; Development Value: "GPCS"
640; Production Value: "GPCS";
641; https://php.net/variables-order
642variables_order = "GPCS"
643
644; This directive determines which super global data (G,P & C) should be
645; registered into the super global array REQUEST. If so, it also determines
646; the order in which that data is registered. The values for this directive
647; are specified in the same manner as the variables_order directive,
648; EXCEPT one. Leaving this value empty will cause PHP to use the value set
649; in the variables_order directive. It does not mean it will leave the super
650; globals array REQUEST empty.
651; Default Value: None
652; Development Value: "GP"
653; Production Value: "GP"
654; https://php.net/request-order
655request_order = "GP"
656
657; This directive determines whether PHP registers $argv & $argc each time it
658; runs. $argv contains an array of all the arguments passed to PHP when a script
659; is invoked. $argc contains an integer representing the number of arguments
660; that were passed when the script was invoked. These arrays are extremely
661; useful when running scripts from the command line. When this directive is
662; enabled, registering these variables consumes CPU cycles and memory each time
663; a script is executed. For security reasons, this feature should be disabled
664; for non-CLI SAPIs.
665; Note: This directive is ignored for the CLI SAPI
666; This directive is deprecated.
667; https://php.net/register-argc-argv
668;register_argc_argv = Off
669
670; When enabled, the ENV, REQUEST and SERVER variables are created when they're
671; first used (Just In Time) instead of when the script starts. If these
672; variables are not used within a script, having this directive on will result
673; in a performance gain. The PHP directive register_argc_argv must be disabled
674; for this directive to have any effect.
675; https://php.net/auto-globals-jit
676auto_globals_jit = On
677
678; Whether PHP will read the POST data.
679; This option is enabled by default.
680; Most likely, you won't want to disable this option globally. It causes $_POST
681; and $_FILES to always be empty; the only way you will be able to read the
682; POST data will be through the php://input stream wrapper. This can be useful
683; to proxy requests or to process the POST data in a memory efficient fashion.
684; https://php.net/enable-post-data-reading
685;enable_post_data_reading = Off
686
687; Maximum size of POST data that PHP will accept.
688; Its value may be 0 to disable the limit. It is ignored if POST data reading
689; is disabled through enable_post_data_reading.
690; https://php.net/post-max-size
691post_max_size = 8M
692
693; Automatically add files before PHP document.
694; https://php.net/auto-prepend-file
695auto_prepend_file =
696
697; Automatically add files after PHP document.
698; https://php.net/auto-append-file
699auto_append_file =
700
701; By default, PHP will output a media type using the Content-Type header. To
702; disable this, simply set it to be empty.
703;
704; PHP's built-in default media type is set to text/html.
705; https://php.net/default-mimetype
706default_mimetype = "text/html"
707
708; PHP's default character set is set to UTF-8.
709; https://php.net/default-charset
710default_charset = "UTF-8"
711
712; PHP internal character encoding is set to empty.
713; If empty, default_charset is used.
714; https://php.net/internal-encoding
715;internal_encoding =
716
717; PHP input character encoding is set to empty.
718; If empty, default_charset is used.
719; https://php.net/input-encoding
720;input_encoding =
721
722; PHP output character encoding is set to empty.
723; If empty, default_charset is used.
724; See also output_buffer.
725; https://php.net/output-encoding
726;output_encoding =
727
728;;;;;;;;;;;;;;;;;;;;;;;;;
729; Paths and Directories ;
730;;;;;;;;;;;;;;;;;;;;;;;;;
731
732; UNIX: "/path1:/path2"
733;include_path = ".:/php/includes"
734;
735; Windows: "\path1;\path2"
736;include_path = ".;c:\php\includes"
737;
738; PHP's default setting for include_path is ".;/path/to/php/pear"
739; https://php.net/include-path
740
741; The root of the PHP pages, used only if nonempty.
742; if PHP was not compiled with FORCE_REDIRECT, you SHOULD set doc_root
743; if you are running php as a CGI under any web server (other than IIS)
744; see documentation for security issues. The alternate is to use the
745; cgi.force_redirect configuration below
746; https://php.net/doc-root
747doc_root =
748
749; The directory under which PHP opens the script using /~username used only
750; if nonempty.
751; https://php.net/user-dir
752user_dir =
753
754; Directory in which the loadable extensions (modules) reside.
755; https://php.net/extension-dir
756;extension_dir = "./"
757; On windows:
758;extension_dir = "ext"
759
760; Directory where the temporary files should be placed.
761; Defaults to the system default (see sys_get_temp_dir)
762;sys_temp_dir = "/tmp"
763
764; Whether or not to enable the dl() function. The dl() function does NOT work
765; properly in multithreaded servers, such as IIS or Zeus, and is automatically
766; disabled on them.
767; https://php.net/enable-dl
768enable_dl = Off
769
770; cgi.force_redirect is necessary to provide security running PHP as a CGI under
771; most web servers. Left undefined, PHP turns this on by default. You can
772; turn it off here AT YOUR OWN RISK
773; **You CAN safely turn this off for IIS, in fact, you MUST.**
774; https://php.net/cgi.force-redirect
775;cgi.force_redirect = 1
776
777; if cgi.nph is enabled it will force cgi to always sent Status: 200 with
778; every request. PHP's default behavior is to disable this feature.
779;cgi.nph = 1
780
781; if cgi.force_redirect is turned on, and you are not running under Apache or Netscape
782; (iPlanet) web servers, you MAY need to set an environment variable name that PHP
783; will look for to know it is OK to continue execution. Setting this variable MAY
784; cause security issues, KNOW WHAT YOU ARE DOING FIRST.
785; https://php.net/cgi.redirect-status-env
786;cgi.redirect_status_env =
787
788; cgi.fix_pathinfo provides *real* PATH_INFO/PATH_TRANSLATED support for CGI. PHP's
789; previous behaviour was to set PATH_TRANSLATED to SCRIPT_FILENAME, and to not grok
790; what PATH_INFO is. For more information on PATH_INFO, see the cgi specs. Setting
791; this to 1 will cause PHP CGI to fix its paths to conform to the spec. A setting
792; of zero causes PHP to behave as before. Default is 1. You should fix your scripts
793; to use SCRIPT_FILENAME rather than PATH_TRANSLATED.
794; https://php.net/cgi.fix-pathinfo
795;cgi.fix_pathinfo=1
796
797; if cgi.discard_path is enabled, the PHP CGI binary can safely be placed outside
798; of the web tree and people will not be able to circumvent .htaccess security.
799;cgi.discard_path=1
800
801; FastCGI under IIS supports the ability to impersonate
802; security tokens of the calling client. This allows IIS to define the
803; security context that the request runs under. mod_fastcgi under Apache
804; does not currently support this feature (03/17/2002)
805; Set to 1 if running under IIS. Default is zero.
806; https://php.net/fastcgi.impersonate
807;fastcgi.impersonate = 1
808
809; Prevent decoding of SCRIPT_FILENAME when using Apache ProxyPass or
810; ProxyPassMatch. This should be used if script file paths are not stored
811; in an encoded format on the file system.
812; Default is 1.
813;fastcgi.script_path_encoded = 0
814
815; Disable logging through FastCGI connection. PHP's default behavior is to enable
816; this feature.
817;fastcgi.logging = 0
818
819; cgi.rfc2616_headers configuration option tells PHP what type of headers to
820; use when sending HTTP response code. If set to 0, PHP sends Status: header that
821; is supported by Apache. When this option is set to 1, PHP will send
822; RFC2616 compliant header.
823; Default is zero.
824; https://php.net/cgi.rfc2616-headers
825;cgi.rfc2616_headers = 0
826
827; cgi.check_shebang_line controls whether CGI PHP checks for line starting with #!
828; (shebang) at the top of the running script. This line might be needed if the
829; script support running both as stand-alone script and via PHP CGI<. PHP in CGI
830; mode skips this line and ignores its content if this directive is turned on.
831; https://php.net/cgi.check-shebang-line
832;cgi.check_shebang_line=1
833
834;;;;;;;;;;;;;;;;
835; File Uploads ;
836;;;;;;;;;;;;;;;;
837
838; Whether to allow HTTP file uploads.
839; https://php.net/file-uploads
840file_uploads = On
841
842; Temporary directory for HTTP uploaded files (will use system default if not
843; specified).
844; https://php.net/upload-tmp-dir
845;upload_tmp_dir =
846
847; Maximum allowed size for uploaded files.
848; https://php.net/upload-max-filesize
849upload_max_filesize = 2M
850
851; Maximum number of files that can be uploaded via a single request
852max_file_uploads = 20
853
854;;;;;;;;;;;;;;;;;;
855; Fopen wrappers ;
856;;;;;;;;;;;;;;;;;;
857
858; Whether to allow the treatment of URLs (like http:// or ftp://) as files.
859; https://php.net/allow-url-fopen
860allow_url_fopen = On
861
862; Whether to allow include/require to open URLs (like https:// or ftp://) as files.
863; https://php.net/allow-url-include
864allow_url_include = Off
865
866; Define the anonymous ftp password (your email address). PHP's default setting
867; for this is empty.
868; https://php.net/from
869;from="john@doe.com"
870
871; Define the User-Agent string. PHP's default setting for this is empty.
872; https://php.net/user-agent
873;user_agent="PHP"
874
875; Default timeout for socket based streams (seconds)
876; https://php.net/default-socket-timeout
877default_socket_timeout = 60
878
879; If your scripts have to deal with files from Macintosh systems,
880; or you are running on a Mac and need to deal with files from
881; unix or win32 systems, setting this flag will cause PHP to
882; automatically detect the EOL character in those files so that
883; fgets() and file() will work regardless of the source of the file.
884; https://php.net/auto-detect-line-endings
885;auto_detect_line_endings = Off
886
887;;;;;;;;;;;;;;;;;;;;;;
888; Dynamic Extensions ;
889;;;;;;;;;;;;;;;;;;;;;;
890
891; If you wish to have an extension loaded automatically, use the following
892; syntax:
893;
894; extension=modulename
895;
896; For example:
897;
898; extension=mysqli
899;
900; When the extension library to load is not located in the default extension
901; directory, You may specify an absolute path to the library file:
902;
903; extension=/path/to/extension/mysqli.so
904;
905; Note : The syntax used in previous PHP versions ('extension=<ext>.so' and
906; 'extension='php_<ext>.dll') is supported for legacy reasons and may be
907; deprecated in a future PHP major version. So, when it is possible, please
908; move to the new ('extension=<ext>) syntax.
909;
910; Notes for Windows environments :
911;
912; - Many DLL files are located in the ext/
913; extension folders as well as the separate PECL DLL download.
914; Be sure to appropriately set the extension_dir directive.
915;
916;extension=bz2
917;extension=curl
918;extension=exif
919;extension=ffi
920;extension=ftp
921;extension=fileinfo
922;extension=gd
923;extension=gettext
924;extension=gmp
925;extension=intl
926;extension=ldap
927;extension=mbstring
928;extension=mysqli
929;extension=odbc
930;extension=openssl
931;extension=pdo_firebird
932;extension=pdo_mysql
933;extension=pdo_odbc
934;extension=pdo_pgsql
935;extension=pdo_sqlite
936;extension=pgsql
937;extension=shmop
938
939; The MIBS data available in the PHP distribution must be installed.
940; See https://www.php.net/manual/en/snmp.installation.php
941;extension=snmp
942
943;extension=soap
944;extension=sockets
945;extension=sodium
946;extension=sqlite3
947;extension=tidy
948;extension=xsl
949;extension=zip
950
951;;;;;;;;;;;;;;;;;;;
952; Module Settings ;
953;;;;;;;;;;;;;;;;;;;
954
955[CLI Server]
956; Whether the CLI web server uses ANSI color coding in its terminal output.
957cli_server.color = On
958
959[Date]
960; Defines the default timezone used by the date functions
961; https://php.net/date.timezone
962;date.timezone =
963
964; https://php.net/date.default-latitude
965;date.default_latitude = 31.7667
966
967; https://php.net/date.default-longitude
968;date.default_longitude = 35.2333
969
970; https://php.net/date.sunrise-zenith
971;date.sunrise_zenith = 90.833333
972
973; https://php.net/date.sunset-zenith
974;date.sunset_zenith = 90.833333
975
976[filter]
977; https://php.net/filter.default
978;filter.default = unsafe_raw
979
980; https://php.net/filter.default-flags
981;filter.default_flags =
982
983[iconv]
984; Use of this INI entry is deprecated, use global input_encoding instead.
985; If empty, default_charset or input_encoding or iconv.input_encoding is used.
986; The precedence is: default_charset < input_encoding < iconv.input_encoding
987;iconv.input_encoding =
988
989; Use of this INI entry is deprecated, use global internal_encoding instead.
990; If empty, default_charset or internal_encoding or iconv.internal_encoding is used.
991; The precedence is: default_charset < internal_encoding < iconv.internal_encoding
992;iconv.internal_encoding =
993
994; Use of this INI entry is deprecated, use global output_encoding instead.
995; If empty, default_charset or output_encoding or iconv.output_encoding is used.
996; The precedence is: default_charset < output_encoding < iconv.output_encoding
997; To use an output encoding conversion, iconv's output handler must be set
998; otherwise output encoding conversion cannot be performed.
999;iconv.output_encoding =
1000
1001[intl]
1002;intl.default_locale =
1003; This directive allows you to produce PHP errors when some error
1004; happens within intl functions. The value is the level of the error produced.
1005; Default is 0, which does not produce any errors.
1006; This directive is deprecated.
1007;intl.error_level = E_WARNING
1008; If enabled this directive indicates that when an error occurs within an
1009; intl function a IntlException should be thrown.
1010; Default is Off, which means errors need to be handled manually.
1011;intl.use_exceptions = On
1012
1013[sqlite3]
1014; Directory pointing to SQLite3 extensions
1015; https://php.net/sqlite3.extension-dir
1016;sqlite3.extension_dir =
1017
1018; SQLite defensive mode flag (only available from SQLite 3.26+)
1019; When the defensive flag is enabled, language features that allow ordinary
1020; SQL to deliberately corrupt the database file are disabled. This forbids
1021; writing directly to the schema, shadow tables (eg. FTS data tables), or
1022; the sqlite_dbpage virtual table.
1023; https://www.sqlite.org/c3ref/c_dbconfig_defensive.html
1024; (for older SQLite versions, this flag has no use)
1025;sqlite3.defensive = 1
1026
1027[Pcre]
1028; PCRE library backtracking limit.
1029; https://php.net/pcre.backtrack-limit
1030;pcre.backtrack_limit=100000
1031
1032; PCRE library recursion limit.
1033; Please note that if you set this value to a high number you may consume all
1034; the available process stack and eventually crash PHP (due to reaching the
1035; stack size limit imposed by the Operating System).
1036; https://php.net/pcre.recursion-limit
1037;pcre.recursion_limit=100000
1038
1039; Enables or disables JIT compilation of patterns. This requires the PCRE
1040; library to be compiled with JIT support.
1041;pcre.jit=1
1042
1043[Pdo]
1044; Whether to pool ODBC connections. Can be one of "strict", "relaxed" or "off"
1045; https://php.net/pdo-odbc.connection-pooling
1046;pdo_odbc.connection_pooling=strict
1047
1048[Pdo_mysql]
1049; Default socket name for local MySQL connects. If empty, uses the built-in
1050; MySQL defaults.
1051pdo_mysql.default_socket=
1052
1053[Phar]
1054; https://php.net/phar.readonly
1055;phar.readonly = On
1056
1057; https://php.net/phar.require-hash
1058;phar.require_hash = On
1059
1060;phar.cache_list =
1061
1062[mail function]
1063; For Win32 only.
1064; https://php.net/smtp
1065SMTP = localhost
1066; https://php.net/smtp-port
1067smtp_port = 25
1068
1069; For Win32 only.
1070; https://php.net/sendmail-from
1071;sendmail_from = me@example.com
1072
1073; For Unix only. You may supply arguments as well (default: "sendmail -t -i").
1074; https://php.net/sendmail-path
1075;sendmail_path =
1076
1077; Force the addition of the specified parameters to be passed as extra parameters
1078; to the sendmail binary. These parameters will always replace the value of
1079; the 5th parameter to mail().
1080;mail.force_extra_parameters =
1081
1082; Add X-PHP-Originating-Script: that will include uid of the script followed by the filename
1083mail.add_x_header = Off
1084
1085; Use mixed LF and CRLF line separators to keep compatibility with some
1086; RFC 2822 non conformant MTA.
1087mail.mixed_lf_and_crlf = Off
1088
1089; Control line ending mode for mail messages and headers.
1090; Possible values: "crlf" (default), "lf", "mixed", "os"
1091; - crlf: Use CRLF line endings
1092; - lf: Use LF line endings only (converts CRLF in message to LF)
1093; - mixed: Same as mail.mixed_lf_and_crlf = On
1094; - os: Use CRLF on Windows, LF on other systems
1095mail.cr_lf_mode = crlf
1096
1097; The path to a log file that will log all mail() calls. Log entries include
1098; the full path of the script, line number, To address and headers.
1099;mail.log =
1100; Log mail to syslog (Event Log on Windows).
1101;mail.log = syslog
1102
1103[ODBC]
1104; https://php.net/odbc.default-db
1105;odbc.default_db = Not yet implemented
1106
1107; https://php.net/odbc.default-user
1108;odbc.default_user = Not yet implemented
1109
1110; https://php.net/odbc.default-pw
1111;odbc.default_pw = Not yet implemented
1112
1113; Controls the ODBC cursor model.
1114; Default: SQL_CURSOR_STATIC (default).
1115;odbc.default_cursortype
1116
1117; Allow or prevent persistent links.
1118; https://php.net/odbc.allow-persistent
1119odbc.allow_persistent = On
1120
1121; Check that a connection is still valid before reuse.
1122; https://php.net/odbc.check-persistent
1123odbc.check_persistent = On
1124
1125; Maximum number of persistent links. -1 means no limit.
1126; https://php.net/odbc.max-persistent
1127odbc.max_persistent = -1
1128
1129; Maximum number of links (persistent + non-persistent). -1 means no limit.
1130; https://php.net/odbc.max-links
1131odbc.max_links = -1
1132
1133; Handling of LONG fields. Returns number of bytes to variables. 0 means
1134; passthru.
1135; https://php.net/odbc.defaultlrl
1136odbc.defaultlrl = 4096
1137
1138; Handling of binary data. 0 means passthru, 1 return as is, 2 convert to char.
1139; See the documentation on odbc_binmode and odbc_longreadlen for an explanation
1140; of odbc.defaultlrl and odbc.defaultbinmode
1141; https://php.net/odbc.defaultbinmode
1142odbc.defaultbinmode = 1
1143
1144[MySQLi]
1145
1146; Maximum number of persistent links. -1 means no limit.
1147; https://php.net/mysqli.max-persistent
1148mysqli.max_persistent = -1
1149
1150; Allow accessing, from PHP's perspective, local files with LOAD DATA statements
1151; https://php.net/mysqli.allow_local_infile
1152;mysqli.allow_local_infile = On
1153
1154; It allows the user to specify a folder where files that can be sent via LOAD DATA
1155; LOCAL can exist. It is ignored if mysqli.allow_local_infile is enabled.
1156;mysqli.local_infile_directory =
1157
1158; Allow or prevent persistent links.
1159; https://php.net/mysqli.allow-persistent
1160mysqli.allow_persistent = On
1161
1162; Maximum number of links. -1 means no limit.
1163; https://php.net/mysqli.max-links
1164mysqli.max_links = -1
1165
1166; Default port number for mysqli_connect().
1167; https://php.net/mysqli.default-port
1168mysqli.default_port = 3306
1169
1170; Default socket name for local MySQL connects. If empty, uses the built-in
1171; MySQL defaults.
1172; https://php.net/mysqli.default-socket
1173mysqli.default_socket =
1174
1175; Default host for mysqli_connect().
1176; https://php.net/mysqli.default-host
1177mysqli.default_host =
1178
1179; Default user for mysqli_connect().
1180; https://php.net/mysqli.default-user
1181mysqli.default_user =
1182
1183; Default password for mysqli_connect().
1184; Note that this is generally a *bad* idea to store passwords in this file.
1185; *Any* user with PHP access can run 'echo get_cfg_var("mysqli.default_pw")
1186; and reveal this password! And of course, any users with read access to this
1187; file will be able to reveal the password as well.
1188; https://php.net/mysqli.default-pw
1189mysqli.default_pw =
1190
1191; If this option is enabled, closing a persistent connection will rollback
1192; any pending transactions of this connection, before it is put back
1193; into the persistent connection pool.
1194;mysqli.rollback_on_cached_plink = Off
1195
1196[mysqlnd]
1197; Enable / Disable collection of general statistics by mysqlnd which can be
1198; used to tune and monitor MySQL operations.
1199mysqlnd.collect_statistics = On
1200