WordPress.org
Get WordPress

Make WordPress Core

Ticket #57553: load.php

File load.php, 49.9 KB (added by mahbubmr500, 4 years ago)

Ticket track: https://core.trac.wordpress.org/ticket/57553

Line 
1<?php
2/**
3 * These functions are needed to load WordPress.
4 *
5 * @package WordPress
6 */
7
8/**
9 * Return the HTTP protocol sent by the server.
10 *
11 * @since 4.4.0
12 *
13 * @return string The HTTP protocol. Default: HTTP/1.0.
14 */
15function wp_get_server_protocol() {
16 $protocol = isset( $_SERVER['SERVER_PROTOCOL'] ) ? $_SERVER['SERVER_PROTOCOL'] : '';
17 if ( ! in_array( $protocol, array( 'HTTP/1.1', 'HTTP/2', 'HTTP/2.0', 'HTTP/3' ), true ) ) {
18 $protocol = 'HTTP/1.0';
19 }
20 return $protocol;
21}
22
23/**
24 * Fix `$_SERVER` variables for various setups.
25 *
26 * @since 3.0.0
27 * @access private
28 *
29 * @global string $PHP_SELF The filename of the currently executing script,
30 * relative to the document root.
31 */
32function wp_fix_server_vars() {
33 global $PHP_SELF;
34
35 $default_server_values = array(
36 'SERVER_SOFTWARE' => '',
37 'REQUEST_URI' => '',
38 );
39
40 $_SERVER = array_merge( $default_server_values, $_SERVER );
41
42 // Fix for IIS when running with PHP ISAPI.
43 if ( empty( $_SERVER['REQUEST_URI'] ) || ( 'cgi-fcgi' !== PHP_SAPI && preg_match( '/^Microsoft-IIS\//', $_SERVER['SERVER_SOFTWARE'] ) ) ) {
44
45 if ( isset( $_SERVER['HTTP_X_ORIGINAL_URL'] ) ) {
46 // IIS Mod-Rewrite.
47 $_SERVER['REQUEST_URI'] = $_SERVER['HTTP_X_ORIGINAL_URL'];
48 } elseif ( isset( $_SERVER['HTTP_X_REWRITE_URL'] ) ) {
49 // IIS Isapi_Rewrite.
50 $_SERVER['REQUEST_URI'] = $_SERVER['HTTP_X_REWRITE_URL'];
51 } else {
52 // Use ORIG_PATH_INFO if there is no PATH_INFO.
53 if ( ! isset( $_SERVER['PATH_INFO'] ) && isset( $_SERVER['ORIG_PATH_INFO'] ) ) {
54 $_SERVER['PATH_INFO'] = $_SERVER['ORIG_PATH_INFO'];
55 }
56
57 // Some IIS + PHP configurations put the script-name in the path-info (no need to append it twice).
58 if ( isset( $_SERVER['PATH_INFO'] ) ) {
59 if ( $_SERVER['PATH_INFO'] == $_SERVER['SCRIPT_NAME'] ) {
60 $_SERVER['REQUEST_URI'] = $_SERVER['PATH_INFO'];
61 } else {
62 $_SERVER['REQUEST_URI'] = $_SERVER['SCRIPT_NAME'] . $_SERVER['PATH_INFO'];
63 }
64 }
65
66 // Append the query string if it exists and isn't null.
67 if ( ! empty( $_SERVER['QUERY_STRING'] ) ) {
68 $_SERVER['REQUEST_URI'] .= '?' . $_SERVER['QUERY_STRING'];
69 }
70 }
71 }
72
73 // Fix for PHP as CGI hosts that set SCRIPT_FILENAME to something ending in php.cgi for all requests.
74 if ( isset( $_SERVER['SCRIPT_FILENAME'] ) && ( strpos( $_SERVER['SCRIPT_FILENAME'], 'php.cgi' ) == strlen( $_SERVER['SCRIPT_FILENAME'] ) - 7 ) ) {
75 $_SERVER['SCRIPT_FILENAME'] = $_SERVER['PATH_TRANSLATED'];
76 }
77
78 // Fix for Dreamhost and other PHP as CGI hosts.
79 if ( isset( $_SERVER['SCRIPT_NAME'] ) && ( strpos( $_SERVER['SCRIPT_NAME'], 'php.cgi' ) !== false ) ) {
80 unset( $_SERVER['PATH_INFO'] );
81 }
82
83 // Fix empty PHP_SELF.
84 $PHP_SELF = $_SERVER['PHP_SELF'];
85 if ( empty( $PHP_SELF ) ) {
86 $_SERVER['PHP_SELF'] = preg_replace( '/(\?.*)?$/', '', $_SERVER['REQUEST_URI'] );
87 $PHP_SELF = $_SERVER['PHP_SELF'];
88 }
89
90 wp_populate_basic_auth_from_authorization_header();
91}
92
93/**
94 * Populates the Basic Auth server details from the Authorization header.
95 *
96 * Some servers running in CGI or FastCGI mode don't pass the Authorization
97 * header on to WordPress. If it's been rewritten to the `HTTP_AUTHORIZATION` header,
98 * fill in the proper $_SERVER variables instead.
99 *
100 * @since 5.6.0
101 */
102function wp_populate_basic_auth_from_authorization_header() {
103 // If we don't have anything to pull from, return early.
104 if ( ! isset( $_SERVER['HTTP_AUTHORIZATION'] ) && ! isset( $_SERVER['REDIRECT_HTTP_AUTHORIZATION'] ) ) {
105 return;
106 }
107
108 // If either PHP_AUTH key is already set, do nothing.
109 if ( isset( $_SERVER['PHP_AUTH_USER'] ) || isset( $_SERVER['PHP_AUTH_PW'] ) ) {
110 return;
111 }
112
113 // From our prior conditional, one of these must be set.
114 $header = isset( $_SERVER['HTTP_AUTHORIZATION'] ) ? $_SERVER['HTTP_AUTHORIZATION'] : $_SERVER['REDIRECT_HTTP_AUTHORIZATION'];
115
116 // Test to make sure the pattern matches expected.
117 if ( ! preg_match( '%^Basic [a-z\d/+]*={0,2}$%i', $header ) ) {
118 return;
119 }
120
121 // Removing `Basic ` the token would start six characters in.
122 $token = substr( $header, 6 );
123 $userpass = base64_decode( $token );
124
125 list( $user, $pass ) = explode( ':', $userpass );
126
127 // Now shove them in the proper keys where we're expecting later on.
128 $_SERVER['PHP_AUTH_USER'] = $user;
129 $_SERVER['PHP_AUTH_PW'] = $pass;
130}
131
132/**
133 * Check for the required PHP version, and the MySQL extension or
134 * a database drop-in.
135 *
136 * Dies if requirements are not met.
137 *
138 * @since 3.0.0
139 * @access private
140 *
141 * @global string $required_php_version The required PHP version string.
142 * @global string $wp_version The WordPress version string.
143 */
144function wp_check_php_mysql_versions() {
145 global $required_php_version, $wp_version;
146 $php_version = PHP_VERSION;
147
148 if ( version_compare( $required_php_version, $php_version, '>' ) ) {
149 $protocol = wp_get_server_protocol();
150 header( sprintf( '%s 500 Internal Server Error', $protocol ), true, 500 );
151 header( 'Content-Type: text/html; charset=utf-8' );
152 printf( 'Your server is running PHP version %1$s but WordPress %2$s requires at least %3$s.', $php_version, $wp_version, $required_php_version );
153 exit( 1 );
154 }
155
156 if ( ! extension_loaded( 'mysql' ) && ! extension_loaded( 'mysqli' ) && ! extension_loaded( 'mysqlnd' )
157 // This runs before default constants are defined, so we can't assume WP_CONTENT_DIR is set yet.
158 && ( defined( 'WP_CONTENT_DIR' ) && ! file_exists( WP_CONTENT_DIR . '/db.php' )
159 || ! file_exists( ABSPATH . 'wp-content/db.php' ) )
160 ) {
161 require_once ABSPATH . WPINC . '/functions.php';
162 wp_load_translations_early();
163 $args = array(
164 'exit' => false,
165 'code' => 'mysql_not_found',
166 );
167 wp_die(
168 __( 'Your PHP installation appears to be missing the MySQL extension which is required by WordPress.' ),
169 __( 'Requirements Not Met' ),
170 $args
171 );
172 exit( 1 );
173 }
174}
175
176/**
177 * Retrieves the current environment type.
178 *
179 * The type can be set via the `WP_ENVIRONMENT_TYPE` global system variable,
180 * or a constant of the same name.
181 *
182 * Possible values are 'local', 'development', 'staging', and 'production'.
183 * If not set, the type defaults to 'production'.
184 *
185 * @since 5.5.0
186 * @since 5.5.1 Added the 'local' type.
187 * @since 5.5.1 Removed the ability to alter the list of types.
188 *
189 * @return string The current environment type.
190 */
191function wp_get_environment_type() {
192 static $current_env = '';
193
194 if ( ! defined( 'WP_RUN_CORE_TESTS' ) && $current_env ) {
195 return $current_env;
196 }
197
198 $wp_environments = array(
199 'local',
200 'development',
201 'staging',
202 'production',
203 );
204
205 // Add a note about the deprecated WP_ENVIRONMENT_TYPES constant.
206 if ( defined( 'WP_ENVIRONMENT_TYPES' ) && function_exists( '_deprecated_argument' ) ) {
207 if ( function_exists( '__' ) ) {
208 /* translators: %s: WP_ENVIRONMENT_TYPES */
209 $message = sprintf( __( 'The %s constant is no longer supported.' ), 'WP_ENVIRONMENT_TYPES' );
210 } else {
211 $message = sprintf( 'The %s constant is no longer supported.', 'WP_ENVIRONMENT_TYPES' );
212 }
213
214 _deprecated_argument(
215 'define()',
216 '5.5.1',
217 $message
218 );
219 }
220
221 // Check if the environment variable has been set, if `getenv` is available on the system.
222 if ( function_exists( 'getenv' ) ) {
223 $has_env = getenv( 'WP_ENVIRONMENT_TYPE' );
224 if ( false !== $has_env ) {
225 $current_env = $has_env;
226 }
227 }
228
229 // Fetch the environment from a constant, this overrides the global system variable.
230 if ( defined( 'WP_ENVIRONMENT_TYPE' ) && WP_ENVIRONMENT_TYPE ) {
231 $current_env = WP_ENVIRONMENT_TYPE;
232 }
233
234 // Make sure the environment is an allowed one, and not accidentally set to an invalid value.
235 if ( ! in_array( $current_env, $wp_environments, true ) ) {
236 $current_env = 'production';
237 }
238
239 return $current_env;
240}
241
242/**
243 * Don't load all of WordPress when handling a favicon.ico request.
244 *
245 * Instead, send the headers for a zero-length favicon and bail.
246 *
247 * @since 3.0.0
248 * @deprecated 5.4.0 Deprecated in favor of do_favicon().
249 */
250function wp_favicon_request() {
251 if ( '/favicon.ico' === $_SERVER['REQUEST_URI'] ) {
252 header( 'Content-Type: image/vnd.microsoft.icon' );
253 exit;
254 }
255}
256
257/**
258 * Die with a maintenance message when conditions are met.
259 *
260 * The default message can be replaced by using a drop-in (maintenance.php in
261 * the wp-content directory).
262 *
263 * @since 3.0.0
264 * @access private
265 */
266function wp_maintenance() {
267 // Return if maintenance mode is disabled.
268 if ( ! wp_is_maintenance_mode() ) {
269 return;
270 }
271
272 if ( file_exists( WP_CONTENT_DIR . '/maintenance.php' ) ) {
273 require_once WP_CONTENT_DIR . '/maintenance.php';
274 die();
275 }
276
277 require_once ABSPATH . WPINC . '/functions.php';
278 wp_load_translations_early();
279
280 header( 'Retry-After: 600' );
281
282 wp_die(
283 __( 'Briefly unavailable for scheduled maintenance. Check back in a minute.' ),
284 __( 'Maintenance' ),
285 503
286 );
287}
288
289/**
290 * Check if maintenance mode is enabled.
291 *
292 * Checks for a file in the WordPress root directory named ".maintenance".
293 * This file will contain the variable $upgrading, set to the time the file
294 * was created. If the file was created less than 10 minutes ago, WordPress
295 * is in maintenance mode.
296 *
297 * @since 5.5.0
298 *
299 * @global int $upgrading The Unix timestamp marking when upgrading WordPress began.
300 *
301 * @return bool True if maintenance mode is enabled, false otherwise.
302 */
303function wp_is_maintenance_mode() {
304 global $upgrading;
305
306 if ( ! file_exists( ABSPATH . '.maintenance' ) || wp_installing() ) {
307 return false;
308 }
309
310 require ABSPATH . '.maintenance';
311 // If the $upgrading timestamp is older than 10 minutes, consider maintenance over.
312 if ( ( time() - $upgrading ) >= 10 * MINUTE_IN_SECONDS ) {
313 return false;
314 }
315
316 /**
317 * Filters whether to enable maintenance mode.
318 *
319 * This filter runs before it can be used by plugins. It is designed for
320 * non-web runtimes. If this filter returns true, maintenance mode will be
321 * active and the request will end. If false, the request will be allowed to
322 * continue processing even if maintenance mode should be active.
323 *
324 * @since 4.6.0
325 *
326 * @param bool $enable_checks Whether to enable maintenance mode. Default true.
327 * @param int $upgrading The timestamp set in the .maintenance file.
328 */
329 if ( ! apply_filters( 'enable_maintenance_mode', true, $upgrading ) ) {
330 return false;
331 }
332
333 return true;
334}
335
336/**
337 * Get the time elapsed so far during this PHP script.
338 *
339 * Uses REQUEST_TIME_FLOAT that appeared in PHP 5.4.0.
340 *
341 * @since 5.8.0
342 *
343 * @return float Seconds since the PHP script started.
344 */
345function timer_float() {
346 return microtime( true ) - $_SERVER['REQUEST_TIME_FLOAT'];
347}
348
349/**
350 * Start the WordPress micro-timer.
351 *
352 * @since 0.71
353 * @access private
354 *
355 * @global float $timestart Unix timestamp set at the beginning of the page load.
356 * @see timer_stop()
357 *
358 * @return bool Always returns true.
359 */
360function timer_start() {
361 global $timestart;
362 $timestart = microtime( true );
363 return true;
364}
365
366/**
367 * Retrieve or display the time from the page start to when function is called.
368 *
369 * @since 0.71
370 *
371 * @global float $timestart Seconds from when timer_start() is called.
372 * @global float $timeend Seconds from when function is called.
373 *
374 * @param int|bool $display Whether to echo or return the results. Accepts 0|false for return,
375 * 1|true for echo. Default 0|false.
376 * @param int $precision The number of digits from the right of the decimal to display.
377 * Default 3.
378 * @return string The "second.microsecond" finished time calculation. The number is formatted
379 * for human consumption, both localized and rounded.
380 */
381function timer_stop( $display = 0, $precision = 3 ) {
382 global $timestart, $timeend;
383 $timeend = microtime( true );
384 $timetotal = $timeend - $timestart;
385 $r = ( function_exists( 'number_format_i18n' ) ) ? number_format_i18n( $timetotal, $precision ) : number_format( $timetotal, $precision );
386 if ( $display ) {
387 echo $r;
388 }
389 return $r;
390}
391
392/**
393 * Set PHP error reporting based on WordPress debug settings.
394 *
395 * Uses three constants: `WP_DEBUG`, `WP_DEBUG_DISPLAY`, and `WP_DEBUG_LOG`.
396 * All three can be defined in wp-config.php. By default, `WP_DEBUG` and
397 * `WP_DEBUG_LOG` are set to false, and `WP_DEBUG_DISPLAY` is set to true.
398 *
399 * When `WP_DEBUG` is true, all PHP notices are reported. WordPress will also
400 * display internal notices: when a deprecated WordPress function, function
401 * argument, or file is used. Deprecated code may be removed from a later
402 * version.
403 *
404 * It is strongly recommended that plugin and theme developers use `WP_DEBUG`
405 * in their development environments.
406 *
407 * `WP_DEBUG_DISPLAY` and `WP_DEBUG_LOG` perform no function unless `WP_DEBUG`
408 * is true.
409 *
410 * When `WP_DEBUG_DISPLAY` is true, WordPress will force errors to be displayed.
411 * `WP_DEBUG_DISPLAY` defaults to true. Defining it as null prevents WordPress
412 * from changing the global configuration setting. Defining `WP_DEBUG_DISPLAY`
413 * as false will force errors to be hidden.
414 *
415 * When `WP_DEBUG_LOG` is true, errors will be logged to `wp-content/debug.log`.
416 * When `WP_DEBUG_LOG` is a valid path, errors will be logged to the specified file.
417 *
418 * Errors are never displayed for XML-RPC, REST, `ms-files.php`, and Ajax requests.
419 *
420 * @since 3.0.0
421 * @since 5.1.0 `WP_DEBUG_LOG` can be a file path.
422 * @access private
423 */
424function wp_debug_mode() {
425 /**
426 * Filters whether to allow the debug mode check to occur.
427 *
428 * This filter runs before it can be used by plugins. It is designed for
429 * non-web runtimes. Returning false causes the `WP_DEBUG` and related
430 * constants to not be checked and the default PHP values for errors
431 * will be used unless you take care to update them yourself.
432 *
433 * To use this filter you must define a `$wp_filter` global before
434 * WordPress loads, usually in `wp-config.php`.
435 *
436 * Example:
437 *
438 * $GLOBALS['wp_filter'] = array(
439 * 'enable_wp_debug_mode_checks' => array(
440 * 10 => array(
441 * array(
442 * 'accepted_args' => 0,
443 * 'function' => function() {
444 * return false;
445 * },
446 * ),
447 * ),
448 * ),
449 * );
450 *
451 * @since 4.6.0
452 *
453 * @param bool $enable_debug_mode Whether to enable debug mode checks to occur. Default true.
454 */
455 if ( ! apply_filters( 'enable_wp_debug_mode_checks', true ) ) {
456 return;
457 }
458
459 if ( WP_DEBUG ) {
460 error_reporting( E_ALL );
461
462 if ( WP_DEBUG_DISPLAY ) {
463 ini_set( 'display_errors', 1 );
464 } elseif ( null !== WP_DEBUG_DISPLAY ) {
465 ini_set( 'display_errors', 0 );
466 }
467
468 if ( in_array( strtolower( (string) WP_DEBUG_LOG ), array( 'true', '1' ), true ) ) {
469 $log_path = WP_CONTENT_DIR . '/debug.log';
470 } elseif ( is_string( WP_DEBUG_LOG ) ) {
471 $log_path = WP_DEBUG_LOG;
472 } else {
473 $log_path = false;
474 }
475
476 if ( $log_path ) {
477 ini_set( 'log_errors', 1 );
478 ini_set( 'error_log', $log_path );
479 }
480 } else {
481 error_reporting( E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_ERROR | E_WARNING | E_PARSE | E_USER_ERROR | E_USER_WARNING | E_RECOVERABLE_ERROR );
482 }
483
484 if (
485 defined( 'XMLRPC_REQUEST' ) || defined( 'REST_REQUEST' ) || defined( 'MS_FILES_REQUEST' ) ||
486 ( defined( 'WP_INSTALLING' ) && WP_INSTALLING ) ||
487 wp_doing_ajax() || wp_is_json_request() ) {
488
489 if ( WP_DEBUG && WP_DEBUG_DISPLAY ) {
490 ini_set( 'display_errors', 1 );
491 }
492 else{
493 ini_set( 'display_errors', 0 );
494 }
495 }
496}
497
498/**
499 * Set the location of the language directory.
500 *
501 * To set directory manually, define the `WP_LANG_DIR` constant
502 * in wp-config.php.
503 *
504 * If the language directory exists within `WP_CONTENT_DIR`, it
505 * is used. Otherwise the language directory is assumed to live
506 * in `WPINC`.
507 *
508 * @since 3.0.0
509 * @access private
510 */
511function wp_set_lang_dir() {
512 if ( ! defined( 'WP_LANG_DIR' ) ) {
513 if ( file_exists( WP_CONTENT_DIR . '/languages' ) && @is_dir( WP_CONTENT_DIR . '/languages' ) || ! @is_dir( ABSPATH . WPINC . '/languages' ) ) {
514 /**
515 * Server path of the language directory.
516 *
517 * No leading slash, no trailing slash, full path, not relative to ABSPATH
518 *
519 * @since 2.1.0
520 */
521 define( 'WP_LANG_DIR', WP_CONTENT_DIR . '/languages' );
522 if ( ! defined( 'LANGDIR' ) ) {
523 // Old static relative path maintained for limited backward compatibility - won't work in some cases.
524 define( 'LANGDIR', 'wp-content/languages' );
525 }
526 } else {
527 /**
528 * Server path of the language directory.
529 *
530 * No leading slash, no trailing slash, full path, not relative to `ABSPATH`.
531 *
532 * @since 2.1.0
533 */
534 define( 'WP_LANG_DIR', ABSPATH . WPINC . '/languages' );
535 if ( ! defined( 'LANGDIR' ) ) {
536 // Old relative path maintained for backward compatibility.
537 define( 'LANGDIR', WPINC . '/languages' );
538 }
539 }
540 }
541}
542
543/**
544 * Load the database class file and instantiate the `$wpdb` global.
545 *
546 * @since 2.5.0
547 *
548 * @global wpdb $wpdb WordPress database abstraction object.
549 */
550function require_wp_db() {
551 global $wpdb;
552
553 require_once ABSPATH . WPINC . '/class-wpdb.php';
554
555 if ( file_exists( WP_CONTENT_DIR . '/db.php' ) ) {
556 require_once WP_CONTENT_DIR . '/db.php';
557 }
558
559 if ( isset( $wpdb ) ) {
560 return;
561 }
562
563 $dbuser = defined( 'DB_USER' ) ? DB_USER : '';
564 $dbpassword = defined( 'DB_PASSWORD' ) ? DB_PASSWORD : '';
565 $dbname = defined( 'DB_NAME' ) ? DB_NAME : '';
566 $dbhost = defined( 'DB_HOST' ) ? DB_HOST : '';
567
568 $wpdb = new wpdb( $dbuser, $dbpassword, $dbname, $dbhost );
569}
570
571/**
572 * Set the database table prefix and the format specifiers for database
573 * table columns.
574 *
575 * Columns not listed here default to `%s`.
576 *
577 * @since 3.0.0
578 * @access private
579 *
580 * @global wpdb $wpdb WordPress database abstraction object.
581 * @global string $table_prefix The database table prefix.
582 */
583function wp_set_wpdb_vars() {
584 global $wpdb, $table_prefix;
585 if ( ! empty( $wpdb->error ) ) {
586 dead_db();
587 }
588
589 $wpdb->field_types = array(
590 'post_author' => '%d',
591 'post_parent' => '%d',
592 'menu_order' => '%d',
593 'term_id' => '%d',
594 'term_group' => '%d',
595 'term_taxonomy_id' => '%d',
596 'parent' => '%d',
597 'count' => '%d',
598 'object_id' => '%d',
599 'term_order' => '%d',
600 'ID' => '%d',
601 'comment_ID' => '%d',
602 'comment_post_ID' => '%d',
603 'comment_parent' => '%d',
604 'user_id' => '%d',
605 'link_id' => '%d',
606 'link_owner' => '%d',
607 'link_rating' => '%d',
608 'option_id' => '%d',
609 'blog_id' => '%d',
610 'meta_id' => '%d',
611 'post_id' => '%d',
612 'user_status' => '%d',
613 'umeta_id' => '%d',
614 'comment_karma' => '%d',
615 'comment_count' => '%d',
616 // Multisite:
617 'active' => '%d',
618 'cat_id' => '%d',
619 'deleted' => '%d',
620 'lang_id' => '%d',
621 'mature' => '%d',
622 'public' => '%d',
623 'site_id' => '%d',
624 'spam' => '%d',
625 );
626
627 $prefix = $wpdb->set_prefix( $table_prefix );
628
629 if ( is_wp_error( $prefix ) ) {
630 wp_load_translations_early();
631 wp_die(
632 sprintf(
633 /* translators: 1: $table_prefix, 2: wp-config.php */
634 __( '<strong>Error:</strong> %1$s in %2$s can only contain numbers, letters, and underscores.' ),
635 '<code>$table_prefix</code>',
636 '<code>wp-config.php</code>'
637 )
638 );
639 }
640}
641
642/**
643 * Toggle `$_wp_using_ext_object_cache` on and off without directly
644 * touching global.
645 *
646 * @since 3.7.0
647 *
648 * @global bool $_wp_using_ext_object_cache
649 *
650 * @param bool $using Whether external object cache is being used.
651 * @return bool The current 'using' setting.
652 */
653function wp_using_ext_object_cache( $using = null ) {
654 global $_wp_using_ext_object_cache;
655 $current_using = $_wp_using_ext_object_cache;
656 if ( null !== $using ) {
657 $_wp_using_ext_object_cache = $using;
658 }
659 return $current_using;
660}
661
662/**
663 * Start the WordPress object cache.
664 *
665 * If an object-cache.php file exists in the wp-content directory,
666 * it uses that drop-in as an external object cache.
667 *
668 * @since 3.0.0
669 * @access private
670 *
671 * @global array $wp_filter Stores all of the filters.
672 */
673function wp_start_object_cache() {
674 global $wp_filter;
675 static $first_init = true;
676
677 // Only perform the following checks once.
678
679 /**
680 * Filters whether to enable loading of the object-cache.php drop-in.
681 *
682 * This filter runs before it can be used by plugins. It is designed for non-web
683 * runtimes. If false is returned, object-cache.php will never be loaded.
684 *
685 * @since 5.8.0
686 *
687 * @param bool $enable_object_cache Whether to enable loading object-cache.php (if present).
688 * Default true.
689 */
690 if ( $first_init && apply_filters( 'enable_loading_object_cache_dropin', true ) ) {
691 if ( ! function_exists( 'wp_cache_init' ) ) {
692 /*
693 * This is the normal situation. First-run of this function. No
694 * caching backend has been loaded.
695 *
696 * We try to load a custom caching backend, and then, if it
697 * results in a wp_cache_init() function existing, we note
698 * that an external object cache is being used.
699 */
700 if ( file_exists( WP_CONTENT_DIR . '/object-cache.php' ) ) {
701 require_once WP_CONTENT_DIR . '/object-cache.php';
702 if ( function_exists( 'wp_cache_init' ) ) {
703 wp_using_ext_object_cache( true );
704 }
705
706 // Re-initialize any hooks added manually by object-cache.php.
707 if ( $wp_filter ) {
708 $wp_filter = WP_Hook::build_preinitialized_hooks( $wp_filter );
709 }
710 }
711 } elseif ( ! wp_using_ext_object_cache() && file_exists( WP_CONTENT_DIR . '/object-cache.php' ) ) {
712 /*
713 * Sometimes advanced-cache.php can load object-cache.php before
714 * this function is run. This breaks the function_exists() check
715 * above and can result in wp_using_ext_object_cache() returning
716 * false when actually an external cache is in use.
717 */
718 wp_using_ext_object_cache( true );
719 }
720 }
721
722 if ( ! wp_using_ext_object_cache() ) {
723 require_once ABSPATH . WPINC . '/cache.php';
724 }
725
726 require_once ABSPATH . WPINC . '/cache-compat.php';
727
728 /*
729 * If cache supports reset, reset instead of init if already
730 * initialized. Reset signals to the cache that global IDs
731 * have changed and it may need to update keys and cleanup caches.
732 */
733 if ( ! $first_init && function_exists( 'wp_cache_switch_to_blog' ) ) {
734 wp_cache_switch_to_blog( get_current_blog_id() );
735 } elseif ( function_exists( 'wp_cache_init' ) ) {
736 wp_cache_init();
737 }
738
739 if ( function_exists( 'wp_cache_add_global_groups' ) ) {
740 wp_cache_add_global_groups(
741 array(
742 'blog-details',
743 'blog-id-cache',
744 'blog-lookup',
745 'blog_meta',
746 'global-posts',
747 'networks',
748 'sites',
749 'site-details',
750 'site-options',
751 'site-transient',
752 'rss',
753 'users',
754 'useremail',
755 'userlogins',
756 'usermeta',
757 'user_meta',
758 'userslugs',
759 )
760 );
761
762 wp_cache_add_non_persistent_groups( array( 'counts', 'plugins' ) );
763 }
764
765 $first_init = false;
766}
767
768/**
769 * Redirect to the installer if WordPress is not installed.
770 *
771 * Dies with an error message when Multisite is enabled.
772 *
773 * @since 3.0.0
774 * @access private
775 */
776function wp_not_installed() {
777 if ( is_blog_installed() || wp_installing() ) {
778 return;
779 }
780
781 nocache_headers();
782
783 if ( is_multisite() ) {
784 wp_die( __( 'The site you have requested is not installed properly. Please contact the system administrator.' ) );
785 }
786
787 require ABSPATH . WPINC . '/kses.php';
788 require ABSPATH . WPINC . '/pluggable.php';
789
790 $link = wp_guess_url() . '/wp-admin/install.php';
791
792 wp_redirect( $link );
793 die();
794}
795
796/**
797 * Retrieve an array of must-use plugin files.
798 *
799 * The default directory is wp-content/mu-plugins. To change the default
800 * directory manually, define `WPMU_PLUGIN_DIR` and `WPMU_PLUGIN_URL`
801 * in wp-config.php.
802 *
803 * @since 3.0.0
804 * @access private
805 *
806 * @return string[] Array of absolute paths of files to include.
807 */
808function wp_get_mu_plugins() {
809 $mu_plugins = array();
810 if ( ! is_dir( WPMU_PLUGIN_DIR ) ) {
811 return $mu_plugins;
812 }
813 $dh = opendir( WPMU_PLUGIN_DIR );
814 if ( ! $dh ) {
815 return $mu_plugins;
816 }
817 while ( ( $plugin = readdir( $dh ) ) !== false ) {
818 if ( '.php' === substr( $plugin, -4 ) ) {
819 $mu_plugins[] = WPMU_PLUGIN_DIR . '/' . $plugin;
820 }
821 }
822 closedir( $dh );
823 sort( $mu_plugins );
824
825 return $mu_plugins;
826}
827
828/**
829 * Retrieve an array of active and valid plugin files.
830 *
831 * While upgrading or installing WordPress, no plugins are returned.
832 *
833 * The default directory is `wp-content/plugins`. To change the default
834 * directory manually, define `WP_PLUGIN_DIR` and `WP_PLUGIN_URL`
835 * in `wp-config.php`.
836 *
837 * @since 3.0.0
838 * @access private
839 *
840 * @return string[] Array of paths to plugin files relative to the plugins directory.
841 */
842function wp_get_active_and_valid_plugins() {
843 $plugins = array();
844 $active_plugins = (array) get_option( 'active_plugins', array() );
845
846 // Check for hacks file if the option is enabled.
847 if ( get_option( 'hack_file' ) && file_exists( ABSPATH . 'my-hacks.php' ) ) {
848 _deprecated_file( 'my-hacks.php', '1.5.0' );
849 array_unshift( $plugins, ABSPATH . 'my-hacks.php' );
850 }
851
852 if ( empty( $active_plugins ) || wp_installing() ) {
853 return $plugins;
854 }
855
856 $network_plugins = is_multisite() ? wp_get_active_network_plugins() : false;
857
858 foreach ( $active_plugins as $plugin ) {
859 if ( ! validate_file( $plugin ) // $plugin must validate as file.
860 && '.php' === substr( $plugin, -4 ) // $plugin must end with '.php'.
861 && file_exists( WP_PLUGIN_DIR . '/' . $plugin ) // $plugin must exist.
862 // Not already included as a network plugin.
863 && ( ! $network_plugins || ! in_array( WP_PLUGIN_DIR . '/' . $plugin, $network_plugins, true ) )
864 ) {
865 $plugins[] = WP_PLUGIN_DIR . '/' . $plugin;
866 }
867 }
868
869 /*
870 * Remove plugins from the list of active plugins when we're on an endpoint
871 * that should be protected against WSODs and the plugin is paused.
872 */
873 if ( wp_is_recovery_mode() ) {
874 $plugins = wp_skip_paused_plugins( $plugins );
875 }
876
877 return $plugins;
878}
879
880/**
881 * Filters a given list of plugins, removing any paused plugins from it.
882 *
883 * @since 5.2.0
884 *
885 * @param string[] $plugins Array of absolute plugin main file paths.
886 * @return string[] Filtered array of plugins, without any paused plugins.
887 */
888function wp_skip_paused_plugins( array $plugins ) {
889 $paused_plugins = wp_paused_plugins()->get_all();
890
891 if ( empty( $paused_plugins ) ) {
892 return $plugins;
893 }
894
895 foreach ( $plugins as $index => $plugin ) {
896 list( $plugin ) = explode( '/', plugin_basename( $plugin ) );
897
898 if ( array_key_exists( $plugin, $paused_plugins ) ) {
899 unset( $plugins[ $index ] );
900
901 // Store list of paused plugins for displaying an admin notice.
902 $GLOBALS['_paused_plugins'][ $plugin ] = $paused_plugins[ $plugin ];
903 }
904 }
905
906 return $plugins;
907}
908
909/**
910 * Retrieves an array of active and valid themes.
911 *
912 * While upgrading or installing WordPress, no themes are returned.
913 *
914 * @since 5.1.0
915 * @access private
916 *
917 * @global string $pagenow The filename of the current screen.
918 *
919 * @return string[] Array of absolute paths to theme directories.
920 */
921function wp_get_active_and_valid_themes() {
922 global $pagenow;
923
924 $themes = array();
925
926 if ( wp_installing() && 'wp-activate.php' !== $pagenow ) {
927 return $themes;
928 }
929
930 if ( TEMPLATEPATH !== STYLESHEETPATH ) {
931 $themes[] = STYLESHEETPATH;
932 }
933
934 $themes[] = TEMPLATEPATH;
935
936 /*
937 * Remove themes from the list of active themes when we're on an endpoint
938 * that should be protected against WSODs and the theme is paused.
939 */
940 if ( wp_is_recovery_mode() ) {
941 $themes = wp_skip_paused_themes( $themes );
942
943 // If no active and valid themes exist, skip loading themes.
944 if ( empty( $themes ) ) {
945 add_filter( 'wp_using_themes', '__return_false' );
946 }
947 }
948
949 return $themes;
950}
951
952/**
953 * Filters a given list of themes, removing any paused themes from it.
954 *
955 * @since 5.2.0
956 *
957 * @param string[] $themes Array of absolute theme directory paths.
958 * @return string[] Filtered array of absolute paths to themes, without any paused themes.
959 */
960function wp_skip_paused_themes( array $themes ) {
961 $paused_themes = wp_paused_themes()->get_all();
962
963 if ( empty( $paused_themes ) ) {
964 return $themes;
965 }
966
967 foreach ( $themes as $index => $theme ) {
968 $theme = basename( $theme );
969
970 if ( array_key_exists( $theme, $paused_themes ) ) {
971 unset( $themes[ $index ] );
972
973 // Store list of paused themes for displaying an admin notice.
974 $GLOBALS['_paused_themes'][ $theme ] = $paused_themes[ $theme ];
975 }
976 }
977
978 return $themes;
979}
980
981/**
982 * Is WordPress in Recovery Mode.
983 *
984 * In this mode, plugins or themes that cause WSODs will be paused.
985 *
986 * @since 5.2.0
987 *
988 * @return bool
989 */
990function wp_is_recovery_mode() {
991 return wp_recovery_mode()->is_active();
992}
993
994/**
995 * Determines whether we are currently on an endpoint that should be protected against WSODs.
996 *
997 * @since 5.2.0
998 *
999 * @global string $pagenow The filename of the current screen.
1000 *
1001 * @return bool True if the current endpoint should be protected.
1002 */
1003function is_protected_endpoint() {
1004 // Protect login pages.
1005 if ( isset( $GLOBALS['pagenow'] ) && 'wp-login.php' === $GLOBALS['pagenow'] ) {
1006 return true;
1007 }
1008
1009 // Protect the admin backend.
1010 if ( is_admin() && ! wp_doing_ajax() ) {
1011 return true;
1012 }
1013
1014 // Protect Ajax actions that could help resolve a fatal error should be available.
1015 if ( is_protected_ajax_action() ) {
1016 return true;
1017 }
1018
1019 /**
1020 * Filters whether the current request is against a protected endpoint.
1021 *
1022 * This filter is only fired when an endpoint is requested which is not already protected by
1023 * WordPress core. As such, it exclusively allows providing further protected endpoints in
1024 * addition to the admin backend, login pages and protected Ajax actions.
1025 *
1026 * @since 5.2.0
1027 *
1028 * @param bool $is_protected_endpoint Whether the currently requested endpoint is protected.
1029 * Default false.
1030 */
1031 return (bool) apply_filters( 'is_protected_endpoint', false );
1032}
1033
1034/**
1035 * Determines whether we are currently handling an Ajax action that should be protected against WSODs.
1036 *
1037 * @since 5.2.0
1038 *
1039 * @return bool True if the current Ajax action should be protected.
1040 */
1041function is_protected_ajax_action() {
1042 if ( ! wp_doing_ajax() ) {
1043 return false;
1044 }
1045
1046 if ( ! isset( $_REQUEST['action'] ) ) {
1047 return false;
1048 }
1049
1050 $actions_to_protect = array(
1051 'edit-theme-plugin-file', // Saving changes in the core code editor.
1052 'heartbeat', // Keep the heart beating.
1053 'install-plugin', // Installing a new plugin.
1054 'install-theme', // Installing a new theme.
1055 'search-plugins', // Searching in the list of plugins.
1056 'search-install-plugins', // Searching for a plugin in the plugin install screen.
1057 'update-plugin', // Update an existing plugin.
1058 'update-theme', // Update an existing theme.
1059 );
1060
1061 /**
1062 * Filters the array of protected Ajax actions.
1063 *
1064 * This filter is only fired when doing Ajax and the Ajax request has an 'action' property.
1065 *
1066 * @since 5.2.0
1067 *
1068 * @param string[] $actions_to_protect Array of strings with Ajax actions to protect.
1069 */
1070 $actions_to_protect = (array) apply_filters( 'wp_protected_ajax_actions', $actions_to_protect );
1071
1072 if ( ! in_array( $_REQUEST['action'], $actions_to_protect, true ) ) {
1073 return false;
1074 }
1075
1076 return true;
1077}
1078
1079/**
1080 * Set internal encoding.
1081 *
1082 * In most cases the default internal encoding is latin1, which is
1083 * of no use, since we want to use the `mb_` functions for `utf-8` strings.
1084 *
1085 * @since 3.0.0
1086 * @access private
1087 */
1088function wp_set_internal_encoding() {
1089 if ( function_exists( 'mb_internal_encoding' ) ) {
1090 $charset = get_option( 'blog_charset' );
1091 // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged
1092 if ( ! $charset || ! @mb_internal_encoding( $charset ) ) {
1093 mb_internal_encoding( 'UTF-8' );
1094 }
1095 }
1096}
1097
1098/**
1099 * Add magic quotes to `$_GET`, `$_POST`, `$_COOKIE`, and `$_SERVER`.
1100 *
1101 * Also forces `$_REQUEST` to be `$_GET + $_POST`. If `$_SERVER`,
1102 * `$_COOKIE`, or `$_ENV` are needed, use those superglobals directly.
1103 *
1104 * @since 3.0.0
1105 * @access private
1106 */
1107function wp_magic_quotes() {
1108 // Escape with wpdb.
1109 $_GET = add_magic_quotes( $_GET );
1110 $_POST = add_magic_quotes( $_POST );
1111 $_COOKIE = add_magic_quotes( $_COOKIE );
1112 $_SERVER = add_magic_quotes( $_SERVER );
1113
1114 // Force REQUEST to be GET + POST.
1115 $_REQUEST = array_merge( $_GET, $_POST );
1116}
1117
1118/**
1119 * Runs just before PHP shuts down execution.
1120 *
1121 * @since 1.2.0
1122 * @access private
1123 */
1124function shutdown_action_hook() {
1125 /**
1126 * Fires just before PHP shuts down execution.
1127 *
1128 * @since 1.2.0
1129 */
1130 do_action( 'shutdown' );
1131
1132 wp_cache_close();
1133}
1134
1135/**
1136 * Copy an object.
1137 *
1138 * @since 2.7.0
1139 * @deprecated 3.2.0
1140 *
1141 * @param object $input_object The object to clone.
1142 * @return object The cloned object.
1143 */
1144function wp_clone( $input_object ) {
1145 // Use parens for clone to accommodate PHP 4. See #17880.
1146 return clone( $input_object );
1147}
1148
1149/**
1150 * Determines whether the current request is for the login screen.
1151 *
1152 * @since 6.1.0
1153 *
1154 * @see wp_login_url()
1155 *
1156 * @return bool True if inside WordPress login screen, false otherwise.
1157 */
1158function is_login() {
1159 return false !== stripos( wp_login_url(), $_SERVER['SCRIPT_NAME'] );
1160}
1161
1162/**
1163 * Determines whether the current request is for an administrative interface page.
1164 *
1165 * Does not check if the user is an administrator; use current_user_can()
1166 * for checking roles and capabilities.
1167 *
1168 * For more information on this and similar theme functions, check out
1169 * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
1170 * Conditional Tags} article in the Theme Developer Handbook.
1171 *
1172 * @since 1.5.1
1173 *
1174 * @global WP_Screen $current_screen WordPress current screen object.
1175 *
1176 * @return bool True if inside WordPress administration interface, false otherwise.
1177 */
1178function is_admin() {
1179 if ( isset( $GLOBALS['current_screen'] ) ) {
1180 return $GLOBALS['current_screen']->in_admin();
1181 } elseif ( defined( 'WP_ADMIN' ) ) {
1182 return WP_ADMIN;
1183 }
1184
1185 return false;
1186}
1187
1188/**
1189 * Determines whether the current request is for a site's administrative interface.
1190 *
1191 * e.g. `/wp-admin/`
1192 *
1193 * Does not check if the user is an administrator; use current_user_can()
1194 * for checking roles and capabilities.
1195 *
1196 * @since 3.1.0
1197 *
1198 * @global WP_Screen $current_screen WordPress current screen object.
1199 *
1200 * @return bool True if inside WordPress site administration pages.
1201 */
1202function is_blog_admin() {
1203 if ( isset( $GLOBALS['current_screen'] ) ) {
1204 return $GLOBALS['current_screen']->in_admin( 'site' );
1205 } elseif ( defined( 'WP_BLOG_ADMIN' ) ) {
1206 return WP_BLOG_ADMIN;
1207 }
1208
1209 return false;
1210}
1211
1212/**
1213 * Determines whether the current request is for the network administrative interface.
1214 *
1215 * e.g. `/wp-admin/network/`
1216 *
1217 * Does not check if the user is an administrator; use current_user_can()
1218 * for checking roles and capabilities.
1219 *
1220 * Does not check if the site is a Multisite network; use is_multisite()
1221 * for checking if Multisite is enabled.
1222 *
1223 * @since 3.1.0
1224 *
1225 * @global WP_Screen $current_screen WordPress current screen object.
1226 *
1227 * @return bool True if inside WordPress network administration pages.
1228 */
1229function is_network_admin() {
1230 if ( isset( $GLOBALS['current_screen'] ) ) {
1231 return $GLOBALS['current_screen']->in_admin( 'network' );
1232 } elseif ( defined( 'WP_NETWORK_ADMIN' ) ) {
1233 return WP_NETWORK_ADMIN;
1234 }
1235
1236 return false;
1237}
1238
1239/**
1240 * Determines whether the current request is for a user admin screen.
1241 *
1242 * e.g. `/wp-admin/user/`
1243 *
1244 * Does not check if the user is an administrator; use current_user_can()
1245 * for checking roles and capabilities.
1246 *
1247 * @since 3.1.0
1248 *
1249 * @global WP_Screen $current_screen WordPress current screen object.
1250 *
1251 * @return bool True if inside WordPress user administration pages.
1252 */
1253function is_user_admin() {
1254 if ( isset( $GLOBALS['current_screen'] ) ) {
1255 return $GLOBALS['current_screen']->in_admin( 'user' );
1256 } elseif ( defined( 'WP_USER_ADMIN' ) ) {
1257 return WP_USER_ADMIN;
1258 }
1259
1260 return false;
1261}
1262
1263/**
1264 * If Multisite is enabled.
1265 *
1266 * @since 3.0.0
1267 *
1268 * @return bool True if Multisite is enabled, false otherwise.
1269 */
1270function is_multisite() {
1271 if ( defined( 'MULTISITE' ) ) {
1272 return MULTISITE;
1273 }
1274
1275 if ( defined( 'SUBDOMAIN_INSTALL' ) || defined( 'VHOST' ) || defined( 'SUNRISE' ) ) {
1276 return true;
1277 }
1278
1279 return false;
1280}
1281
1282/**
1283 * Retrieve the current site ID.
1284 *
1285 * @since 3.1.0
1286 *
1287 * @global int $blog_id
1288 *
1289 * @return int Site ID.
1290 */
1291function get_current_blog_id() {
1292 global $blog_id;
1293 return absint( $blog_id );
1294}
1295
1296/**
1297 * Retrieves the current network ID.
1298 *
1299 * @since 4.6.0
1300 *
1301 * @return int The ID of the current network.
1302 */
1303function get_current_network_id() {
1304 if ( ! is_multisite() ) {
1305 return 1;
1306 }
1307
1308 $current_network = get_network();
1309
1310 if ( ! isset( $current_network->id ) ) {
1311 return get_main_network_id();
1312 }
1313
1314 return absint( $current_network->id );
1315}
1316
1317/**
1318 * Attempt an early load of translations.
1319 *
1320 * Used for errors encountered during the initial loading process, before
1321 * the locale has been properly detected and loaded.
1322 *
1323 * Designed for unusual load sequences (like setup-config.php) or for when
1324 * the script will then terminate with an error, otherwise there is a risk
1325 * that a file can be double-included.
1326 *
1327 * @since 3.4.0
1328 * @access private
1329 *
1330 * @global WP_Textdomain_Registry $wp_textdomain_registry WordPress Textdomain Registry.
1331 * @global WP_Locale $wp_locale WordPress date and time locale object.
1332 */
1333function wp_load_translations_early() {
1334 global $wp_textdomain_registry, $wp_locale;
1335
1336 static $loaded = false;
1337 if ( $loaded ) {
1338 return;
1339 }
1340 $loaded = true;
1341
1342 if ( function_exists( 'did_action' ) && did_action( 'init' ) ) {
1343 return;
1344 }
1345
1346 // We need $wp_local_package.
1347 require ABSPATH . WPINC . '/version.php';
1348
1349 // Translation and localization.
1350 require_once ABSPATH . WPINC . '/pomo/mo.php';
1351 require_once ABSPATH . WPINC . '/l10n.php';
1352 require_once ABSPATH . WPINC . '/class-wp-textdomain-registry.php';
1353 require_once ABSPATH . WPINC . '/class-wp-locale.php';
1354 require_once ABSPATH . WPINC . '/class-wp-locale-switcher.php';
1355
1356 // General libraries.
1357 require_once ABSPATH . WPINC . '/plugin.php';
1358
1359 $locales = array();
1360 $locations = array();
1361
1362 if ( ! $wp_textdomain_registry instanceof WP_Textdomain_Registry ) {
1363 $wp_textdomain_registry = new WP_Textdomain_Registry();
1364 }
1365
1366 while ( true ) {
1367 if ( defined( 'WPLANG' ) ) {
1368 if ( '' === WPLANG ) {
1369 break;
1370 }
1371 $locales[] = WPLANG;
1372 }
1373
1374 if ( isset( $wp_local_package ) ) {
1375 $locales[] = $wp_local_package;
1376 }
1377
1378 if ( ! $locales ) {
1379 break;
1380 }
1381
1382 if ( defined( 'WP_LANG_DIR' ) && @is_dir( WP_LANG_DIR ) ) {
1383 $locations[] = WP_LANG_DIR;
1384 }
1385
1386 if ( defined( 'WP_CONTENT_DIR' ) && @is_dir( WP_CONTENT_DIR . '/languages' ) ) {
1387 $locations[] = WP_CONTENT_DIR . '/languages';
1388 }
1389
1390 if ( @is_dir( ABSPATH . 'wp-content/languages' ) ) {
1391 $locations[] = ABSPATH . 'wp-content/languages';
1392 }
1393
1394 if ( @is_dir( ABSPATH . WPINC . '/languages' ) ) {
1395 $locations[] = ABSPATH . WPINC . '/languages';
1396 }
1397
1398 if ( ! $locations ) {
1399 break;
1400 }
1401
1402 $locations = array_unique( $locations );
1403
1404 foreach ( $locales as $locale ) {
1405 foreach ( $locations as $location ) {
1406 if ( file_exists( $location . '/' . $locale . '.mo' ) ) {
1407 load_textdomain( 'default', $location . '/' . $locale . '.mo', $locale );
1408 if ( defined( 'WP_SETUP_CONFIG' ) && file_exists( $location . '/admin-' . $locale . '.mo' ) ) {
1409 load_textdomain( 'default', $location . '/admin-' . $locale . '.mo', $locale );
1410 }
1411 break 2;
1412 }
1413 }
1414 }
1415
1416 break;
1417 }
1418
1419 $wp_locale = new WP_Locale();
1420}
1421
1422/**
1423 * Check or set whether WordPress is in "installation" mode.
1424 *
1425 * If the `WP_INSTALLING` constant is defined during the bootstrap, `wp_installing()` will default to `true`.
1426 *
1427 * @since 4.4.0
1428 *
1429 * @param bool $is_installing Optional. True to set WP into Installing mode, false to turn Installing mode off.
1430 * Omit this parameter if you only want to fetch the current status.
1431 * @return bool True if WP is installing, otherwise false. When a `$is_installing` is passed, the function will
1432 * report whether WP was in installing mode prior to the change to `$is_installing`.
1433 */
1434function wp_installing( $is_installing = null ) {
1435 static $installing = null;
1436
1437 // Support for the `WP_INSTALLING` constant, defined before WP is loaded.
1438 if ( is_null( $installing ) ) {
1439 $installing = defined( 'WP_INSTALLING' ) && WP_INSTALLING;
1440 }
1441
1442 if ( ! is_null( $is_installing ) ) {
1443 $old_installing = $installing;
1444 $installing = $is_installing;
1445 return (bool) $old_installing;
1446 }
1447
1448 return (bool) $installing;
1449}
1450
1451/**
1452 * Determines if SSL is used.
1453 *
1454 * @since 2.6.0
1455 * @since 4.6.0 Moved from functions.php to load.php.
1456 *
1457 * @return bool True if SSL, otherwise false.
1458 */
1459function is_ssl() {
1460 if ( isset( $_SERVER['HTTPS'] ) ) {
1461 if ( 'on' === strtolower( $_SERVER['HTTPS'] ) ) {
1462 return true;
1463 }
1464
1465 if ( '1' == $_SERVER['HTTPS'] ) {
1466 return true;
1467 }
1468 } elseif ( isset( $_SERVER['SERVER_PORT'] ) && ( '443' == $_SERVER['SERVER_PORT'] ) ) {
1469 return true;
1470 }
1471 return false;
1472}
1473
1474/**
1475 * Converts a shorthand byte value to an integer byte value.
1476 *
1477 * @since 2.3.0
1478 * @since 4.6.0 Moved from media.php to load.php.
1479 *
1480 * @link https://www.php.net/manual/en/function.ini-get.php
1481 * @link https://www.php.net/manual/en/faq.using.php#faq.using.shorthandbytes
1482 *
1483 * @param string $value A (PHP ini) byte value, either shorthand or ordinary.
1484 * @return int An integer byte value.
1485 */
1486function wp_convert_hr_to_bytes( $value ) {
1487 $value = strtolower( trim( $value ) );
1488 $bytes = (int) $value;
1489
1490 if ( false !== strpos( $value, 'g' ) ) {
1491 $bytes *= GB_IN_BYTES;
1492 } elseif ( false !== strpos( $value, 'm' ) ) {
1493 $bytes *= MB_IN_BYTES;
1494 } elseif ( false !== strpos( $value, 'k' ) ) {
1495 $bytes *= KB_IN_BYTES;
1496 }
1497
1498 // Deal with large (float) values which run into the maximum integer size.
1499 return min( $bytes, PHP_INT_MAX );
1500}
1501
1502/**
1503 * Determines whether a PHP ini value is changeable at runtime.
1504 *
1505 * @since 4.6.0
1506 *
1507 * @link https://www.php.net/manual/en/function.ini-get-all.php
1508 *
1509 * @param string $setting The name of the ini setting to check.
1510 * @return bool True if the value is changeable at runtime. False otherwise.
1511 */
1512function wp_is_ini_value_changeable( $setting ) {
1513 static $ini_all;
1514
1515 if ( ! isset( $ini_all ) ) {
1516 $ini_all = false;
1517 // Sometimes `ini_get_all()` is disabled via the `disable_functions` option for "security purposes".
1518 if ( function_exists( 'ini_get_all' ) ) {
1519 $ini_all = ini_get_all();
1520 }
1521 }
1522
1523 // Bit operator to workaround https://bugs.php.net/bug.php?id=44936 which changes access level to 63 in PHP 5.2.6 - 5.2.17.
1524 if ( isset( $ini_all[ $setting ]['access'] ) && ( INI_ALL === ( $ini_all[ $setting ]['access'] & 7 ) || INI_USER === ( $ini_all[ $setting ]['access'] & 7 ) ) ) {
1525 return true;
1526 }
1527
1528 // If we were unable to retrieve the details, fail gracefully to assume it's changeable.
1529 if ( ! is_array( $ini_all ) ) {
1530 return true;
1531 }
1532
1533 return false;
1534}
1535
1536/**
1537 * Determines whether the current request is a WordPress Ajax request.
1538 *
1539 * @since 4.7.0
1540 *
1541 * @return bool True if it's a WordPress Ajax request, false otherwise.
1542 */
1543function wp_doing_ajax() {
1544 /**
1545 * Filters whether the current request is a WordPress Ajax request.
1546 *
1547 * @since 4.7.0
1548 *
1549 * @param bool $wp_doing_ajax Whether the current request is a WordPress Ajax request.
1550 */
1551 return apply_filters( 'wp_doing_ajax', defined( 'DOING_AJAX' ) && DOING_AJAX );
1552}
1553
1554/**
1555 * Determines whether the current request should use themes.
1556 *
1557 * @since 5.1.0
1558 *
1559 * @return bool True if themes should be used, false otherwise.
1560 */
1561function wp_using_themes() {
1562 /**
1563 * Filters whether the current request should use themes.
1564 *
1565 * @since 5.1.0
1566 *
1567 * @param bool $wp_using_themes Whether the current request should use themes.
1568 */
1569 return apply_filters( 'wp_using_themes', defined( 'WP_USE_THEMES' ) && WP_USE_THEMES );
1570}
1571
1572/**
1573 * Determines whether the current request is a WordPress cron request.
1574 *
1575 * @since 4.8.0
1576 *
1577 * @return bool True if it's a WordPress cron request, false otherwise.
1578 */
1579function wp_doing_cron() {
1580 /**
1581 * Filters whether the current request is a WordPress cron request.
1582 *
1583 * @since 4.8.0
1584 *
1585 * @param bool $wp_doing_cron Whether the current request is a WordPress cron request.
1586 */
1587 return apply_filters( 'wp_doing_cron', defined( 'DOING_CRON' ) && DOING_CRON );
1588}
1589
1590/**
1591 * Checks whether the given variable is a WordPress Error.
1592 *
1593 * Returns whether `$thing` is an instance of the `WP_Error` class.
1594 *
1595 * @since 2.1.0
1596 *
1597 * @param mixed $thing The variable to check.
1598 * @return bool Whether the variable is an instance of WP_Error.
1599 */
1600function is_wp_error( $thing ) {
1601 $is_wp_error = ( $thing instanceof WP_Error );
1602
1603 if ( $is_wp_error ) {
1604 /**
1605 * Fires when `is_wp_error()` is called and its parameter is an instance of `WP_Error`.
1606 *
1607 * @since 5.6.0
1608 *
1609 * @param WP_Error $thing The error object passed to `is_wp_error()`.
1610 */
1611 do_action( 'is_wp_error_instance', $thing );
1612 }
1613
1614 return $is_wp_error;
1615}
1616
1617/**
1618 * Determines whether file modifications are allowed.
1619 *
1620 * @since 4.8.0
1621 *
1622 * @param string $context The usage context.
1623 * @return bool True if file modification is allowed, false otherwise.
1624 */
1625function wp_is_file_mod_allowed( $context ) {
1626 /**
1627 * Filters whether file modifications are allowed.
1628 *
1629 * @since 4.8.0
1630 *
1631 * @param bool $file_mod_allowed Whether file modifications are allowed.
1632 * @param string $context The usage context.
1633 */
1634 return apply_filters( 'file_mod_allowed', ! defined( 'DISALLOW_FILE_MODS' ) || ! DISALLOW_FILE_MODS, $context );
1635}
1636
1637/**
1638 * Start scraping edited file errors.
1639 *
1640 * @since 4.9.0
1641 */
1642function wp_start_scraping_edited_file_errors() {
1643 if ( ! isset( $_REQUEST['wp_scrape_key'] ) || ! isset( $_REQUEST['wp_scrape_nonce'] ) ) {
1644 return;
1645 }
1646 $key = substr( sanitize_key( wp_unslash( $_REQUEST['wp_scrape_key'] ) ), 0, 32 );
1647 $nonce = wp_unslash( $_REQUEST['wp_scrape_nonce'] );
1648
1649 if ( get_transient( 'scrape_key_' . $key ) !== $nonce ) {
1650 echo "###### wp_scraping_result_start:$key ######";
1651 echo wp_json_encode(
1652 array(
1653 'code' => 'scrape_nonce_failure',
1654 'message' => __( 'Scrape key check failed. Please try again.' ),
1655 )
1656 );
1657 echo "###### wp_scraping_result_end:$key ######";
1658 die();
1659 }
1660 if ( ! defined( 'WP_SANDBOX_SCRAPING' ) ) {
1661 define( 'WP_SANDBOX_SCRAPING', true );
1662 }
1663 register_shutdown_function( 'wp_finalize_scraping_edited_file_errors', $key );
1664}
1665
1666/**
1667 * Finalize scraping for edited file errors.
1668 *
1669 * @since 4.9.0
1670 *
1671 * @param string $scrape_key Scrape key.
1672 */
1673function wp_finalize_scraping_edited_file_errors( $scrape_key ) {
1674 $error = error_get_last();
1675 echo "\n###### wp_scraping_result_start:$scrape_key ######\n";
1676 if ( ! empty( $error ) && in_array( $error['type'], array( E_CORE_ERROR, E_COMPILE_ERROR, E_ERROR, E_PARSE, E_USER_ERROR, E_RECOVERABLE_ERROR ), true ) ) {
1677 $error = str_replace( ABSPATH, '', $error );
1678 echo wp_json_encode( $error );
1679 } else {
1680 echo wp_json_encode( true );
1681 }
1682 echo "\n###### wp_scraping_result_end:$scrape_key ######\n";
1683}
1684
1685/**
1686 * Checks whether current request is a JSON request, or is expecting a JSON response.
1687 *
1688 * @since 5.0.0
1689 *
1690 * @return bool True if `Accepts` or `Content-Type` headers contain `application/json`.
1691 * False otherwise.
1692 */
1693function wp_is_json_request() {
1694
1695 if ( isset( $_SERVER['HTTP_ACCEPT'] ) && wp_is_json_media_type( $_SERVER['HTTP_ACCEPT'] ) ) {
1696 return true;
1697 }
1698
1699 if ( isset( $_SERVER['CONTENT_TYPE'] ) && wp_is_json_media_type( $_SERVER['CONTENT_TYPE'] ) ) {
1700 return true;
1701 }
1702
1703 return false;
1704
1705}
1706
1707/**
1708 * Checks whether current request is a JSONP request, or is expecting a JSONP response.
1709 *
1710 * @since 5.2.0
1711 *
1712 * @return bool True if JSONP request, false otherwise.
1713 */
1714function wp_is_jsonp_request() {
1715 if ( ! isset( $_GET['_jsonp'] ) ) {
1716 return false;
1717 }
1718
1719 if ( ! function_exists( 'wp_check_jsonp_callback' ) ) {
1720 require_once ABSPATH . WPINC . '/functions.php';
1721 }
1722
1723 $jsonp_callback = $_GET['_jsonp'];
1724 if ( ! wp_check_jsonp_callback( $jsonp_callback ) ) {
1725 return false;
1726 }
1727
1728 /** This filter is documented in wp-includes/rest-api/class-wp-rest-server.php */
1729 $jsonp_enabled = apply_filters( 'rest_jsonp_enabled', true );
1730
1731 return $jsonp_enabled;
1732
1733}
1734
1735/**
1736 * Checks whether a string is a valid JSON Media Type.
1737 *
1738 * @since 5.6.0
1739 *
1740 * @param string $media_type A Media Type string to check.
1741 * @return bool True if string is a valid JSON Media Type.
1742 */
1743function wp_is_json_media_type( $media_type ) {
1744 static $cache = array();
1745
1746 if ( ! isset( $cache[ $media_type ] ) ) {
1747 $cache[ $media_type ] = (bool) preg_match( '/(^|\s|,)application\/([\w!#\$&-\^\.\+]+\+)?json(\+oembed)?($|\s|;|,)/i', $media_type );
1748 }
1749
1750 return $cache[ $media_type ];
1751}
1752
1753/**
1754 * Checks whether current request is an XML request, or is expecting an XML response.
1755 *
1756 * @since 5.2.0
1757 *
1758 * @return bool True if `Accepts` or `Content-Type` headers contain `text/xml`
1759 * or one of the related MIME types. False otherwise.
1760 */
1761function wp_is_xml_request() {
1762 $accepted = array(
1763 'text/xml',
1764 'application/rss+xml',
1765 'application/atom+xml',
1766 'application/rdf+xml',
1767 'text/xml+oembed',
1768 'application/xml+oembed',
1769 );
1770
1771 if ( isset( $_SERVER['HTTP_ACCEPT'] ) ) {
1772 foreach ( $accepted as $type ) {
1773 if ( false !== strpos( $_SERVER['HTTP_ACCEPT'], $type ) ) {
1774 return true;
1775 }
1776 }
1777 }
1778
1779 if ( isset( $_SERVER['CONTENT_TYPE'] ) && in_array( $_SERVER['CONTENT_TYPE'], $accepted, true ) ) {
1780 return true;
1781 }
1782
1783 return false;
1784}
1785
1786/**
1787 * Checks if this site is protected by HTTP Basic Auth.
1788 *
1789 * At the moment, this merely checks for the present of Basic Auth credentials. Therefore, calling
1790 * this function with a context different from the current context may give inaccurate results.
1791 * In a future release, this evaluation may be made more robust.
1792 *
1793 * Currently, this is only used by Application Passwords to prevent a conflict since it also utilizes
1794 * Basic Auth.
1795 *
1796 * @since 5.6.1
1797 *
1798 * @global string $pagenow The filename of the current screen.
1799 *
1800 * @param string $context The context to check for protection. Accepts 'login', 'admin', and 'front'.
1801 * Defaults to the current context.
1802 * @return bool Whether the site is protected by Basic Auth.
1803 */
1804function wp_is_site_protected_by_basic_auth( $context = '' ) {
1805 global $pagenow;
1806
1807 if ( ! $context ) {
1808 if ( 'wp-login.php' === $pagenow ) {
1809 $context = 'login';
1810 } elseif ( is_admin() ) {
1811 $context = 'admin';
1812 } else {
1813 $context = 'front';
1814 }
1815 }
1816
1817 $is_protected = ! empty( $_SERVER['PHP_AUTH_USER'] ) || ! empty( $_SERVER['PHP_AUTH_PW'] );
1818
1819 /**
1820 * Filters whether a site is protected by HTTP Basic Auth.
1821 *
1822 * @since 5.6.1
1823 *
1824 * @param bool $is_protected Whether the site is protected by Basic Auth.
1825 * @param string $context The context to check for protection. One of 'login', 'admin', or 'front'.
1826 */
1827 return apply_filters( 'wp_is_site_protected_by_basic_auth', $is_protected, $context );
1828}