VasUpsiy

1<?php
2/**
3 * Main WordPress API
4 *
5 * @package WordPress
6 */
7
8require( ABSPATH . WPINC . '/option.php' );
9
10/**
11 * Convert given date string into a different format.
12 *
13 * $format should be either a PHP date format string, e.g. 'U' for a Unix
14 * timestamp, or 'G' for a Unix timestamp assuming that $date is GMT.
15 *
16 * If $translate is true then the given date and format string will
17 * be passed to date_i18n() for translation.
18 *
19 * @since 0.71
20 *
21 * @param string $format    Format of the date to return.
22 * @param string $date      Date string to convert.
23 * @param bool   $translate Whether the return date should be translated. Default true.
24 * @return string|int|bool Formatted date string or Unix timestamp. False if $date is empty.
25 */
26function mysql2date( $format, $date, $translate = true ) {
27	if ( empty( $date ) )
28		return false;
29
30	if ( 'G' == $format )
31		return strtotime( $date . ' +0000' );
32
33	$i = strtotime( $date );
34
35	if ( 'U' == $format )
36		return $i;
37
38	if ( $translate )
39		return date_i18n( $format, $i );
40	else
41		return date( $format, $i );
42}
43
44/**
45 * Retrieve the current time based on specified type.
46 *
47 * The 'mysql' type will return the time in the format for MySQL DATETIME field.
48 * The 'timestamp' type will return the current timestamp.
49 * Other strings will be interpreted as PHP date formats (e.g. 'Y-m-d').
50 *
51 * If $gmt is set to either '1' or 'true', then both types will use GMT time.
52 * if $gmt is false, the output is adjusted with the GMT offset in the WordPress option.
53 *
54 * @since 1.0.0
55 *
56 * @param string   $type Type of time to retrieve. Accepts 'mysql', 'timestamp', or PHP date
57 *                       format string (e.g. 'Y-m-d').
58 * @param int|bool $gmt  Optional. Whether to use GMT timezone. Default false.
59 * @return int|string Integer if $type is 'timestamp', string otherwise.
60 */
61function current_time( $type, $gmt = 0 ) {
62	switch ( $type ) {
63		case 'mysql':
64			return ( $gmt ) ? gmdate( 'Y-m-d H:i:s' ) : gmdate( 'Y-m-d H:i:s', ( time() + ( get_option( 'gmt_offset' ) * HOUR_IN_SECONDS ) ) );
65		case 'timestamp':
66			return ( $gmt ) ? time() : time() + ( get_option( 'gmt_offset' ) * HOUR_IN_SECONDS );
67		default:
68			return ( $gmt ) ? date( $type ) : date( $type, time() + ( get_option( 'gmt_offset' ) * HOUR_IN_SECONDS ) );
69	}
70}
71
72/**
73 * Retrieve the date in localized format, based on timestamp.
74 *
75 * If the locale specifies the locale month and weekday, then the locale will
76 * take over the format for the date. If it isn't, then the date format string
77 * will be used instead.
78 *
79 * @since 0.71
80 *
81 * @global WP_Locale $wp_locale
82 *
83 * @param string   $dateformatstring Format to display the date.
84 * @param bool|int $unixtimestamp    Optional. Unix timestamp. Default false.
85 * @param bool     $gmt              Optional. Whether to use GMT timezone. Default false.
86 *
87 * @return string The date, translated if locale specifies it.
88 */
89function date_i18n( $dateformatstring, $unixtimestamp = false, $gmt = false ) {
90	global $wp_locale;
91	$i = $unixtimestamp;
92
93	if ( false === $i ) {
94		if ( ! $gmt )
95			$i = current_time( 'timestamp' );
96		else
97			$i = time();
98		// we should not let date() interfere with our
99		// specially computed timestamp
100		$gmt = true;
101	}
102
103	/*
104	 * Store original value for language with untypical grammars.
105	 * See https://core.trac.wordpress.org/ticket/9396
106	 */
107	$req_format = $dateformatstring;
108
109	$datefunc = $gmt? 'gmdate' : 'date';
110
111	if ( ( !empty( $wp_locale->month ) ) && ( !empty( $wp_locale->weekday ) ) ) {
112		$datemonth = $wp_locale->get_month( $datefunc( 'm', $i ) );
113		$datemonth_abbrev = $wp_locale->get_month_abbrev( $datemonth );
114		$dateweekday = $wp_locale->get_weekday( $datefunc( 'w', $i ) );
115		$dateweekday_abbrev = $wp_locale->get_weekday_abbrev( $dateweekday );
116		$datemeridiem = $wp_locale->get_meridiem( $datefunc( 'a', $i ) );
117		$datemeridiem_capital = $wp_locale->get_meridiem( $datefunc( 'A', $i ) );
118		$dateformatstring = ' '.$dateformatstring;
119		$dateformatstring = preg_replace( "/([^\\\])D/", "\\1" . backslashit( $dateweekday_abbrev ), $dateformatstring );
120		$dateformatstring = preg_replace( "/([^\\\])F/", "\\1" . backslashit( $datemonth ), $dateformatstring );
121		$dateformatstring = preg_replace( "/([^\\\])l/", "\\1" . backslashit( $dateweekday ), $dateformatstring );
122		$dateformatstring = preg_replace( "/([^\\\])M/", "\\1" . backslashit( $datemonth_abbrev ), $dateformatstring );
123		$dateformatstring = preg_replace( "/([^\\\])a/", "\\1" . backslashit( $datemeridiem ), $dateformatstring );
124		$dateformatstring = preg_replace( "/([^\\\])A/", "\\1" . backslashit( $datemeridiem_capital ), $dateformatstring );
125
126		$dateformatstring = substr( $dateformatstring, 1, strlen( $dateformatstring ) -1 );
127	}
128	$timezone_formats = array( 'P', 'I', 'O', 'T', 'Z', 'e' );
129	$timezone_formats_re = implode( '|', $timezone_formats );
130	if ( preg_match( "/$timezone_formats_re/", $dateformatstring ) ) {
131		$timezone_string = get_option( 'timezone_string' );
132		if ( $timezone_string ) {
133			$timezone_object = timezone_open( $timezone_string );
134			$date_object = date_create( null, $timezone_object );
135			foreach ( $timezone_formats as $timezone_format ) {
136				if ( false !== strpos( $dateformatstring, $timezone_format ) ) {
137					$formatted = date_format( $date_object, $timezone_format );
138					$dateformatstring = ' '.$dateformatstring;
139					$dateformatstring = preg_replace( "/([^\\\])$timezone_format/", "\\1" . backslashit( $formatted ), $dateformatstring );
140					$dateformatstring = substr( $dateformatstring, 1, strlen( $dateformatstring ) -1 );
141				}
142			}
143		}
144	}
145	$j = @$datefunc( $dateformatstring, $i );
146
147	/**
148	 * Filter the date formatted based on the locale.
149	 *
150	 * @since 2.8.0
151	 *
152	 * @param string $j          Formatted date string.
153	 * @param string $req_format Format to display the date.
154	 * @param int    $i          Unix timestamp.
155	 * @param bool   $gmt        Whether to convert to GMT for time. Default false.
156	 */
157	$j = apply_filters( 'date_i18n', $j, $req_format, $i, $gmt );
158	return $j;
159}
160
161/**
162 * Determines if the date should be declined.
163 *
164 * If the locale specifies that month names require a genitive case in certain
165 * formats (like 'j F Y'), the month name will be replaced with a correct form.
166 *
167 * @since 4.4.0
168 *
169 * @param string $date Formatted date string.
170 * @return string The date, declined if locale specifies it.
171 */
172function wp_maybe_decline_date( $date ) {
173	global $wp_locale;
174
175	// i18n functions are not available in SHORTINIT mode
176	if ( ! function_exists( '_x' ) ) {
177		return $date;
178	}
179
180	/* translators: If months in your language require a genitive case,
181	 * translate this to 'on'. Do not translate into your own language.
182	 */
183	if ( 'on' === _x( 'off', 'decline months names: on or off' ) ) {
184		// Match a format like 'j F Y' or 'j. F'
185		if ( @preg_match( '#^\d{1,2}\.? \w+#u', $date ) ) {
186			$months = $wp_locale->month;
187
188			foreach ( $months as $key => $month ) {
189				$months[ $key ] = '#' . $month . '#';
190			}
191
192			$date = preg_replace( $months, $wp_locale->month_genitive, $date );
193		}
194	}
195
196	// Used for locale-specific rules
197	$locale = get_locale();
198
199	if ( 'ca' === $locale ) {
200		// " de abril| de agost| de octubre..." -> " d'abril| d'agost| d'octubre..."
201		$date = preg_replace( '# de ([ao])#i', " d'\\1", $date );
202	}
203
204	return $date;
205}
206
207/**
208 * Convert float number to format based on the locale.
209 *
210 * @since 2.3.0
211 *
212 * @global WP_Locale $wp_locale
213 *
214 * @param float $number   The number to convert based on locale.
215 * @param int   $decimals Optional. Precision of the number of decimal places. Default 0.
216 * @return string Converted number in string format.
217 */
218function number_format_i18n( $number, $decimals = 0 ) {
219	global $wp_locale;
220
221	if ( isset( $wp_locale ) ) {
222		$formatted = number_format( $number, absint( $decimals ), $wp_locale->number_format['decimal_point'], $wp_locale->number_format['thousands_sep'] );
223	} else {
224		$formatted = number_format( $number, absint( $decimals ) );
225	}
226
227	/**
228	 * Filter the number formatted based on the locale.
229	 *
230	 * @since  2.8.0
231	 *
232	 * @param string $formatted Converted number in string format.
233	 */
234	return apply_filters( 'number_format_i18n', $formatted );
235}
236
237/**
238 * Convert number of bytes largest unit bytes will fit into.
239 *
240 * It is easier to read 1 kB than 1024 bytes and 1 MB than 1048576 bytes. Converts
241 * number of bytes to human readable number by taking the number of that unit
242 * that the bytes will go into it. Supports TB value.
243 *
244 * Please note that integers in PHP are limited to 32 bits, unless they are on
245 * 64 bit architecture, then they have 64 bit size. If you need to place the
246 * larger size then what PHP integer type will hold, then use a string. It will
247 * be converted to a double, which should always have 64 bit length.
248 *
249 * Technically the correct unit names for powers of 1024 are KiB, MiB etc.
250 *
251 * @since 2.3.0
252 *
253 * @param int|string $bytes    Number of bytes. Note max integer size for integers.
254 * @param int        $decimals Optional. Precision of number of decimal places. Default 0.
255 * @return string|false False on failure. Number string on success.
256 */
257function size_format( $bytes, $decimals = 0 ) {
258	$quant = array(
259		'TB' => TB_IN_BYTES,
260		'GB' => GB_IN_BYTES,
261		'MB' => MB_IN_BYTES,
262		'kB' => KB_IN_BYTES,
263		'B'  => 1,
264	);
265
266	foreach ( $quant as $unit => $mag ) {
267		if ( doubleval( $bytes ) >= $mag ) {
268			return number_format_i18n( $bytes / $mag, $decimals ) . ' ' . $unit;
269		}
270	}
271
272	return false;
273}
274
275/**
276 * Get the week start and end from the datetime or date string from MySQL.
277 *
278 * @since 0.71
279 *
280 * @param string     $mysqlstring   Date or datetime field type from MySQL.
281 * @param int|string $start_of_week Optional. Start of the week as an integer. Default empty string.
282 * @return array Keys are 'start' and 'end'.
283 */
284function get_weekstartend( $mysqlstring, $start_of_week = '' ) {
285	// MySQL string year.
286	$my = substr( $mysqlstring, 0, 4 );
287
288	// MySQL string month.
289	$mm = substr( $mysqlstring, 8, 2 );
290
291	// MySQL string day.
292	$md = substr( $mysqlstring, 5, 2 );
293
294	// The timestamp for MySQL string day.
295	$day = mktime( 0, 0, 0, $md, $mm, $my );
296
297	// The day of the week from the timestamp.
298	$weekday = date( 'w', $day );
299
300	if ( !is_numeric($start_of_week) )
301		$start_of_week = get_option( 'start_of_week' );
302
303	if ( $weekday < $start_of_week )
304		$weekday += 7;
305
306	// The most recent week start day on or before $day.
307	$start = $day - DAY_IN_SECONDS * ( $weekday - $start_of_week );
308
309	// $start + 1 week - 1 second.
310	$end = $start + WEEK_IN_SECONDS - 1;
311	return compact( 'start', 'end' );
312}
313
314/**
315 * Unserialize value only if it was serialized.
316 *
317 * @since 2.0.0
318 *
319 * @param string $original Maybe unserialized original, if is needed.
320 * @return mixed Unserialized data can be any type.
321 */
322function maybe_unserialize( $original ) {
323	if ( is_serialized( $original ) ) // don't attempt to unserialize data that wasn't serialized going in
324		return @unserialize( $original );
325	return $original;
326}
327
328/**
329 * Check value to find if it was serialized.
330 *
331 * If $data is not an string, then returned value will always be false.
332 * Serialized data is always a string.
333 *
334 * @since 2.0.5
335 *
336 * @param string $data   Value to check to see if was serialized.
337 * @param bool   $strict Optional. Whether to be strict about the end of the string. Default true.
338 * @return bool False if not serialized and true if it was.
339 */
340function is_serialized( $data, $strict = true ) {
341	// if it isn't a string, it isn't serialized.
342	if ( ! is_string( $data ) ) {
343		return false;
344	}
345	$data = trim( $data );
346 	if ( 'N;' == $data ) {
347		return true;
348	}
349	if ( strlen( $data ) < 4 ) {
350		return false;
351	}
352	if ( ':' !== $data[1] ) {
353		return false;
354	}
355	if ( $strict ) {
356		$lastc = substr( $data, -1 );
357		if ( ';' !== $lastc && '}' !== $lastc ) {
358			return false;
359		}
360	} else {
361		$semicolon = strpos( $data, ';' );
362		$brace     = strpos( $data, '}' );
363		// Either ; or } must exist.
364		if ( false === $semicolon && false === $brace )
365			return false;
366		// But neither must be in the first X characters.
367		if ( false !== $semicolon && $semicolon < 3 )
368			return false;
369		if ( false !== $brace && $brace < 4 )
370			return false;
371	}
372	$token = $data[0];
373	switch ( $token ) {
374		case 's' :
375			if ( $strict ) {
376				if ( '"' !== substr( $data, -2, 1 ) ) {
377					return false;
378				}
379			} elseif ( false === strpos( $data, '"' ) ) {
380				return false;
381			}
382			// or else fall through
383		case 'a' :
384		case 'O' :
385			return (bool) preg_match( "/^{$token}:[0-9]+:/s", $data );
386		case 'b' :
387		case 'i' :
388		case 'd' :
389			$end = $strict ? '$' : '';
390			return (bool) preg_match( "/^{$token}:[0-9.E-]+;$end/", $data );
391	}
392	return false;
393}
394
395/**
396 * Check whether serialized data is of string type.
397 *
398 * @since 2.0.5
399 *
400 * @param string $data Serialized data.
401 * @return bool False if not a serialized string, true if it is.
402 */
403function is_serialized_string( $data ) {
404	// if it isn't a string, it isn't a serialized string.
405	if ( ! is_string( $data ) ) {
406		return false;
407	}
408	$data = trim( $data );
409	if ( strlen( $data ) < 4 ) {
410		return false;
411	} elseif ( ':' !== $data[1] ) {
412		return false;
413	} elseif ( ';' !== substr( $data, -1 ) ) {
414		return false;
415	} elseif ( $data[0] !== 's' ) {
416		return false;
417	} elseif ( '"' !== substr( $data, -2, 1 ) ) {
418		return false;
419	} else {
420		return true;
421	}
422}
423
424/**
425 * Serialize data, if needed.
426 *
427 * @since 2.0.5
428 *
429 * @param string|array|object $data Data that might be serialized.
430 * @return mixed A scalar data
431 */
432function maybe_serialize( $data ) {
433	if ( is_array( $data ) || is_object( $data ) )
434		return serialize( $data );
435
436	// Double serialization is required for backward compatibility.
437	// See https://core.trac.wordpress.org/ticket/12930
438	// Also the world will end. See WP 3.6.1.
439	if ( is_serialized( $data, false ) )
440		return serialize( $data );
441
442	return $data;
443}
444
445/**
446 * Retrieve post title from XMLRPC XML.
447 *
448 * If the title element is not part of the XML, then the default post title from
449 * the $post_default_title will be used instead.
450 *
451 * @since 0.71
452 *
453 * @global string $post_default_title Default XML-RPC post title.
454 *
455 * @param string $content XMLRPC XML Request content
456 * @return string Post title
457 */
458function xmlrpc_getposttitle( $content ) {
459	global $post_default_title;
460	if ( preg_match( '/<title>(.+?)<\/title>/is', $content, $matchtitle ) ) {
461		$post_title = $matchtitle[1];
462	} else {
463		$post_title = $post_default_title;
464	}
465	return $post_title;
466}
467
468/**
469 * Retrieve the post category or categories from XMLRPC XML.
470 *
471 * If the category element is not found, then the default post category will be
472 * used. The return type then would be what $post_default_category. If the
473 * category is found, then it will always be an array.
474 *
475 * @since 0.71
476 *
477 * @global string $post_default_category Default XML-RPC post category.
478 *
479 * @param string $content XMLRPC XML Request content
480 * @return string|array List of categories or category name.
481 */
482function xmlrpc_getpostcategory( $content ) {
483	global $post_default_category;
484	if ( preg_match( '/<category>(.+?)<\/category>/is', $content, $matchcat ) ) {
485		$post_category = trim( $matchcat[1], ',' );
486		$post_category = explode( ',', $post_category );
487	} else {
488		$post_category = $post_default_category;
489	}
490	return $post_category;
491}
492
493/**
494 * XMLRPC XML content without title and category elements.
495 *
496 * @since 0.71
497 *
498 * @param string $content XML-RPC XML Request content.
499 * @return string XMLRPC XML Request content without title and category elements.
500 */
501function xmlrpc_removepostdata( $content ) {
502	$content = preg_replace( '/<title>(.+?)<\/title>/si', '', $content );
503	$content = preg_replace( '/<category>(.+?)<\/category>/si', '', $content );
504	$content = trim( $content );
505	return $content;
506}
507
508/**
509 * Use RegEx to extract URLs from arbitrary content.
510 *
511 * @since 3.7.0
512 *
513 * @param string $content Content to extract URLs from.
514 * @return array URLs found in passed string.
515 */
516function wp_extract_urls( $content ) {
517	preg_match_all(
518		"#([\"']?)("
519			. "(?:([\w-]+:)?//?)"
520			. "[^\s()<>]+"
521			. "[.]"
522			. "(?:"
523				. "\([\w\d]+\)|"
524				. "(?:"
525					. "[^`!()\[\]{};:'\".,<>«»“”‘’\s]|"
526					. "(?:[:]\d+)?/?"
527				. ")+"
528			. ")"
529		. ")\\1#",
530		$content,
531		$post_links
532	);
533
534	$post_links = array_unique( array_map( 'html_entity_decode', $post_links[2] ) );
535
536	return array_values( $post_links );
537}
538
539/**
540 * Check content for video and audio links to add as enclosures.
541 *
542 * Will not add enclosures that have already been added and will
543 * remove enclosures that are no longer in the post. This is called as
544 * pingbacks and trackbacks.
545 *
546 * @since 1.5.0
547 *
548 * @global wpdb $wpdb WordPress database abstraction object.
549 *
550 * @param string $content Post Content.
551 * @param int    $post_ID Post ID.
552 */
553function do_enclose( $content, $post_ID ) {
554	global $wpdb;
555
556	//TODO: Tidy this ghetto code up and make the debug code optional
557	include_once( ABSPATH . WPINC . '/class-IXR.php' );
558
559	$post_links = array();
560
561	$pung = get_enclosed( $post_ID );
562
563	$post_links_temp = wp_extract_urls( $content );
564
565	foreach ( $pung as $link_test ) {
566		if ( ! in_array( $link_test, $post_links_temp ) ) { // link no longer in post
567			$mids = $wpdb->get_col( $wpdb->prepare("SELECT meta_id FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = 'enclosure' AND meta_value LIKE %s", $post_ID, $wpdb->esc_like( $link_test ) . '%') );
568			foreach ( $mids as $mid )
569				delete_metadata_by_mid( 'post', $mid );
570		}
571	}
572
573	foreach ( (array) $post_links_temp as $link_test ) {
574		if ( !in_array( $link_test, $pung ) ) { // If we haven't pung it already
575			$test = @parse_url( $link_test );
576			if ( false === $test )
577				continue;
578			if ( isset( $test['query'] ) )
579				$post_links[] = $link_test;
580			elseif ( isset($test['path']) && ( $test['path'] != '/' ) &&  ($test['path'] != '' ) )
581				$post_links[] = $link_test;
582		}
583	}
584
585	/**
586	 * Filter the list of enclosure links before querying the database.
587	 *
588	 * Allows for the addition and/or removal of potential enclosures to save
589	 * to postmeta before checking the database for existing enclosures.
590	 *
591	 * @since 4.4.0
592	 *
593	 * @param array $post_links An array of enclosure links.
594	 * @param int   $post_ID    Post ID.
595	 */
596	$post_links = apply_filters( 'enclosure_links', $post_links, $post_ID );
597
598	foreach ( (array) $post_links as $url ) {
599		if ( $url != '' && !$wpdb->get_var( $wpdb->prepare( "SELECT post_id FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = 'enclosure' AND meta_value LIKE %s", $post_ID, $wpdb->esc_like( $url ) . '%' ) ) ) {
600
601			if ( $headers = wp_get_http_headers( $url) ) {
602				$len = isset( $headers['content-length'] ) ? (int) $headers['content-length'] : 0;
603				$type = isset( $headers['content-type'] ) ? $headers['content-type'] : '';
604				$allowed_types = array( 'video', 'audio' );
605
606				// Check to see if we can figure out the mime type from
607				// the extension
608				$url_parts = @parse_url( $url );
609				if ( false !== $url_parts ) {
610					$extension = pathinfo( $url_parts['path'], PATHINFO_EXTENSION );
611					if ( !empty( $extension ) ) {
612						foreach ( wp_get_mime_types() as $exts => $mime ) {
613							if ( preg_match( '!^(' . $exts . ')$!i', $extension ) ) {
614								$type = $mime;
615								break;
616							}
617						}
618					}
619				}
620
621				if ( in_array( substr( $type, 0, strpos( $type, "/" ) ), $allowed_types ) ) {
622					add_post_meta( $post_ID, 'enclosure', "$url\n$len\n$mime\n" );
623				}
624			}
625		}
626	}
627}
628
629/**
630 * Retrieve HTTP Headers from URL.
631 *
632 * @since 1.5.1
633 *
634 * @param string $url        URL to retrieve HTTP headers from.
635 * @param bool   $deprecated Not Used.
636 * @return bool|string False on failure, headers on success.
637 */
638function wp_get_http_headers( $url, $deprecated = false ) {
639	if ( !empty( $deprecated ) )
640		_deprecated_argument( __FUNCTION__, '2.7' );
641
642	$response = wp_safe_remote_head( $url );
643
644	if ( is_wp_error( $response ) )
645		return false;
646
647	return wp_remote_retrieve_headers( $response );
648}
649
650/**
651 * Whether the publish date of the current post in the loop is different from the
652 * publish date of the previous post in the loop.
653 *
654 * @since 0.71
655 *
656 * @global string $currentday  The day of the current post in the loop.
657 * @global string $previousday The day of the previous post in the loop.
658 *
659 * @return int 1 when new day, 0 if not a new day.
660 */
661function is_new_day() {
662	global $currentday, $previousday;
663	if ( $currentday != $previousday )
664		return 1;
665	else
666		return 0;
667}
668
669/**
670 * Build URL query based on an associative and, or indexed array.
671 *
672 * This is a convenient function for easily building url queries. It sets the
673 * separator to '&' and uses _http_build_query() function.
674 *
675 * @since 2.3.0
676 *
677 * @see _http_build_query() Used to build the query
678 * @link http://us2.php.net/manual/en/function.http-build-query.php for more on what
679 *		 http_build_query() does.
680 *
681 * @param array $data URL-encode key/value pairs.
682 * @return string URL-encoded string.
683 */
684function build_query( $data ) {
685	return _http_build_query( $data, null, '&', '', false );
686}
687
688/**
689 * From php.net (modified by Mark Jaquith to behave like the native PHP5 function).
690 *
691 * @since 3.2.0
692 * @access private
693 *
694 * @see http://us1.php.net/manual/en/function.http-build-query.php
695 *
696 * @param array|object  $data       An array or object of data. Converted to array.
697 * @param string        $prefix     Optional. Numeric index. If set, start parameter numbering with it.
698 *                                  Default null.
699 * @param string        $sep        Optional. Argument separator; defaults to 'arg_separator.output'.
700 *                                  Default null.
701 * @param string        $key        Optional. Used to prefix key name. Default empty.
702 * @param bool          $urlencode  Optional. Whether to use urlencode() in the result. Default true.
703 *
704 * @return string The query string.
705 */
706function _http_build_query( $data, $prefix = null, $sep = null, $key = '', $urlencode = true ) {
707	$ret = array();
708
709	foreach ( (array) $data as $k => $v ) {
710		if ( $urlencode)
711			$k = urlencode($k);
712		if ( is_int($k) && $prefix != null )
713			$k = $prefix.$k;
714		if ( !empty($key) )
715			$k = $key . '%5B' . $k . '%5D';
716		if ( $v === null )
717			continue;
718		elseif ( $v === false )
719			$v = '0';
720
721		if ( is_array($v) || is_object($v) )
722			array_push($ret,_http_build_query($v, '', $sep, $k, $urlencode));
723		elseif ( $urlencode )
724			array_push($ret, $k.'='.urlencode($v));
725		else
726			array_push($ret, $k.'='.$v);
727	}
728
729	if ( null === $sep )
730		$sep = ini_get('arg_separator.output');
731
732	return implode($sep, $ret);
733}
734
735/**
736 * Retrieves a modified URL query string.
737 *
738 * You can rebuild the URL and append query variables to the URL query by using this function.
739 * There are two ways to use this function; either a single key and value, or an associative array.
740 *
741 * Using a single key and value:
742 *
743 *     add_query_arg( 'key', 'value', 'http://example.com' );
744 *
745 * Using an associative array:
746 *
747 *     add_query_arg( array(
748 *         'key1' => 'value1',
749 *         'key2' => 'value2',
750 *     ), 'http://example.com' );
751 *
752 * Omitting the URL from either use results in the current URL being used
753 * (the value of `$_SERVER['REQUEST_URI']`).
754 *
755 * Values are expected to be encoded appropriately with urlencode() or rawurlencode().
756 *
757 * Setting any query variable's value to boolean false removes the key (see remove_query_arg()).
758 *
759 * Important: The return value of add_query_arg() is not escaped by default. Output should be
760 * late-escaped with esc_url() or similar to help prevent vulnerability to cross-site scripting
761 * (XSS) attacks.
762 *
763 * @since 1.5.0
764 *
765 * @param string|array $key   Either a query variable key, or an associative array of query variables.
766 * @param string       $value Optional. Either a query variable value, or a URL to act upon.
767 * @param string       $url   Optional. A URL to act upon.
768 * @return string New URL query string (unescaped).
769 */
770function add_query_arg() {
771	$args = func_get_args();
772	if ( is_array( $args[0] ) ) {
773		if ( count( $args ) < 2 || false === $args[1] )
774			$uri = $_SERVER['REQUEST_URI'];
775		else
776			$uri = $args[1];
777	} else {
778		if ( count( $args ) < 3 || false === $args[2] )
779			$uri = $_SERVER['REQUEST_URI'];
780		else
781			$uri = $args[2];
782	}
783
784	if ( $frag = strstr( $uri, '#' ) )
785		$uri = substr( $uri, 0, -strlen( $frag ) );
786	else
787		$frag = '';
788
789	if ( 0 === stripos( $uri, 'http://' ) ) {
790		$protocol = 'http://';
791		$uri = substr( $uri, 7 );
792	} elseif ( 0 === stripos( $uri, 'https://' ) ) {
793		$protocol = 'https://';
794		$uri = substr( $uri, 8 );
795	} else {
796		$protocol = '';
797	}
798
799	if ( strpos( $uri, '?' ) !== false ) {
800		list( $base, $query ) = explode( '?', $uri, 2 );
801		$base .= '?';
802	} elseif ( $protocol || strpos( $uri, '=' ) === false ) {
803		$base = $uri . '?';
804		$query = '';
805	} else {
806		$base = '';
807		$query = $uri;
808	}
809
810	wp_parse_str( $query, $qs );
811	$qs = urlencode_deep( $qs ); // this re-URL-encodes things that were already in the query string
812	if ( is_array( $args[0] ) ) {
813		foreach ( $args[0] as $k => $v ) {
814			$qs[ $k ] = $v;
815		}
816	} else {
817		$qs[ $args[0] ] = $args[1];
818	}
819
820	foreach ( $qs as $k => $v ) {
821		if ( $v === false )
822			unset( $qs[$k] );
823	}
824
825	$ret = build_query( $qs );
826	$ret = trim( $ret, '?' );
827	$ret = preg_replace( '#=(&|$)#', '$1', $ret );
828	$ret = $protocol . $base . $ret . $frag;
829	$ret = rtrim( $ret, '?' );
830	return $ret;
831}
832
833/**
834 * Removes an item or items from a query string.
835 *
836 * @since 1.5.0
837 *
838 * @param string|array $key   Query key or keys to remove.
839 * @param bool|string  $query Optional. When false uses the current URL. Default false.
840 * @return string New URL query string.
841 */
842function remove_query_arg( $key, $query = false ) {
843	if ( is_array( $key ) ) { // removing multiple keys
844		foreach ( $key as $k )
845			$query = add_query_arg( $k, false, $query );
846		return $query;
847	}
848	return add_query_arg( $key, false, $query );
849}
850
851/**
852 * Returns an array of single-use query variable names that can be removed from a URL.
853 *
854 * @since 4.4.0
855 *
856 * @return array An array of parameters to remove from the URL.
857 */
858function wp_removable_query_args() {
859	$removable_query_args = array(
860		'activate',
861		'activated',
862		'approved',
863		'deactivate',
864		'deleted',
865		'disabled',
866		'enabled',
867		'error',
868		'locked',
869		'message',
870		'same',
871		'saved',
872		'settings-updated',
873		'skipped',
874		'spammed',
875		'trashed',
876		'unspammed',
877		'untrashed',
878		'update',
879		'updated',
880		'wp-post-new-reload',
881	);
882
883	/**
884	 * Filter the list of query variables to remove.
885	 *
886	 * @since 4.2.0
887	 *
888	 * @param array $removable_query_args An array of query variables to remove from a URL.
889	 */
890	return apply_filters( 'removable_query_args', $removable_query_args );
891}
892
893/**
894 * Walks the array while sanitizing the contents.
895 *
896 * @since 0.71
897 *
898 * @param array $array Array to walk while sanitizing contents.
899 * @return array Sanitized $array.
900 */
901function add_magic_quotes( $array ) {
902	foreach ( (array) $array as $k => $v ) {
903		if ( is_array( $v ) ) {
904			$array[$k] = add_magic_quotes( $v );
905		} else {
906			$array[$k] = addslashes( $v );
907		}
908	}
909	return $array;
910}
911
912/**
913 * HTTP request for URI to retrieve content.
914 *
915 * @since 1.5.1
916 *
917 * @see wp_safe_remote_get()
918 *
919 * @param string $uri URI/URL of web page to retrieve.
920 * @return false|string HTTP content. False on failure.
921 */
922function wp_remote_fopen( $uri ) {
923	$parsed_url = @parse_url( $uri );
924
925	if ( !$parsed_url || !is_array( $parsed_url ) )
926		return false;
927
928	$options = array();
929	$options['timeout'] = 10;
930
931	$response = wp_safe_remote_get( $uri, $options );
932
933	if ( is_wp_error( $response ) )
934		return false;
935
936	return wp_remote_retrieve_body( $response );
937}
938
939/**
940 * Set up the WordPress query.
941 *
942 * @since 2.0.0
943 *
944 * @global WP       $wp_locale
945 * @global WP_Query $wp_query
946 * @global WP_Query $wp_the_query
947 *
948 * @param string|array $query_vars Default WP_Query arguments.
949 */
950function wp( $query_vars = '' ) {
951	global $wp, $wp_query, $wp_the_query;
952	$wp->main( $query_vars );
953
954	if ( !isset($wp_the_query) )
955		$wp_the_query = $wp_query;
956}
957
958/**
959 * Retrieve the description for the HTTP status.
960 *
961 * @since 2.3.0
962 *
963 * @global array $wp_header_to_desc
964 *
965 * @param int $code HTTP status code.
966 * @return string Empty string if not found, or description if found.
967 */
968function get_status_header_desc( $code ) {
969	global $wp_header_to_desc;
970
971	$code = absint( $code );
972
973	if ( !isset( $wp_header_to_desc ) ) {
974		$wp_header_to_desc = array(
975			100 => 'Continue',
976			101 => 'Switching Protocols',
977			102 => 'Processing',
978
979			200 => 'OK',
980			201 => 'Created',
981			202 => 'Accepted',
982			203 => 'Non-Authoritative Information',
983			204 => 'No Content',
984			205 => 'Reset Content',
985			206 => 'Partial Content',
986			207 => 'Multi-Status',
987			226 => 'IM Used',
988
989			300 => 'Multiple Choices',
990			301 => 'Moved Permanently',
991			302 => 'Found',
992			303 => 'See Other',
993			304 => 'Not Modified',
994			305 => 'Use Proxy',
995			306 => 'Reserved',
996			307 => 'Temporary Redirect',
997			308 => 'Permanent Redirect',
998
999			400 => 'Bad Request',
1000			401 => 'Unauthorized',
1001			402 => 'Payment Required',
1002			403 => 'Forbidden',
1003			404 => 'Not Found',
1004			405 => 'Method Not Allowed',
1005			406 => 'Not Acceptable',
1006			407 => 'Proxy Authentication Required',
1007			408 => 'Request Timeout',
1008			409 => 'Conflict',
1009			410 => 'Gone',
1010			411 => 'Length Required',
1011			412 => 'Precondition Failed',
1012			413 => 'Request Entity Too Large',
1013			414 => 'Request-URI Too Long',
1014			415 => 'Unsupported Media Type',
1015			416 => 'Requested Range Not Satisfiable',
1016			417 => 'Expectation Failed',
1017			418 => 'I\'m a teapot',
1018			421 => 'Misdirected Request',
1019			422 => 'Unprocessable Entity',
1020			423 => 'Locked',
1021			424 => 'Failed Dependency',
1022			426 => 'Upgrade Required',
1023			428 => 'Precondition Required',
1024			429 => 'Too Many Requests',
1025			431 => 'Request Header Fields Too Large',
1026			451 => 'Unavailable For Legal Reasons',
1027
1028			500 => 'Internal Server Error',
1029			501 => 'Not Implemented',
1030			502 => 'Bad Gateway',
1031			503 => 'Service Unavailable',
1032			504 => 'Gateway Timeout',
1033			505 => 'HTTP Version Not Supported',
1034			506 => 'Variant Also Negotiates',
1035			507 => 'Insufficient Storage',
1036			510 => 'Not Extended',
1037			511 => 'Network Authentication Required',
1038		);
1039	}
1040
1041	if ( isset( $wp_header_to_desc[$code] ) )
1042		return $wp_header_to_desc[$code];
1043	else
1044		return '';
1045}
1046
1047/**
1048 * Set HTTP status header.
1049 *
1050 * @since 2.0.0
1051 * @since 4.4.0 Added the `$description` parameter.
1052 *
1053 * @see get_status_header_desc()
1054 *
1055 * @param int    $code        HTTP status code.
1056 * @param string $description Optional. A custom description for the HTTP status.
1057 */
1058function status_header( $code, $description = '' ) {
1059	if ( ! $description ) {
1060		$description = get_status_header_desc( $code );
1061	}
1062
1063	if ( empty( $description ) ) {
1064		return;
1065	}
1066
1067	$protocol = wp_get_server_protocol();
1068	$status_header = "$protocol $code $description";
1069	if ( function_exists( 'apply_filters' ) )
1070
1071		/**
1072		 * Filter an HTTP status header.
1073		 *
1074		 * @since 2.2.0
1075		 *
1076		 * @param string $status_header HTTP status header.
1077		 * @param int    $code          HTTP status code.
1078		 * @param string $description   Description for the status code.
1079		 * @param string $protocol      Server protocol.
1080		 */
1081		$status_header = apply_filters( 'status_header', $status_header, $code, $description, $protocol );
1082
1083	@header( $status_header, true, $code );
1084}
1085
1086/**
1087 * Get the header information to prevent caching.
1088 *
1089 * The several different headers cover the different ways cache prevention
1090 * is handled by different browsers
1091 *
1092 * @since 2.8.0
1093 *
1094 * @return array The associative array of header names and field values.
1095 */
1096function wp_get_nocache_headers() {
1097	$headers = array(
1098		'Expires' => 'Wed, 11 Jan 1984 05:00:00 GMT',
1099		'Cache-Control' => 'no-cache, must-revalidate, max-age=0',
1100		'Pragma' => 'no-cache',
1101	);
1102
1103	if ( function_exists('apply_filters') ) {
1104		/**
1105		 * Filter the cache-controlling headers.
1106		 *
1107		 * @since 2.8.0
1108		 *
1109		 * @see wp_get_nocache_headers()
1110		 *
1111		 * @param array $headers {
1112		 *     Header names and field values.
1113		 *
1114		 *     @type string $Expires       Expires header.
1115		 *     @type string $Cache-Control Cache-Control header.
1116		 *     @type string $Pragma        Pragma header.
1117		 * }
1118		 */
1119		$headers = (array) apply_filters( 'nocache_headers', $headers );
1120	}
1121	$headers['Last-Modified'] = false;
1122	return $headers;
1123}
1124
1125/**
1126 * Set the headers to prevent caching for the different browsers.
1127 *
1128 * Different browsers support different nocache headers, so several
1129 * headers must be sent so that all of them get the point that no
1130 * caching should occur.
1131 *
1132 * @since 2.0.0
1133 *
1134 * @see wp_get_nocache_headers()
1135 */
1136function nocache_headers() {
1137	$headers = wp_get_nocache_headers();
1138
1139	unset( $headers['Last-Modified'] );
1140
1141	// In PHP 5.3+, make sure we are not sending a Last-Modified header.
1142	if ( function_exists( 'header_remove' ) ) {
1143		@header_remove( 'Last-Modified' );
1144	} else {
1145		// In PHP 5.2, send an empty Last-Modified header, but only as a
1146		// last resort to override a header already sent. #WP23021
1147		foreach ( headers_list() as $header ) {
1148			if ( 0 === stripos( $header, 'Last-Modified' ) ) {
1149				$headers['Last-Modified'] = '';
1150				break;
1151			}
1152		}
1153	}
1154
1155	foreach ( $headers as $name => $field_value )
1156		@header("{$name}: {$field_value}");
1157}
1158
1159/**
1160 * Set the headers for caching for 10 days with JavaScript content type.
1161 *
1162 * @since 2.1.0
1163 */
1164function cache_javascript_headers() {
1165	$expiresOffset = 10 * DAY_IN_SECONDS;
1166
1167	header( "Content-Type: text/javascript; charset=" . get_bloginfo( 'charset' ) );
1168	header( "Vary: Accept-Encoding" ); // Handle proxies
1169	header( "Expires: " . gmdate( "D, d M Y H:i:s", time() + $expiresOffset ) . " GMT" );
1170}
1171
1172/**
1173 * Retrieve the number of database queries during the WordPress execution.
1174 *
1175 * @since 2.0.0
1176 *
1177 * @global wpdb $wpdb WordPress database abstraction object.
1178 *
1179 * @return int Number of database queries.
1180 */
1181function get_num_queries() {
1182	global $wpdb;
1183	return $wpdb->num_queries;
1184}
1185
1186/**
1187 * Whether input is yes or no.
1188 *
1189 * Must be 'y' to be true.
1190 *
1191 * @since 1.0.0
1192 *
1193 * @param string $yn Character string containing either 'y' (yes) or 'n' (no).
1194 * @return bool True if yes, false on anything else.
1195 */
1196function bool_from_yn( $yn ) {
1197	return ( strtolower( $yn ) == 'y' );
1198}
1199
1200/**
1201 * Load the feed template from the use of an action hook.
1202 *
1203 * If the feed action does not have a hook, then the function will die with a
1204 * message telling the visitor that the feed is not valid.
1205 *
1206 * It is better to only have one hook for each feed.
1207 *
1208 * @since 2.1.0
1209 *
1210 * @global WP_Query $wp_query Used to tell if the use a comment feed.
1211 */
1212function do_feed() {
1213	global $wp_query;
1214
1215	$feed = get_query_var( 'feed' );
1216
1217	// Remove the pad, if present.
1218	$feed = preg_replace( '/^_+/', '', $feed );
1219
1220	if ( $feed == '' || $feed == 'feed' )
1221		$feed = get_default_feed();
1222
1223	if ( ! has_action( "do_feed_{$feed}" ) ) {
1224		wp_die( __( 'ERROR: This is not a valid feed template.' ), '', array( 'response' => 404 ) );
1225	}
1226
1227	/**
1228	 * Fires once the given feed is loaded.
1229	 *
1230	 * The dynamic portion of the hook name, `$feed`, refers to the feed template name.
1231	 * Possible values include: 'rdf', 'rss', 'rss2', and 'atom'.
1232	 *
1233	 * @since 2.1.0
1234	 * @since 4.4.0 The `$feed` parameter was added.
1235	 *
1236	 * @param bool   $is_comment_feed Whether the feed is a comment feed.
1237	 * @param string $feed            The feed name.
1238	 */
1239	do_action( "do_feed_{$feed}", $wp_query->is_comment_feed, $feed );
1240}
1241
1242/**
1243 * Load the RDF RSS 0.91 Feed template.
1244 *
1245 * @since 2.1.0
1246 *
1247 * @see load_template()
1248 */
1249function do_feed_rdf() {
1250	load_template( ABSPATH . WPINC . '/feed-rdf.php' );
1251}
1252
1253/**
1254 * Load the RSS 1.0 Feed Template.
1255 *
1256 * @since 2.1.0
1257 *
1258 * @see load_template()
1259 */
1260function do_feed_rss() {
1261	load_template( ABSPATH . WPINC . '/feed-rss.php' );
1262}
1263
1264/**
1265 * Load either the RSS2 comment feed or the RSS2 posts feed.
1266 *
1267 * @since 2.1.0
1268 *
1269 * @see load_template()
1270 *
1271 * @param bool $for_comments True for the comment feed, false for normal feed.
1272 */
1273function do_feed_rss2( $for_comments ) {
1274	if ( $for_comments )
1275		load_template( ABSPATH . WPINC . '/feed-rss2-comments.php' );
1276	else
1277		load_template( ABSPATH . WPINC . '/feed-rss2.php' );
1278}
1279
1280/**
1281 * Load either Atom comment feed or Atom posts feed.
1282 *
1283 * @since 2.1.0
1284 *
1285 * @see load_template()
1286 *
1287 * @param bool $for_comments True for the comment feed, false for normal feed.
1288 */
1289function do_feed_atom( $for_comments ) {
1290	if ($for_comments)
1291		load_template( ABSPATH . WPINC . '/feed-atom-comments.php');
1292	else
1293		load_template( ABSPATH . WPINC . '/feed-atom.php' );
1294}
1295
1296/**
1297 * Display the robots.txt file content.
1298 *
1299 * The echo content should be with usage of the permalinks or for creating the
1300 * robots.txt file.
1301 *
1302 * @since 2.1.0
1303 */
1304function do_robots() {
1305	header( 'Content-Type: text/plain; charset=utf-8' );
1306
1307	/**
1308	 * Fires when displaying the robots.txt file.
1309	 *
1310	 * @since 2.1.0
1311	 */
1312	do_action( 'do_robotstxt' );
1313
1314	$output = "User-agent: *\n";
1315	$public = get_option( 'blog_public' );
1316	if ( '0' == $public ) {
1317		$output .= "Disallow: /\n";
1318	} else {
1319		$site_url = parse_url( site_url() );
1320		$path = ( !empty( $site_url['path'] ) ) ? $site_url['path'] : '';
1321		$output .= "Disallow: $path/wp-admin/\n";
1322		$output .= "Allow: $path/wp-admin/admin-ajax.php\n";
1323	}
1324
1325	/**
1326	 * Filter the robots.txt output.
1327	 *
1328	 * @since 3.0.0
1329	 *
1330	 * @param string $output Robots.txt output.
1331	 * @param bool   $public Whether the site is considered "public".
1332	 */
1333	echo apply_filters( 'robots_txt', $output, $public );
1334}
1335
1336/**
1337 * Test whether WordPress is already installed.
1338 *
1339 * The cache will be checked first. If you have a cache plugin, which saves
1340 * the cache values, then this will work. If you use the default WordPress
1341 * cache, and the database goes away, then you might have problems.
1342 *
1343 * Checks for the 'siteurl' option for whether WordPress is installed.
1344 *
1345 * @since 2.1.0
1346 *
1347 * @global wpdb $wpdb WordPress database abstraction object.
1348 *
1349 * @return bool Whether the site is already installed.
1350 */
1351function is_blog_installed() {
1352	global $wpdb;
1353
1354	/*
1355	 * Check cache first. If options table goes away and we have true
1356	 * cached, oh well.
1357	 */
1358	if ( wp_cache_get( 'is_blog_installed' ) )
1359		return true;
1360
1361	$suppress = $wpdb->suppress_errors();
1362	if ( ! wp_installing() ) {
1363		$alloptions = wp_load_alloptions();
1364	}
1365	// If siteurl is not set to autoload, check it specifically
1366	if ( !isset( $alloptions['siteurl'] ) )
1367		$installed = $wpdb->get_var( "SELECT option_value FROM $wpdb->options WHERE option_name = 'siteurl'" );
1368	else
1369		$installed = $alloptions['siteurl'];
1370	$wpdb->suppress_errors( $suppress );
1371
1372	$installed = !empty( $installed );
1373	wp_cache_set( 'is_blog_installed', $installed );
1374
1375	if ( $installed )
1376		return true;
1377
1378	// If visiting repair.php, return true and let it take over.
1379	if ( defined( 'WP_REPAIRING' ) )
1380		return true;
1381
1382	$suppress = $wpdb->suppress_errors();
1383
1384	/*
1385	 * Loop over the WP tables. If none exist, then scratch install is allowed.
1386	 * If one or more exist, suggest table repair since we got here because the
1387	 * options table could not be accessed.
1388	 */
1389	$wp_tables = $wpdb->tables();
1390	foreach ( $wp_tables as $table ) {
1391		// The existence of custom user tables shouldn't suggest an insane state or prevent a clean install.
1392		if ( defined( 'CUSTOM_USER_TABLE' ) && CUSTOM_USER_TABLE == $table )
1393			continue;
1394		if ( defined( 'CUSTOM_USER_META_TABLE' ) && CUSTOM_USER_META_TABLE == $table )
1395			continue;
1396
1397		if ( ! $wpdb->get_results( "DESCRIBE $table;" ) )
1398			continue;
1399
1400		// One or more tables exist. We are insane.
1401
1402		wp_load_translations_early();
1403
1404		// Die with a DB error.
1405		$wpdb->error = sprintf( __( 'One or more database tables are unavailable. The database may need to be <a href="%s">repaired</a>.' ), 'maint/repair.php?referrer=is_blog_installed' );
1406		dead_db();
1407	}
1408
1409	$wpdb->suppress_errors( $suppress );
1410
1411	wp_cache_set( 'is_blog_installed', false );
1412
1413	return false;
1414}
1415
1416/**
1417 * Retrieve URL with nonce added to URL query.
1418 *
1419 * @since 2.0.4
1420 *
1421 * @param string     $actionurl URL to add nonce action.
1422 * @param int|string $action    Optional. Nonce action name. Default -1.
1423 * @param string     $name      Optional. Nonce name. Default '_wpnonce'.
1424 * @return string Escaped URL with nonce action added.
1425 */
1426function wp_nonce_url( $actionurl, $action = -1, $name = '_wpnonce' ) {
1427	$actionurl = str_replace( '&amp;', '&', $actionurl );
1428	return esc_html( add_query_arg( $name, wp_create_nonce( $action ), $actionurl ) );
1429}
1430
1431/**
1432 * Retrieve or display nonce hidden field for forms.
1433 *
1434 * The nonce field is used to validate that the contents of the form came from
1435 * the location on the current site and not somewhere else. The nonce does not
1436 * offer absolute protection, but should protect against most cases. It is very
1437 * important to use nonce field in forms.
1438 *
1439 * The $action and $name are optional, but if you want to have better security,
1440 * it is strongly suggested to set those two parameters. It is easier to just
1441 * call the function without any parameters, because validation of the nonce
1442 * doesn't require any parameters, but since crackers know what the default is
1443 * it won't be difficult for them to find a way around your nonce and cause
1444 * damage.
1445 *
1446 * The input name will be whatever $name value you gave. The input value will be
1447 * the nonce creation value.
1448 *
1449 * @since 2.0.4
1450 *
1451 * @param int|string $action  Optional. Action name. Default -1.
1452 * @param string     $name    Optional. Nonce name. Default '_wpnonce'.
1453 * @param bool       $referer Optional. Whether to set the referer field for validation. Default true.
1454 * @param bool       $echo    Optional. Whether to display or return hidden form field. Default true.
1455 * @return string Nonce field HTML markup.
1456 */
1457function wp_nonce_field( $action = -1, $name = "_wpnonce", $referer = true , $echo = true ) {
1458	$name = esc_attr( $name );
1459	$nonce_field = '<input type="hidden" id="' . $name . '" name="' . $name . '" value="' . wp_create_nonce( $action ) . '" />';
1460
1461	if ( $referer )
1462		$nonce_field .= wp_referer_field( false );
1463
1464	if ( $echo )
1465		echo $nonce_field;
1466
1467	return $nonce_field;
1468}
1469
1470/**
1471 * Retrieve or display referer hidden field for forms.
1472 *
1473 * The referer link is the current Request URI from the server super global. The
1474 * input name is '_wp_http_referer', in case you wanted to check manually.
1475 *
1476 * @since 2.0.4
1477 *
1478 * @param bool $echo Optional. Whether to echo or return the referer field. Default true.
1479 * @return string Referer field HTML markup.
1480 */
1481function wp_referer_field( $echo = true ) {
1482	$referer_field = '<input type="hidden" name="_wp_http_referer" value="'. esc_attr( wp_unslash( $_SERVER['REQUEST_URI'] ) ) . '" />';
1483
1484	if ( $echo )
1485		echo $referer_field;
1486	return $referer_field;
1487}
1488
1489/**
1490 * Retrieve or display original referer hidden field for forms.
1491 *
1492 * The input name is '_wp_original_http_referer' and will be either the same
1493 * value of wp_referer_field(), if that was posted already or it will be the
1494 * current page, if it doesn't exist.
1495 *
1496 * @since 2.0.4
1497 *
1498 * @param bool   $echo         Optional. Whether to echo the original http referer. Default true.
1499 * @param string $jump_back_to Optional. Can be 'previous' or page you want to jump back to.
1500 *                             Default 'current'.
1501 * @return string Original referer field.
1502 */
1503function wp_original_referer_field( $echo = true, $jump_back_to = 'current' ) {
1504	if ( ! $ref = wp_get_original_referer() ) {
1505		$ref = 'previous' == $jump_back_to ? wp_get_referer() : wp_unslash( $_SERVER['REQUEST_URI'] );
1506	}
1507	$orig_referer_field = '<input type="hidden" name="_wp_original_http_referer" value="' . esc_attr( $ref ) . '" />';
1508	if ( $echo )
1509		echo $orig_referer_field;
1510	return $orig_referer_field;
1511}
1512
1513/**
1514 * Retrieve referer from '_wp_http_referer' or HTTP referer.
1515 *
1516 * If it's the same as the current request URL, will return false.
1517 *
1518 * @since 2.0.4
1519 *
1520 * @return false|string False on failure. Referer URL on success.
1521 */
1522function wp_get_referer() {
1523	if ( ! function_exists( 'wp_validate_redirect' ) ) {
1524		return false;
1525	}
1526
1527	$ref = wp_get_raw_referer();
1528
1529	if ( $ref && $ref !== wp_unslash( $_SERVER['REQUEST_URI'] ) && $ref !== home_url() . wp_unslash( $_SERVER['REQUEST_URI'] ) ) {
1530		return wp_validate_redirect( $ref, false );
1531	}
1532
1533	return false;
1534}
1535
1536/**
1537 * Retrieves unvalidated referer from '_wp_http_referer' or HTTP referer.
1538 *
1539 * Do not use for redirects, use {@see wp_get_referer()} instead.
1540 *
1541 * @since 4.5.0
1542 *
1543 * @return string|false Referer URL on success, false on failure.
1544 */
1545function wp_get_raw_referer() {
1546	if ( ! empty( $_REQUEST['_wp_http_referer'] ) ) {
1547		return wp_unslash( $_REQUEST['_wp_http_referer'] );
1548	} else if ( ! empty( $_SERVER['HTTP_REFERER'] ) ) {
1549		return wp_unslash( $_SERVER['HTTP_REFERER'] );
1550	}
1551
1552	return false;
1553}
1554
1555/**
1556 * Retrieve original referer that was posted, if it exists.
1557 *
1558 * @since 2.0.4
1559 *
1560 * @return string|false False if no original referer or original referer if set.
1561 */
1562function wp_get_original_referer() {
1563	if ( ! empty( $_REQUEST['_wp_original_http_referer'] ) && function_exists( 'wp_validate_redirect' ) )
1564		return wp_validate_redirect( wp_unslash( $_REQUEST['_wp_original_http_referer'] ), false );
1565	return false;
1566}
1567
1568/**
1569 * Recursive directory creation based on full path.
1570 *
1571 * Will attempt to set permissions on folders.
1572 *
1573 * @since 2.0.1
1574 *
1575 * @param string $target Full path to attempt to create.
1576 * @return bool Whether the path was created. True if path already exists.
1577 */
1578function wp_mkdir_p( $target ) {
1579	$wrapper = null;
1580
1581	// Strip the protocol.
1582	if ( wp_is_stream( $target ) ) {
1583		list( $wrapper, $target ) = explode( '://', $target, 2 );
1584	}
1585
1586	// From php.net/mkdir user contributed notes.
1587	$target = str_replace( '//', '/', $target );
1588
1589	// Put the wrapper back on the target.
1590	if ( $wrapper !== null ) {
1591		$target = $wrapper . '://' . $target;
1592	}
1593
1594	/*
1595	 * Safe mode fails with a trailing slash under certain PHP versions.
1596	 * Use rtrim() instead of untrailingslashit to avoid formatting.php dependency.
1597	 */
1598	$target = rtrim($target, '/');
1599	if ( empty($target) )
1600		$target = '/';
1601
1602	if ( file_exists( $target ) )
1603		return @is_dir( $target );
1604
1605	// We need to find the permissions of the parent folder that exists and inherit that.
1606	$target_parent = dirname( $target );
1607	while ( '.' != $target_parent && ! is_dir( $target_parent ) ) {
1608		$target_parent = dirname( $target_parent );
1609	}
1610
1611	// Get the permission bits.
1612	if ( $stat = @stat( $target_parent ) ) {
1613		$dir_perms = $stat['mode'] & 0007777;
1614	} else {
1615		$dir_perms = 0777;
1616	}
1617
1618	if ( @mkdir( $target, $dir_perms, true ) ) {
1619
1620		/*
1621		 * If a umask is set that modifies $dir_perms, we'll have to re-set
1622		 * the $dir_perms correctly with chmod()
1623		 */
1624		if ( $dir_perms != ( $dir_perms & ~umask() ) ) {
1625			$folder_parts = explode( '/', substr( $target, strlen( $target_parent ) + 1 ) );
1626			for ( $i = 1, $c = count( $folder_parts ); $i <= $c; $i++ ) {
1627				@chmod( $target_parent . '/' . implode( '/', array_slice( $folder_parts, 0, $i ) ), $dir_perms );
1628			}
1629		}
1630
1631		return true;
1632	}
1633
1634	return false;
1635}
1636
1637/**
1638 * Test if a give filesystem path is absolute.
1639 *
1640 * For example, '/foo/bar', or 'c:\windows'.
1641 *
1642 * @since 2.5.0
1643 *
1644 * @param string $path File path.
1645 * @return bool True if path is absolute, false is not absolute.
1646 */
1647function path_is_absolute( $path ) {
1648	/*
1649	 * This is definitive if true but fails if $path does not exist or contains
1650	 * a symbolic link.
1651	 */
1652	if ( realpath($path) == $path )
1653		return true;
1654
1655	if ( strlen($path) == 0 || $path[0] == '.' )
1656		return false;
1657
1658	// Windows allows absolute paths like this.
1659	if ( preg_match('#^[a-zA-Z]:\\\\#', $path) )
1660		return true;
1661
1662	// A path starting with / or \ is absolute; anything else is relative.
1663	return ( $path[0] == '/' || $path[0] == '\\' );
1664}
1665
1666/**
1667 * Join two filesystem paths together.
1668 *
1669 * For example, 'give me $path relative to $base'. If the $path is absolute,
1670 * then it the full path is returned.
1671 *
1672 * @since 2.5.0
1673 *
1674 * @param string $base Base path.
1675 * @param string $path Path relative to $base.
1676 * @return string The path with the base or absolute path.
1677 */
1678function path_join( $base, $path ) {
1679	if ( path_is_absolute($path) )
1680		return $path;
1681
1682	return rtrim($base, '/') . '/' . ltrim($path, '/');
1683}
1684
1685/**
1686 * Normalize a filesystem path.
1687 *
1688 * On windows systems, replaces backslashes with forward slashes
1689 * and forces upper-case drive letters.
1690 * Allows for two leading slashes for Windows network shares, but
1691 * ensures that all other duplicate slashes are reduced to a single.
1692 *
1693 * @since 3.9.0
1694 * @since 4.4.0 Ensures upper-case drive letters on Windows systems.
1695 * @since 4.5.0 Allows for Windows network shares.
1696 *
1697 * @param string $path Path to normalize.
1698 * @return string Normalized path.
1699 */
1700function wp_normalize_path( $path ) {
1701	$path = str_replace( '\\', '/', $path );
1702	$path = preg_replace( '|(?<=.)/+|', '/', $path );
1703	if ( ':' === substr( $path, 1, 1 ) ) {
1704		$path = ucfirst( $path );
1705	}
1706	return $path;
1707}
1708
1709/**
1710 * Determine a writable directory for temporary files.
1711 *
1712 * Function's preference is the return value of sys_get_temp_dir(),
1713 * followed by your PHP temporary upload directory, followed by WP_CONTENT_DIR,
1714 * before finally defaulting to /tmp/
1715 *
1716 * In the event that this function does not find a writable location,
1717 * It may be overridden by the WP_TEMP_DIR constant in your wp-config.php file.
1718 *
1719 * @since 2.5.0
1720 *
1721 * @staticvar string $temp
1722 *
1723 * @return string Writable temporary directory.
1724 */
1725function get_temp_dir() {
1726	static $temp = '';
1727	if ( defined('WP_TEMP_DIR') )
1728		return trailingslashit(WP_TEMP_DIR);
1729
1730	if ( $temp )
1731		return trailingslashit( $temp );
1732
1733	if ( function_exists('sys_get_temp_dir') ) {
1734		$temp = sys_get_temp_dir();
1735		if ( @is_dir( $temp ) && wp_is_writable( $temp ) )
1736			return trailingslashit( $temp );
1737	}
1738
1739	$temp = ini_get('upload_tmp_dir');
1740	if ( @is_dir( $temp ) && wp_is_writable( $temp ) )
1741		return trailingslashit( $temp );
1742
1743	$temp = WP_CONTENT_DIR . '/';
1744	if ( is_dir( $temp ) && wp_is_writable( $temp ) )
1745		return $temp;
1746
1747	return '/tmp/';
1748}
1749
1750/**
1751 * Determine if a directory is writable.
1752 *
1753 * This function is used to work around certain ACL issues in PHP primarily
1754 * affecting Windows Servers.
1755 *
1756 * @since 3.6.0
1757 *
1758 * @see win_is_writable()
1759 *
1760 * @param string $path Path to check for write-ability.
1761 * @return bool Whether the path is writable.
1762 */
1763function wp_is_writable( $path ) {
1764	if ( 'WIN' === strtoupper( substr( PHP_OS, 0, 3 ) ) )
1765		return win_is_writable( $path );
1766	else
1767		return @is_writable( $path );
1768}
1769
1770/**
1771 * Workaround for Windows bug in is_writable() function
1772 *
1773 * PHP has issues with Windows ACL's for determine if a
1774 * directory is writable or not, this works around them by
1775 * checking the ability to open files rather than relying
1776 * upon PHP to interprate the OS ACL.
1777 *
1778 * @since 2.8.0
1779 *
1780 * @see http://bugs.php.net/bug.php?id=27609
1781 * @see http://bugs.php.net/bug.php?id=30931
1782 *
1783 * @param string $path Windows path to check for write-ability.
1784 * @return bool Whether the path is writable.
1785 */
1786function win_is_writable( $path ) {
1787
1788	if ( $path[strlen( $path ) - 1] == '/' ) { // if it looks like a directory, check a random file within the directory
1789		return win_is_writable( $path . uniqid( mt_rand() ) . '.tmp');
1790	} elseif ( is_dir( $path ) ) { // If it's a directory (and not a file) check a random file within the directory
1791		return win_is_writable( $path . '/' . uniqid( mt_rand() ) . '.tmp' );
1792	}
1793	// check tmp file for read/write capabilities
1794	$should_delete_tmp_file = !file_exists( $path );
1795	$f = @fopen( $path, 'a' );
1796	if ( $f === false )
1797		return false;
1798	fclose( $f );
1799	if ( $should_delete_tmp_file )
1800		unlink( $path );
1801	return true;
1802}
1803
1804/**
1805 * Retrieves uploads directory information.
1806 *
1807 * Same as wp_upload_dir() but "light weight" as it doesn't attempt to create the uploads directory.
1808 * Intended for use in themes, when only 'basedir' and 'baseurl' are needed, generally in all cases
1809 * when not uploading files.
1810 *
1811 * @since 4.5.0
1812 *
1813 * @see wp_upload_dir()
1814 *
1815 * @return array See wp_upload_dir() for description.
1816 */
1817function wp_get_upload_dir() {
1818	return wp_upload_dir( null, false );
1819}
1820
1821/**
1822 * Get an array containing the current upload directory's path and url.
1823 *
1824 * Checks the 'upload_path' option, which should be from the web root folder,
1825 * and if it isn't empty it will be used. If it is empty, then the path will be
1826 * 'WP_CONTENT_DIR/uploads'. If the 'UPLOADS' constant is defined, then it will
1827 * override the 'upload_path' option and 'WP_CONTENT_DIR/uploads' path.
1828 *
1829 * The upload URL path is set either by the 'upload_url_path' option or by using
1830 * the 'WP_CONTENT_URL' constant and appending '/uploads' to the path.
1831 *
1832 * If the 'uploads_use_yearmonth_folders' is set to true (checkbox if checked in
1833 * the administration settings panel), then the time will be used. The format
1834 * will be year first and then month.
1835 *
1836 * If the path couldn't be created, then an error will be returned with the key
1837 * 'error' containing the error message. The error suggests that the parent
1838 * directory is not writable by the server.
1839 *
1840 * On success, the returned array will have many indices:
1841 * 'path' - base directory and sub directory or full path to upload directory.
1842 * 'url' - base url and sub directory or absolute URL to upload directory.
1843 * 'subdir' - sub directory if uploads use year/month folders option is on.
1844 * 'basedir' - path without subdir.
1845 * 'baseurl' - URL path without subdir.
1846 * 'error' - false or error message.
1847 *
1848 * @since 2.0.0
1849 * @uses _wp_upload_dir()
1850 *
1851 * @param string $time Optional. Time formatted in 'yyyy/mm'. Default null.
1852 * @param bool   $create_dir Optional. Whether to check and create the uploads directory. Default true (backwards compatible).
1853 * @param bool   $refresh_cache Optional. Whether to refresh the cache. Default false.
1854 * @return array See above for description.
1855 */
1856function wp_upload_dir( $time = null, $create_dir = true, $refresh_cache = false ) {
1857	static $cache = array(), $tested_paths = array();
1858
1859	$key = sprintf( '%d-%s', get_current_blog_id(), (string) $time );
1860
1861	if ( $refresh_cache || empty( $cache[ $key ] ) ) {
1862		$cache[ $key ] = _wp_upload_dir( $time );
1863	}
1864
1865	/**
1866	 * Filter the uploads directory data.
1867	 *
1868	 * @since 2.0.0
1869	 *
1870	 * @param array $uploads Array of upload directory data with keys of 'path',
1871	 *                       'url', 'subdir, 'basedir', and 'error'.
1872	 */
1873	$uploads = apply_filters( 'upload_dir', $cache[ $key ] );
1874
1875	if ( $create_dir ) {
1876		$path = $uploads['path'];
1877
1878		if ( array_key_exists( $path, $tested_paths ) ) {
1879			$uploads['error'] = $tested_paths[ $path ];
1880		} else {
1881			if ( ! wp_mkdir_p( $path ) ) {
1882				if ( 0 === strpos( $uploads['basedir'], ABSPATH ) ) {
1883					$error_path = str_replace( ABSPATH, '', $uploads['basedir'] ) . $uploads['subdir'];
1884				} else {
1885					$error_path = basename( $uploads['basedir'] ) . $uploads['subdir'];
1886				}
1887
1888				$uploads['error'] = sprintf( __( 'Unable to create directory %s. Is its parent directory writable by the server?' ), esc_html( $error_path ) );
1889			}
1890
1891			$tested_paths[ $path ] = $uploads['error'];
1892		}
1893	}
1894
1895	return $uploads;
1896}
1897
1898/**
1899 * A non-filtered, non-cached version of wp_upload_dir() that doesn't check the path.
1900 *
1901 * @access private
1902 *
1903 * @param string $time Optional. Time formatted in 'yyyy/mm'. Default null.
1904 * @return array See wp_upload_dir()
1905 */
1906function _wp_upload_dir( $time = null ) {
1907	$siteurl = get_option( 'siteurl' );
1908	$upload_path = trim( get_option( 'upload_path' ) );
1909
1910	if ( empty( $upload_path ) || 'wp-content/uploads' == $upload_path ) {
1911		$dir = WP_CONTENT_DIR . '/uploads';
1912	} elseif ( 0 !== strpos( $upload_path, ABSPATH ) ) {
1913		// $dir is absolute, $upload_path is (maybe) relative to ABSPATH
1914		$dir = path_join( ABSPATH, $upload_path );
1915	} else {
1916		$dir = $upload_path;
1917	}
1918
1919	if ( !$url = get_option( 'upload_url_path' ) ) {
1920		if ( empty($upload_path) || ( 'wp-content/uploads' == $upload_path ) || ( $upload_path == $dir ) )
1921			$url = WP_CONTENT_URL . '/uploads';
1922		else
1923			$url = trailingslashit( $siteurl ) . $upload_path;
1924	}
1925
1926	/*
1927	 * Honor the value of UPLOADS. This happens as long as ms-files rewriting is disabled.
1928	 * We also sometimes obey UPLOADS when rewriting is enabled -- see the next block.
1929	 */
1930	if ( defined( 'UPLOADS' ) && ! ( is_multisite() && get_site_option( 'ms_files_rewriting' ) ) ) {
1931		$dir = ABSPATH . UPLOADS;
1932		$url = trailingslashit( $siteurl ) . UPLOADS;
1933	}
1934
1935	// If multisite (and if not the main site in a post-MU network)
1936	if ( is_multisite() && ! ( is_main_network() && is_main_site() && defined( 'MULTISITE' ) ) ) {
1937
1938		if ( ! get_site_option( 'ms_files_rewriting' ) ) {
1939			/*
1940			 * If ms-files rewriting is disabled (networks created post-3.5), it is fairly
1941			 * straightforward: Append sites/%d if we're not on the main site (for post-MU
1942			 * networks). (The extra directory prevents a four-digit ID from conflicting with
1943			 * a year-based directory for the main site. But if a MU-era network has disabled
1944			 * ms-files rewriting manually, they don't need the extra directory, as they never
1945			 * had wp-content/uploads for the main site.)
1946			 */
1947
1948			if ( defined( 'MULTISITE' ) )
1949				$ms_dir = '/sites/' . get_current_blog_id();
1950			else
1951				$ms_dir = '/' . get_current_blog_id();
1952
1953			$dir .= $ms_dir;
1954			$url .= $ms_dir;
1955
1956		} elseif ( defined( 'UPLOADS' ) && ! ms_is_switched() ) {
1957			/*
1958			 * Handle the old-form ms-files.php rewriting if the network still has that enabled.
1959			 * When ms-files rewriting is enabled, then we only listen to UPLOADS when:
1960			 * 1) We are not on the main site in a post-MU network, as wp-content/uploads is used
1961			 *    there, and
1962			 * 2) We are not switched, as ms_upload_constants() hardcodes these constants to reflect
1963			 *    the original blog ID.
1964			 *
1965			 * Rather than UPLOADS, we actually use BLOGUPLOADDIR if it is set, as it is absolute.
1966			 * (And it will be set, see ms_upload_constants().) Otherwise, UPLOADS can be used, as
1967			 * as it is relative to ABSPATH. For the final piece: when UPLOADS is used with ms-files
1968			 * rewriting in multisite, the resulting URL is /files. (#WP22702 for background.)
1969			 */
1970
1971			if ( defined( 'BLOGUPLOADDIR' ) )
1972				$dir = untrailingslashit( BLOGUPLOADDIR );
1973			else
1974				$dir = ABSPATH . UPLOADS;
1975			$url = trailingslashit( $siteurl ) . 'files';
1976		}
1977	}
1978
1979	$basedir = $dir;
1980	$baseurl = $url;
1981
1982	$subdir = '';
1983	if ( get_option( 'uploads_use_yearmonth_folders' ) ) {
1984		// Generate the yearly and monthly dirs
1985		if ( !$time )
1986			$time = current_time( 'mysql' );
1987		$y = substr( $time, 0, 4 );
1988		$m = substr( $time, 5, 2 );
1989		$subdir = "/$y/$m";
1990	}
1991
1992	$dir .= $subdir;
1993	$url .= $subdir;
1994
1995	return array(
1996		'path'    => $dir,
1997		'url'     => $url,
1998		'subdir'  => $subdir,
1999		'basedir' => $basedir,
2000		'baseurl' => $baseurl,
2001		'error'   => false,
2002	);
2003}
2004
2005/**
2006 * Get a filename that is sanitized and unique for the given directory.
2007 *
2008 * If the filename is not unique, then a number will be added to the filename
2009 * before the extension, and will continue adding numbers until the filename is
2010 * unique.
2011 *
2012 * The callback is passed three parameters, the first one is the directory, the
2013 * second is the filename, and the third is the extension.
2014 *
2015 * @since 2.5.0
2016 *
2017 * @param string   $dir                      Directory.
2018 * @param string   $filename                 File name.
2019 * @param callable $unique_filename_callback Callback. Default null.
2020 * @return string New filename, if given wasn't unique.
2021 */
2022function wp_unique_filename( $dir, $filename, $unique_filename_callback = null ) {
2023	// Sanitize the file name before we begin processing.
2024	$filename = sanitize_file_name($filename);
2025
2026	// Separate the filename into a name and extension.
2027	$info = pathinfo($filename);
2028	$ext = !empty($info['extension']) ? '.' . $info['extension'] : '';
2029	$name = basename($filename, $ext);
2030
2031	// Edge case: if file is named '.ext', treat as an empty name.
2032	if ( $name === $ext )
2033		$name = '';
2034
2035	/*
2036	 * Increment the file number until we have a unique file to save in $dir.
2037	 * Use callback if supplied.
2038	 */
2039	if ( $unique_filename_callback && is_callable( $unique_filename_callback ) ) {
2040		$filename = call_user_func( $unique_filename_callback, $dir, $name, $ext );
2041	} else {
2042		$number = '';
2043
2044		// Change '.ext' to lower case.
2045		if ( $ext && strtolower($ext) != $ext ) {
2046			$ext2 = strtolower($ext);
2047			$filename2 = preg_replace( '|' . preg_quote($ext) . '$|', $ext2, $filename );
2048
2049			// Check for both lower and upper case extension or image sub-sizes may be overwritten.
2050			while ( file_exists($dir . "/$filename") || file_exists($dir . "/$filename2") ) {
2051				$new_number = $number + 1;
2052				$filename = str_replace( array( "-$number$ext", "$number$ext" ), "-$new_number$ext", $filename );
2053				$filename2 = str_replace( array( "-$number$ext2", "$number$ext2" ), "-$new_number$ext2", $filename2 );
2054				$number = $new_number;
2055			}
2056
2057			/**
2058			 * Filter the result when generating a unique file name.
2059			 *
2060			 * @since 4.5.0
2061			 *
2062			 * @param string        $filename                 Unique file name.
2063			 * @param string        $ext                      File extension, eg. ".png".
2064			 * @param string        $dir                      Directory path.
2065			 * @param callable|null $unique_filename_callback Callback function that generates the unique file name.
2066			 */
2067			return apply_filters( 'wp_unique_filename', $filename2, $ext, $dir, $unique_filename_callback );
2068		}
2069
2070		while ( file_exists( $dir . "/$filename" ) ) {
2071			if ( '' == "$number$ext" ) {
2072				$filename = "$filename-" . ++$number;
2073			} else {
2074				$filename = str_replace( array( "-$number$ext", "$number$ext" ), "-" . ++$number . $ext, $filename );
2075			}
2076		}
2077	}
2078
2079	/** This filter is documented in wp-includes/functions.php */
2080	return apply_filters( 'wp_unique_filename', $filename, $ext, $dir, $unique_filename_callback );
2081}
2082
2083/**
2084 * Create a file in the upload folder with given content.
2085 *
2086 * If there is an error, then the key 'error' will exist with the error message.
2087 * If success, then the key 'file' will have the unique file path, the 'url' key
2088 * will have the link to the new file. and the 'error' key will be set to false.
2089 *
2090 * This function will not move an uploaded file to the upload folder. It will
2091 * create a new file with the content in $bits parameter. If you move the upload
2092 * file, read the content of the uploaded file, and then you can give the
2093 * filename and content to this function, which will add it to the upload
2094 * folder.
2095 *
2096 * The permissions will be set on the new file automatically by this function.
2097 *
2098 * @since 2.0.0
2099 *
2100 * @param string       $name       Filename.
2101 * @param null|string  $deprecated Never used. Set to null.
2102 * @param mixed        $bits       File content
2103 * @param string       $time       Optional. Time formatted in 'yyyy/mm'. Default null.
2104 * @return array
2105 */
2106function wp_upload_bits( $name, $deprecated, $bits, $time = null ) {
2107	if ( !empty( $deprecated ) )
2108		_deprecated_argument( __FUNCTION__, '2.0' );
2109
2110	if ( empty( $name ) )
2111		return array( 'error' => __( 'Empty filename' ) );
2112
2113	$wp_filetype = wp_check_filetype( $name );
2114	if ( ! $wp_filetype['ext'] && ! current_user_can( 'unfiltered_upload' ) )
2115		return array( 'error' => __( 'Invalid file type' ) );
2116
2117	$upload = wp_upload_dir( $time );
2118
2119	if ( $upload['error'] !== false )
2120		return $upload;
2121
2122	/**
2123	 * Filter whether to treat the upload bits as an error.
2124	 *
2125	 * Passing a non-array to the filter will effectively short-circuit preparing
2126	 * the upload bits, returning that value instead.
2127	 *
2128	 * @since 3.0.0
2129	 *
2130	 * @param mixed $upload_bits_error An array of upload bits data, or a non-array error to return.
2131	 */
2132	$upload_bits_error = apply_filters( 'wp_upload_bits', array( 'name' => $name, 'bits' => $bits, 'time' => $time ) );
2133	if ( !is_array( $upload_bits_error ) ) {
2134		$upload[ 'error' ] = $upload_bits_error;
2135		return $upload;
2136	}
2137
2138	$filename = wp_unique_filename( $upload['path'], $name );
2139
2140	$new_file = $upload['path'] . "/$filename";
2141	if ( ! wp_mkdir_p( dirname( $new_file ) ) ) {
2142		if ( 0 === strpos( $upload['basedir'], ABSPATH ) )
2143			$error_path = str_replace( ABSPATH, '', $upload['basedir'] ) . $upload['subdir'];
2144		else
2145			$error_path = basename( $upload['basedir'] ) . $upload['subdir'];
2146
2147		$message = sprintf( __( 'Unable to create directory %s. Is its parent directory writable by the server?' ), $error_path );
2148		return array( 'error' => $message );
2149	}
2150
2151	$ifp = @ fopen( $new_file, 'wb' );
2152	if ( ! $ifp )
2153		return array( 'error' => sprintf( __( 'Could not write file %s' ), $new_file ) );
2154
2155	@fwrite( $ifp, $bits );
2156	fclose( $ifp );
2157	clearstatcache();
2158
2159	// Set correct file permissions
2160	$stat = @ stat( dirname( $new_file ) );
2161	$perms = $stat['mode'] & 0007777;
2162	$perms = $perms & 0000666;
2163	@ chmod( $new_file, $perms );
2164	clearstatcache();
2165
2166	// Compute the URL
2167	$url = $upload['url'] . "/$filename";
2168
2169	/** This filter is documented in wp-admin/includes/file.php */
2170	return apply_filters( 'wp_handle_upload', array( 'file' => $new_file, 'url' => $url, 'type' => $wp_filetype['type'], 'error' => false ), 'sideload' );
2171}
2172
2173/**
2174 * Retrieve the file type based on the extension name.
2175 *
2176 * @since 2.5.0
2177 *
2178 * @param string $ext The extension to search.
2179 * @return string|void The file type, example: audio, video, document, spreadsheet, etc.
2180 */
2181function wp_ext2type( $ext ) {
2182	$ext = strtolower( $ext );
2183
2184	/**
2185	 * Filter file type based on the extension name.
2186	 *
2187	 * @since 2.5.0
2188	 *
2189	 * @see wp_ext2type()
2190	 *
2191	 * @param array $ext2type Multi-dimensional array with extensions for a default set
2192	 *                        of file types.
2193	 */
2194	$ext2type = apply_filters( 'ext2type', array(
2195		'image'       => array( 'jpg', 'jpeg', 'jpe',  'gif',  'png',  'bmp',   'tif',  'tiff', 'ico' ),
2196		'audio'       => array( 'aac', 'ac3',  'aif',  'aiff', 'm3a',  'm4a',   'm4b',  'mka',  'mp1',  'mp2',  'mp3', 'ogg', 'oga', 'ram', 'wav', 'wma' ),
2197		'video'       => array( '3g2',  '3gp', '3gpp', 'asf', 'avi',  'divx', 'dv',   'flv',  'm4v',   'mkv',  'mov',  'mp4',  'mpeg', 'mpg', 'mpv', 'ogm', 'ogv', 'qt',  'rm', 'vob', 'wmv' ),
2198		'document'    => array( 'doc', 'docx', 'docm', 'dotm', 'odt',  'pages', 'pdf',  'xps',  'oxps', 'rtf',  'wp', 'wpd', 'psd', 'xcf' ),
2199		'spreadsheet' => array( 'numbers',     'ods',  'xls',  'xlsx', 'xlsm',  'xlsb' ),
2200		'interactive' => array( 'swf', 'key',  'ppt',  'pptx', 'pptm', 'pps',   'ppsx', 'ppsm', 'sldx', 'sldm', 'odp' ),
2201		'text'        => array( 'asc', 'csv',  'tsv',  'txt' ),
2202		'archive'     => array( 'bz2', 'cab',  'dmg',  'gz',   'rar',  'sea',   'sit',  'sqx',  'tar',  'tgz',  'zip', '7z' ),
2203		'code'        => array( 'css', 'htm',  'html', 'php',  'js' ),
2204	) );
2205
2206	foreach ( $ext2type as $type => $exts )
2207		if ( in_array( $ext, $exts ) )
2208			return $type;
2209}
2210
2211/**
2212 * Retrieve the file type from the file name.
2213 *
2214 * You can optionally define the mime array, if needed.
2215 *
2216 * @since 2.0.4
2217 *
2218 * @param string $filename File name or path.
2219 * @param array  $mimes    Optional. Key is the file extension with value as the mime type.
2220 * @return array Values with extension first and mime type.
2221 */
2222function wp_check_filetype( $filename, $mimes = null ) {
2223	if ( empty($mimes) )
2224		$mimes = get_allowed_mime_types();
2225	$type = false;
2226	$ext = false;
2227
2228	foreach ( $mimes as $ext_preg => $mime_match ) {
2229		$ext_preg = '!\.(' . $ext_preg . ')$!i';
2230		if ( preg_match( $ext_preg, $filename, $ext_matches ) ) {
2231			$type = $mime_match;
2232			$ext = $ext_matches[1];
2233			break;
2234		}
2235	}
2236
2237	return compact( 'ext', 'type' );
2238}
2239
2240/**
2241 * Attempt to determine the real file type of a file.
2242 *
2243 * If unable to, the file name extension will be used to determine type.
2244 *
2245 * If it's determined that the extension does not match the file's real type,
2246 * then the "proper_filename" value will be set with a proper filename and extension.
2247 *
2248 * Currently this function only supports renaming images validated via wp_get_image_mime().
2249 *
2250 * @since 3.0.0
2251 *
2252 * @param string $file     Full path to the file.
2253 * @param string $filename The name of the file (may differ from $file due to $file being
2254 *                         in a tmp directory).
2255 * @param array   $mimes   Optional. Key is the file extension with value as the mime type.
2256 * @return array Values for the extension, MIME, and either a corrected filename or false
2257 *               if original $filename is valid.
2258 */
2259function wp_check_filetype_and_ext( $file, $filename, $mimes = null ) {
2260	$proper_filename = false;
2261
2262	// Do basic extension validation and MIME mapping
2263	$wp_filetype = wp_check_filetype( $filename, $mimes );
2264	$ext = $wp_filetype['ext'];
2265	$type = $wp_filetype['type'];
2266
2267	// We can't do any further validation without a file to work with
2268	if ( ! file_exists( $file ) ) {
2269		return compact( 'ext', 'type', 'proper_filename' );
2270	}
2271
2272	// Validate image types.
2273	if ( $type && 0 === strpos( $type, 'image/' ) ) {
2274
2275		// Attempt to figure out what type of image it actually is
2276		$real_mime = wp_get_image_mime( $file );
2277
2278		if ( ! $real_mime ) {
2279			$type = $ext = false;
2280		} elseif ( $real_mime != $type ) {
2281			/**
2282			 * Filter the list mapping image mime types to their respective extensions.
2283			 *
2284			 * @since 3.0.0
2285			 *
2286			 * @param  array $mime_to_ext Array of image mime types and their matching extensions.
2287			 */
2288			$mime_to_ext = apply_filters( 'getimagesize_mimes_to_exts', array(
2289				'image/jpeg' => 'jpg',
2290				'image/png'  => 'png',
2291				'image/gif'  => 'gif',
2292				'image/bmp'  => 'bmp',
2293				'image/tiff' => 'tif',
2294			) );
2295
2296			// Replace whatever is after the last period in the filename with the correct extension
2297			if ( ! empty( $mime_to_ext[ $real_mime ] ) ) {
2298				$filename_parts = explode( '.', $filename );
2299				array_pop( $filename_parts );
2300				$filename_parts[] = $mime_to_ext[ $real_mime ];
2301				$new_filename = implode( '.', $filename_parts );
2302
2303				if ( $new_filename != $filename ) {
2304					$proper_filename = $new_filename; // Mark that it changed
2305				}
2306				// Redefine the extension / MIME
2307				$wp_filetype = wp_check_filetype( $new_filename, $mimes );
2308				$ext = $wp_filetype['ext'];
2309				$type = $wp_filetype['type'];
2310			} else {
2311				$type = $ext = false;
2312			}
2313		}
2314	} elseif ( function_exists( 'finfo_file' ) ) {
2315		// Use finfo_file if available to validate non-image files.
2316		$finfo = finfo_open( FILEINFO_MIME_TYPE );
2317		$real_mime = finfo_file( $finfo, $file );
2318		finfo_close( $finfo );
2319
2320		// If the extension does not match the file's real type, return false.
2321		if ( $real_mime !== $type ) {
2322			$type = $ext = false;
2323		}
2324	}
2325
2326	/**
2327	 * Filter the "real" file type of the given file.
2328	 *
2329	 * @since 3.0.0
2330	 *
2331	 * @param array  $wp_check_filetype_and_ext File data array containing 'ext', 'type', and
2332	 *                                          'proper_filename' keys.
2333	 * @param string $file                      Full path to the file.
2334	 * @param string $filename                  The name of the file (may differ from $file due to
2335	 *                                          $file being in a tmp directory).
2336	 * @param array  $mimes                     Key is the file extension with value as the mime type.
2337	 */
2338	return apply_filters( 'wp_check_filetype_and_ext', compact( 'ext', 'type', 'proper_filename' ), $file, $filename, $mimes );
2339}
2340
2341/**
2342 * Returns the real mime type of an image file.
2343 *
2344 * This depends on exif_imagetype() or getimagesize() to determine real mime types.
2345 *
2346 * @since 4.7.1
2347 *
2348 * @param string $file Full path to the file.
2349 * @return string|false The actual mime type or false if the type cannot be determined.
2350 */
2351function wp_get_image_mime( $file ) {
2352	/*
2353	 * Use exif_imagetype() to check the mimetype if available or fall back to
2354	 * getimagesize() if exif isn't avaialbe. If either function throws an Exception
2355	 * we assume the file could not be validated.
2356	 */
2357	try {
2358		if ( is_callable( 'exif_imagetype' ) ) {
2359			$mime = image_type_to_mime_type( exif_imagetype( $file ) );
2360		} elseif ( function_exists( 'getimagesize' ) ) {
2361			$imagesize = getimagesize( $file );
2362			$mime = ( isset( $imagesize['mime'] ) ) ? $imagesize['mime'] : false;
2363		} else {
2364			$mime = false;
2365		}
2366	} catch ( Exception $e ) {
2367		$mime = false;
2368	}
2369
2370	return $mime;
2371}
2372
2373/**
2374 * Retrieve list of mime types and file extensions.
2375 *
2376 * @since 3.5.0
2377 * @since 4.2.0 Support was added for GIMP (xcf) files.
2378 *
2379 * @return array Array of mime types keyed by the file extension regex corresponding to those types.
2380 */
2381function wp_get_mime_types() {
2382	/**
2383	 * Filter the list of mime types and file extensions.
2384	 *
2385	 * This filter should be used to add, not remove, mime types. To remove
2386	 * mime types, use the 'upload_mimes' filter.
2387	 *
2388	 * @since 3.5.0
2389	 *
2390	 * @param array $wp_get_mime_types Mime types keyed by the file extension regex
2391	 *                                 corresponding to those types.
2392	 */
2393	return apply_filters( 'mime_types', array(
2394	// Image formats.
2395	'jpg|jpeg|jpe' => 'image/jpeg',
2396	'gif' => 'image/gif',
2397	'png' => 'image/png',
2398	'bmp' => 'image/bmp',
2399	'tiff|tif' => 'image/tiff',
2400	'ico' => 'image/x-icon',
2401	// Video formats.
2402	'asf|asx' => 'video/x-ms-asf',
2403	'wmv' => 'video/x-ms-wmv',
2404	'wmx' => 'video/x-ms-wmx',
2405	'wm' => 'video/x-ms-wm',
2406	'avi' => 'video/avi',
2407	'divx' => 'video/divx',
2408	'flv' => 'video/x-flv',
2409	'mov|qt' => 'video/quicktime',
2410	'mpeg|mpg|mpe' => 'video/mpeg',
2411	'mp4|m4v' => 'video/mp4',
2412	'ogv' => 'video/ogg',
2413	'webm' => 'video/webm',
2414	'mkv' => 'video/x-matroska',
2415	'3gp|3gpp' => 'video/3gpp', // Can also be audio
2416	'3g2|3gp2' => 'video/3gpp2', // Can also be audio
2417	// Text formats.
2418	'txt|asc|c|cc|h|srt' => 'text/plain',
2419	'csv' => 'text/csv',
2420	'tsv' => 'text/tab-separated-values',
2421	'ics' => 'text/calendar',
2422	'rtx' => 'text/richtext',
2423	'css' => 'text/css',
2424	'htm|html' => 'text/html',
2425	'vtt' => 'text/vtt',
2426	'dfxp' => 'application/ttaf+xml',
2427	// Audio formats.
2428	'mp3|m4a|m4b' => 'audio/mpeg',
2429	'ra|ram' => 'audio/x-realaudio',
2430	'wav' => 'audio/wav',
2431	'ogg|oga' => 'audio/ogg',
2432	'mid|midi' => 'audio/midi',
2433	'wma' => 'audio/x-ms-wma',
2434	'wax' => 'audio/x-ms-wax',
2435	'mka' => 'audio/x-matroska',
2436	// Misc application formats.
2437	'rtf' => 'application/rtf',
2438	'js' => 'application/javascript',
2439	'pdf' => 'application/pdf',
2440	'swf' => 'application/x-shockwave-flash',
2441	'class' => 'application/java',
2442	'tar' => 'application/x-tar',
2443	'zip' => 'application/zip',
2444	'gz|gzip' => 'application/x-gzip',
2445	'rar' => 'application/rar',
2446	'7z' => 'application/x-7z-compressed',
2447	'exe' => 'application/x-msdownload',
2448	'psd' => 'application/octet-stream',
2449	'xcf' => 'application/octet-stream',
2450	// MS Office formats.
2451	'doc' => 'application/msword',
2452	'pot|pps|ppt' => 'application/vnd.ms-powerpoint',
2453	'wri' => 'application/vnd.ms-write',
2454	'xla|xls|xlt|xlw' => 'application/vnd.ms-excel',
2455	'mdb' => 'application/vnd.ms-access',
2456	'mpp' => 'application/vnd.ms-project',
2457	'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
2458	'docm' => 'application/vnd.ms-word.document.macroEnabled.12',
2459	'dotx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
2460	'dotm' => 'application/vnd.ms-word.template.macroEnabled.12',
2461	'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
2462	'xlsm' => 'application/vnd.ms-excel.sheet.macroEnabled.12',
2463	'xlsb' => 'application/vnd.ms-excel.sheet.binary.macroEnabled.12',
2464	'xltx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
2465	'xltm' => 'application/vnd.ms-excel.template.macroEnabled.12',
2466	'xlam' => 'application/vnd.ms-excel.addin.macroEnabled.12',
2467	'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
2468	'pptm' => 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
2469	'ppsx' => 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
2470	'ppsm' => 'application/vnd.ms-powerpoint.slideshow.macroEnabled.12',
2471	'potx' => 'application/vnd.openxmlformats-officedocument.presentationml.template',
2472	'potm' => 'application/vnd.ms-powerpoint.template.macroEnabled.12',
2473	'ppam' => 'application/vnd.ms-powerpoint.addin.macroEnabled.12',
2474	'sldx' => 'application/vnd.openxmlformats-officedocument.presentationml.slide',
2475	'sldm' => 'application/vnd.ms-powerpoint.slide.macroEnabled.12',
2476	'onetoc|onetoc2|onetmp|onepkg' => 'application/onenote',
2477	'oxps' => 'application/oxps',
2478	'xps' => 'application/vnd.ms-xpsdocument',
2479	// OpenOffice formats.
2480	'odt' => 'application/vnd.oasis.opendocument.text',
2481	'odp' => 'application/vnd.oasis.opendocument.presentation',
2482	'ods' => 'application/vnd.oasis.opendocument.spreadsheet',
2483	'odg' => 'application/vnd.oasis.opendocument.graphics',
2484	'odc' => 'application/vnd.oasis.opendocument.chart',
2485	'odb' => 'application/vnd.oasis.opendocument.database',
2486	'odf' => 'application/vnd.oasis.opendocument.formula',
2487	// WordPerfect formats.
2488	'wp|wpd' => 'application/wordperfect',
2489	// iWork formats.
2490	'key' => 'application/vnd.apple.keynote',
2491	'numbers' => 'application/vnd.apple.numbers',
2492	'pages' => 'application/vnd.apple.pages',
2493	) );
2494}
2495/**
2496 * Retrieve list of allowed mime types and file extensions.
2497 *
2498 * @since 2.8.6
2499 *
2500 * @param int|WP_User $user Optional. User to check. Defaults to current user.
2501 * @return array Array of mime types keyed by the file extension regex corresponding
2502 *               to those types.
2503 */
2504function get_allowed_mime_types( $user = null ) {
2505	$t = wp_get_mime_types();
2506
2507	unset( $t['swf'], $t['exe'] );
2508	if ( function_exists( 'current_user_can' ) )
2509		$unfiltered = $user ? user_can( $user, 'unfiltered_html' ) : current_user_can( 'unfiltered_html' );
2510
2511	if ( empty( $unfiltered ) )
2512		unset( $t['htm|html'] );
2513
2514	/**
2515	 * Filter list of allowed mime types and file extensions.
2516	 *
2517	 * @since 2.0.0
2518	 *
2519	 * @param array            $t    Mime types keyed by the file extension regex corresponding to
2520	 *                               those types. 'swf' and 'exe' removed from full list. 'htm|html' also
2521	 *                               removed depending on '$user' capabilities.
2522	 * @param int|WP_User|null $user User ID, User object or null if not provided (indicates current user).
2523	 */
2524	return apply_filters( 'upload_mimes', $t, $user );
2525}
2526
2527/**
2528 * Display "Are You Sure" message to confirm the action being taken.
2529 *
2530 * If the action has the nonce explain message, then it will be displayed
2531 * along with the "Are you sure?" message.
2532 *
2533 * @since 2.0.4
2534 *
2535 * @param string $action The nonce action.
2536 */
2537function wp_nonce_ays( $action ) {
2538	if ( 'log-out' == $action ) {
2539		$html = sprintf( __( 'You are attempting to log out of %s' ), get_bloginfo( 'name' ) ) . '</p><p>';
2540		$redirect_to = isset( $_REQUEST['redirect_to'] ) ? $_REQUEST['redirect_to'] : '';
2541		$html .= sprintf( __( "Do you really want to <a href='%s'>log out</a>?"), wp_logout_url( $redirect_to ) );
2542	} else {
2543		$html = __( 'Are you sure you want to do this?' );
2544		if ( wp_get_referer() )
2545			$html .= "</p><p><a href='" . esc_url( remove_query_arg( 'updated', wp_get_referer() ) ) . "'>" . __( 'Please try again.' ) . "</a>";
2546	}
2547
2548	wp_die( $html, __( 'WordPress Failure Notice' ), 403 );
2549}
2550
2551/**
2552 * Kill WordPress execution and display HTML message with error message.
2553 *
2554 * This function complements the `die()` PHP function. The difference is that
2555 * HTML will be displayed to the user. It is recommended to use this function
2556 * only when the execution should not continue any further. It is not recommended
2557 * to call this function very often, and try to handle as many errors as possible
2558 * silently or more gracefully.
2559 *
2560 * As a shorthand, the desired HTTP response code may be passed as an integer to
2561 * the `$title` parameter (the default title would apply) or the `$args` parameter.
2562 *
2563 * @since 2.0.4
2564 * @since 4.1.0 The `$title` and `$args` parameters were changed to optionally accept
2565 *              an integer to be used as the response code.
2566 *
2567 * @param string|WP_Error  $message Optional. Error message. If this is a {@see WP_Error} object,
2568 *                                  the error's messages are used. Default empty.
2569 * @param string|int       $title   Optional. Error title. If `$message` is a `WP_Error` object,
2570 *                                  error data with the key 'title' may be used to specify the title.
2571 *                                  If `$title` is an integer, then it is treated as the response
2572 *                                  code. Default empty.
2573 * @param string|array|int $args {
2574 *     Optional. Arguments to control behavior. If `$args` is an integer, then it is treated
2575 *     as the response code. Default empty array.
2576 *
2577 *     @type int    $response       The HTTP response code. Default 500.
2578 *     @type bool   $back_link      Whether to include a link to go back. Default false.
2579 *     @type string $text_direction The text direction. This is only useful internally, when WordPress
2580 *                                  is still loading and the site's locale is not set up yet. Accepts 'rtl'.
2581 *                                  Default is the value of {@see is_rtl()}.
2582 * }
2583 */
2584function wp_die( $message = '', $title = '', $args = array() ) {
2585
2586	if ( is_int( $args ) ) {
2587		$args = array( 'response' => $args );
2588	} elseif ( is_int( $title ) ) {
2589		$args  = array( 'response' => $title );
2590		$title = '';
2591	}
2592
2593	if ( defined( 'DOING_AJAX' ) && DOING_AJAX ) {
2594		/**
2595		 * Filter callback for killing WordPress execution for AJAX requests.
2596		 *
2597		 * @since 3.4.0
2598		 *
2599		 * @param callable $function Callback function name.
2600		 */
2601		$function = apply_filters( 'wp_die_ajax_handler', '_ajax_wp_die_handler' );
2602	} elseif ( defined( 'XMLRPC_REQUEST' ) && XMLRPC_REQUEST ) {
2603		/**
2604		 * Filter callback for killing WordPress execution for XML-RPC requests.
2605		 *
2606		 * @since 3.4.0
2607		 *
2608		 * @param callable $function Callback function name.
2609		 */
2610		$function = apply_filters( 'wp_die_xmlrpc_handler', '_xmlrpc_wp_die_handler' );
2611	} else {
2612		/**
2613		 * Filter callback for killing WordPress execution for all non-AJAX, non-XML-RPC requests.
2614		 *
2615		 * @since 3.0.0
2616		 *
2617		 * @param callable $function Callback function name.
2618		 */
2619		$function = apply_filters( 'wp_die_handler', '_default_wp_die_handler' );
2620	}
2621
2622	call_user_func( $function, $message, $title, $args );
2623}
2624
2625/**
2626 * Kill WordPress execution and display HTML message with error message.
2627 *
2628 * This is the default handler for wp_die if you want a custom one for your
2629 * site then you can overload using the wp_die_handler filter in wp_die
2630 *
2631 * @since 3.0.0
2632 * @access private
2633 *
2634 * @param string       $message Error message.
2635 * @param string       $title   Optional. Error title. Default empty.
2636 * @param string|array $args    Optional. Arguments to control behavior. Default empty array.
2637 */
2638function _default_wp_die_handler( $message, $title = '', $args = array() ) {
2639	$defaults = array( 'response' => 500 );
2640	$r = wp_parse_args($args, $defaults);
2641
2642	$have_gettext = function_exists('__');
2643
2644	if ( function_exists( 'is_wp_error' ) && is_wp_error( $message ) ) {
2645		if ( empty( $title ) ) {
2646			$error_data = $message->get_error_data();
2647			if ( is_array( $error_data ) && isset( $error_data['title'] ) )
2648				$title = $error_data['title'];
2649		}
2650		$errors = $message->get_error_messages();
2651		switch ( count( $errors ) ) {
2652		case 0 :
2653			$message = '';
2654			break;
2655		case 1 :
2656			$message = "<p>{$errors[0]}</p>";
2657			break;
2658		default :
2659			$message = "<ul>\n\t\t<li>" . join( "</li>\n\t\t<li>", $errors ) . "</li>\n\t</ul>";
2660			break;
2661		}
2662	} elseif ( is_string( $message ) ) {
2663		$message = "<p>$message</p>";
2664	}
2665
2666	if ( isset( $r['back_link'] ) && $r['back_link'] ) {
2667		$back_text = $have_gettext? __('&laquo; Back') : '&laquo; Back';
2668		$message .= "\n<p><a href='javascript:history.back()'>$back_text</a></p>";
2669	}
2670
2671	if ( ! did_action( 'admin_head' ) ) :
2672		if ( !headers_sent() ) {
2673			status_header( $r['response'] );
2674			nocache_headers();
2675			header( 'Content-Type: text/html; charset=utf-8' );
2676		}
2677
2678		if ( empty($title) )
2679			$title = $have_gettext ? __('WordPress &rsaquo; Error') : 'WordPress &rsaquo; Error';
2680
2681		$text_direction = 'ltr';
2682		if ( isset($r['text_direction']) && 'rtl' == $r['text_direction'] )
2683			$text_direction = 'rtl';
2684		elseif ( function_exists( 'is_rtl' ) && is_rtl() )
2685			$text_direction = 'rtl';
2686?>
2687<!DOCTYPE html>
2688<!-- Ticket #11289, IE bug fix: always pad the error page with enough characters such that it is greater than 512 bytes, even after gzip compression abcdefghijklmnopqrstuvwxyz1234567890aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz11223344556677889900abacbcbdcdcededfefegfgfhghgihihjijikjkjlklkmlmlnmnmononpopoqpqprqrqsrsrtstsubcbcdcdedefefgfabcadefbghicjkldmnoepqrfstugvwxhyz1i234j567k890laabmbccnddeoeffpgghqhiirjjksklltmmnunoovppqwqrrxsstytuuzvvw0wxx1yyz2z113223434455666777889890091abc2def3ghi4jkl5mno6pqr7stu8vwx9yz11aab2bcc3dd4ee5ff6gg7hh8ii9j0jk1kl2lmm3nnoo4p5pq6qrr7ss8tt9uuvv0wwx1x2yyzz13aba4cbcb5dcdc6dedfef8egf9gfh0ghg1ihi2hji3jik4jkj5lkl6kml7mln8mnm9ono
2689-->
2690<html xmlns="http://www.w3.org/1999/xhtml" <?php if ( function_exists( 'language_attributes' ) && function_exists( 'is_rtl' ) ) language_attributes(); else echo "dir='$text_direction'"; ?>>
2691<head>
2692	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
2693	<meta name="viewport" content="width=device-width">
2694	<title><?php echo $title ?></title>
2695	<style type="text/css">
2696		html {
2697			background: #f1f1f1;
2698		}
2699		body {
2700			background: #fff;
2701			color: #444;
2702			font-family: "Open Sans", sans-serif;
2703			margin: 2em auto;
2704			padding: 1em 2em;
2705			max-width: 700px;
2706			-webkit-box-shadow: 0 1px 3px rgba(0,0,0,0.13);
2707			box-shadow: 0 1px 3px rgba(0,0,0,0.13);
2708		}
2709		h1 {
2710			border-bottom: 1px solid #dadada;
2711			clear: both;
2712			color: #666;
2713			font: 24px "Open Sans", sans-serif;
2714			margin: 30px 0 0 0;
2715			padding: 0;
2716			padding-bottom: 7px;
2717		}
2718		#error-page {
2719			margin-top: 50px;
2720		}
2721		#error-page p {
2722			font-size: 14px;
2723			line-height: 1.5;
2724			margin: 25px 0 20px;
2725		}
2726		#error-page code {
2727			font-family: Consolas, Monaco, monospace;
2728		}
2729		ul li {
2730			margin-bottom: 10px;
2731			font-size: 14px ;
2732		}
2733		a {
2734			color: #0073aa;
2735		}
2736		a:hover,
2737		a:active {
2738			color: #00a0d2;
2739		}
2740		a:focus {
2741			color: #124964;
2742		    -webkit-box-shadow:
2743		    	0 0 0 1px #5b9dd9,
2744				0 0 2px 1px rgba(30, 140, 190, .8);
2745		    box-shadow:
2746		    	0 0 0 1px #5b9dd9,
2747				0 0 2px 1px rgba(30, 140, 190, .8);
2748			outline: none;
2749		}
2750		.button {
2751			background: #f7f7f7;
2752			border: 1px solid #ccc;
2753			color: #555;
2754			display: inline-block;
2755			text-decoration: none;
2756			font-size: 13px;
2757			line-height: 26px;
2758			height: 28px;
2759			margin: 0;
2760			padding: 0 10px 1px;
2761			cursor: pointer;
2762			-webkit-border-radius: 3px;
2763			-webkit-appearance: none;
2764			border-radius: 3px;
2765			white-space: nowrap;
2766			-webkit-box-sizing: border-box;
2767			-moz-box-sizing:    border-box;
2768			box-sizing:         border-box;
2769
2770			-webkit-box-shadow: 0 1px 0 #ccc;
2771			box-shadow: 0 1px 0 #ccc;
2772		 	vertical-align: top;
2773		}
2774
2775		.button.button-large {
2776			height: 30px;
2777			line-height: 28px;
2778			padding: 0 12px 2px;
2779		}
2780
2781		.button:hover,
2782		.button:focus {
2783			background: #fafafa;
2784			border-color: #999;
2785			color: #23282d;
2786		}
2787
2788		.button:focus  {
2789			border-color: #5b9dd9;
2790			-webkit-box-shadow: 0 0 3px rgba( 0, 115, 170, .8 );
2791			box-shadow: 0 0 3px rgba( 0, 115, 170, .8 );
2792			outline: none;
2793		}
2794
2795		.button:active {
2796			background: #eee;
2797			border-color: #999;
2798		 	-webkit-box-shadow: inset 0 2px 5px -3px rgba( 0, 0, 0, 0.5 );
2799		 	box-shadow: inset 0 2px 5px -3px rgba( 0, 0, 0, 0.5 );
2800		 	-webkit-transform: translateY(1px);
2801		 	-ms-transform: translateY(1px);
2802		 	transform: translateY(1px);
2803		}
2804
2805		<?php
2806		if ( 'rtl' == $text_direction ) {
2807			echo 'body { font-family: Tahoma, Arial; }';
2808		}
2809		?>
2810	</style>
2811</head>
2812<body id="error-page">
2813<?php endif; // ! did_action( 'admin_head' ) ?>
2814	<?php echo $message; ?>
2815</body>
2816</html>
2817<?php
2818	die();
2819}
2820
2821/**
2822 * Kill WordPress execution and display XML message with error message.
2823 *
2824 * This is the handler for wp_die when processing XMLRPC requests.
2825 *
2826 * @since 3.2.0
2827 * @access private
2828 *
2829 * @global wp_xmlrpc_server $wp_xmlrpc_server
2830 *
2831 * @param string       $message Error message.
2832 * @param string       $title   Optional. Error title. Default empty.
2833 * @param string|array $args    Optional. Arguments to control behavior. Default empty array.
2834 */
2835function _xmlrpc_wp_die_handler( $message, $title = '', $args = array() ) {
2836	global $wp_xmlrpc_server;
2837	$defaults = array( 'response' => 500 );
2838
2839	$r = wp_parse_args($args, $defaults);
2840
2841	if ( $wp_xmlrpc_server ) {
2842		$error = new IXR_Error( $r['response'] , $message);
2843		$wp_xmlrpc_server->output( $error->getXml() );
2844	}
2845	die();
2846}
2847
2848/**
2849 * Kill WordPress ajax execution.
2850 *
2851 * This is the handler for wp_die when processing Ajax requests.
2852 *
2853 * @since 3.4.0
2854 * @access private
2855 *
2856 * @param string $message Optional. Response to print. Default empty.
2857 */
2858function _ajax_wp_die_handler( $message = '' ) {
2859	if ( is_scalar( $message ) )
2860		die( (string) $message );
2861	die( '0' );
2862}
2863
2864/**
2865 * Kill WordPress execution.
2866 *
2867 * This is the handler for wp_die when processing APP requests.
2868 *
2869 * @since 3.4.0
2870 * @access private
2871 *
2872 * @param string $message Optional. Response to print. Default empty.
2873 */
2874function _scalar_wp_die_handler( $message = '' ) {
2875	if ( is_scalar( $message ) )
2876		die( (string) $message );
2877	die();
2878}
2879
2880/**
2881 * Encode a variable into JSON, with some sanity checks.
2882 *
2883 * @since 4.1.0
2884 *
2885 * @param mixed $data    Variable (usually an array or object) to encode as JSON.
2886 * @param int   $options Optional. Options to be passed to json_encode(). Default 0.
2887 * @param int   $depth   Optional. Maximum depth to walk through $data. Must be
2888 *                       greater than 0. Default 512.
2889 * @return string|false The JSON encoded string, or false if it cannot be encoded.
2890 */
2891function wp_json_encode( $data, $options = 0, $depth = 512 ) {
2892	/*
2893	 * json_encode() has had extra params added over the years.
2894	 * $options was added in 5.3, and $depth in 5.5.
2895	 * We need to make sure we call it with the correct arguments.
2896	 */
2897	if ( version_compare( PHP_VERSION, '5.5', '>=' ) ) {
2898		$args = array( $data, $options, $depth );
2899	} elseif ( version_compare( PHP_VERSION, '5.3', '>=' ) ) {
2900		$args = array( $data, $options );
2901	} else {
2902		$args = array( $data );
2903	}
2904
2905	// Prepare the data for JSON serialization.
2906	$data = _wp_json_prepare_data( $data );
2907
2908	$json = @call_user_func_array( 'json_encode', $args );
2909
2910	// If json_encode() was successful, no need to do more sanity checking.
2911	// ... unless we're in an old version of PHP, and json_encode() returned
2912	// a string containing 'null'. Then we need to do more sanity checking.
2913	if ( false !== $json && ( version_compare( PHP_VERSION, '5.5', '>=' ) || false === strpos( $json, 'null' ) ) )  {
2914		return $json;
2915	}
2916
2917	try {
2918		$args[0] = _wp_json_sanity_check( $data, $depth );
2919	} catch ( Exception $e ) {
2920		return false;
2921	}
2922
2923	return call_user_func_array( 'json_encode', $args );
2924}
2925
2926/**
2927 * Perform sanity checks on data that shall be encoded to JSON.
2928 *
2929 * @ignore
2930 * @since 4.1.0
2931 * @access private
2932 *
2933 * @see wp_json_encode()
2934 *
2935 * @param mixed $data  Variable (usually an array or object) to encode as JSON.
2936 * @param int   $depth Maximum depth to walk through $data. Must be greater than 0.
2937 * @return mixed The sanitized data that shall be encoded to JSON.
2938 */
2939function _wp_json_sanity_check( $data, $depth ) {
2940	if ( $depth < 0 ) {
2941		throw new Exception( 'Reached depth limit' );
2942	}
2943
2944	if ( is_array( $data ) ) {
2945		$output = array();
2946		foreach ( $data as $id => $el ) {
2947			// Don't forget to sanitize the ID!
2948			if ( is_string( $id ) ) {
2949				$clean_id = _wp_json_convert_string( $id );
2950			} else {
2951				$clean_id = $id;
2952			}
2953
2954			// Check the element type, so that we're only recursing if we really have to.
2955			if ( is_array( $el ) || is_object( $el ) ) {
2956				$output[ $clean_id ] = _wp_json_sanity_check( $el, $depth - 1 );
2957			} elseif ( is_string( $el ) ) {
2958				$output[ $clean_id ] = _wp_json_convert_string( $el );
2959			} else {
2960				$output[ $clean_id ] = $el;
2961			}
2962		}
2963	} elseif ( is_object( $data ) ) {
2964		$output = new stdClass;
2965		foreach ( $data as $id => $el ) {
2966			if ( is_string( $id ) ) {
2967				$clean_id = _wp_json_convert_string( $id );
2968			} else {
2969				$clean_id = $id;
2970			}
2971
2972			if ( is_array( $el ) || is_object( $el ) ) {
2973				$output->$clean_id = _wp_json_sanity_check( $el, $depth - 1 );
2974			} elseif ( is_string( $el ) ) {
2975				$output->$clean_id = _wp_json_convert_string( $el );
2976			} else {
2977				$output->$clean_id = $el;
2978			}
2979		}
2980	} elseif ( is_string( $data ) ) {
2981		return _wp_json_convert_string( $data );
2982	} else {
2983		return $data;
2984	}
2985
2986	return $output;
2987}
2988
2989/**
2990 * Convert a string to UTF-8, so that it can be safely encoded to JSON.
2991 *
2992 * @ignore
2993 * @since 4.1.0
2994 * @access private
2995 *
2996 * @see _wp_json_sanity_check()
2997 *
2998 * @staticvar bool $use_mb
2999 *
3000 * @param string $string The string which is to be converted.
3001 * @return string The checked string.
3002 */
3003function _wp_json_convert_string( $string ) {
3004	static $use_mb = null;
3005	if ( is_null( $use_mb ) ) {
3006		$use_mb = function_exists( 'mb_convert_encoding' );
3007	}
3008
3009	if ( $use_mb ) {
3010		$encoding = mb_detect_encoding( $string, mb_detect_order(), true );
3011		if ( $encoding ) {
3012			return mb_convert_encoding( $string, 'UTF-8', $encoding );
3013		} else {
3014			return mb_convert_encoding( $string, 'UTF-8', 'UTF-8' );
3015		}
3016	} else {
3017		return wp_check_invalid_utf8( $string, true );
3018	}
3019}
3020
3021/**
3022 * Prepares response data to be serialized to JSON.
3023 *
3024 * This supports the JsonSerializable interface for PHP 5.2-5.3 as well.
3025 *
3026 * @ignore
3027 * @since 4.4.0
3028 * @access private
3029 *
3030 * @param mixed $data Native representation.
3031 * @return bool|int|float|null|string|array Data ready for `json_encode()`.
3032 */
3033function _wp_json_prepare_data( $data ) {
3034	if ( ! defined( 'WP_JSON_SERIALIZE_COMPATIBLE' ) || WP_JSON_SERIALIZE_COMPATIBLE === false ) {
3035		return $data;
3036	}
3037
3038	switch ( gettype( $data ) ) {
3039		case 'boolean':
3040		case 'integer':
3041		case 'double':
3042		case 'string':
3043		case 'NULL':
3044			// These values can be passed through.
3045			return $data;
3046
3047		case 'array':
3048			// Arrays must be mapped in case they also return objects.
3049			return array_map( '_wp_json_prepare_data', $data );
3050
3051		case 'object':
3052			// If this is an incomplete object (__PHP_Incomplete_Class), bail.
3053			if ( ! is_object( $data ) ) {
3054				return null;
3055			}
3056
3057			if ( $data instanceof JsonSerializable ) {
3058				$data = $data->jsonSerialize();
3059			} else {
3060				$data = get_object_vars( $data );
3061			}
3062
3063			// Now, pass the array (or whatever was returned from jsonSerialize through).
3064			return _wp_json_prepare_data( $data );
3065
3066		default:
3067			return null;
3068	}
3069}
3070
3071/**
3072 * Send a JSON response back to an Ajax request.
3073 *
3074 * @since 3.5.0
3075 *
3076 * @param mixed $response Variable (usually an array or object) to encode as JSON,
3077 *                        then print and die.
3078 */
3079function wp_send_json( $response ) {
3080	@header( 'Content-Type: application/json; charset=' . get_option( 'blog_charset' ) );
3081	echo wp_json_encode( $response );
3082	if ( defined( 'DOING_AJAX' ) && DOING_AJAX )
3083		wp_die();
3084	else
3085		die;
3086}
3087
3088/**
3089 * Send a JSON response back to an Ajax request, indicating success.
3090 *
3091 * @since 3.5.0
3092 *
3093 * @param mixed $data Data to encode as JSON, then print and die.
3094 */
3095function wp_send_json_success( $data = null ) {
3096	$response = array( 'success' => true );
3097
3098	if ( isset( $data ) )
3099		$response['data'] = $data;
3100
3101	wp_send_json( $response );
3102}
3103
3104/**
3105 * Send a JSON response back to an Ajax request, indicating failure.
3106 *
3107 * If the `$data` parameter is a {@see WP_Error} object, the errors
3108 * within the object are processed and output as an array of error
3109 * codes and corresponding messages. All other types are output
3110 * without further processing.
3111 *
3112 * @since 3.5.0
3113 * @since 4.1.0 The `$data` parameter is now processed if a {@see WP_Error}
3114 *              object is passed in.
3115 *
3116 * @param mixed $data Data to encode as JSON, then print and die.
3117 */
3118function wp_send_json_error( $data = null ) {
3119	$response = array( 'success' => false );
3120
3121	if ( isset( $data ) ) {
3122		if ( is_wp_error( $data ) ) {
3123			$result = array();
3124			foreach ( $data->errors as $code => $messages ) {
3125				foreach ( $messages as $message ) {
3126					$result[] = array( 'code' => $code, 'message' => $message );
3127				}
3128			}
3129
3130			$response['data'] = $result;
3131		} else {
3132			$response['data'] = $data;
3133		}
3134	}
3135
3136	wp_send_json( $response );
3137}
3138
3139/**
3140 * Retrieve the WordPress home page URL.
3141 *
3142 * If the constant named 'WP_HOME' exists, then it will be used and returned
3143 * by the function. This can be used to counter the redirection on your local
3144 * development environment.
3145 *
3146 * @since 2.2.0
3147 * @access private
3148 *
3149 * @see WP_HOME
3150 *
3151 * @param string $url URL for the home location.
3152 * @return string Homepage location.
3153 */
3154function _config_wp_home( $url = '' ) {
3155	if ( defined( 'WP_HOME' ) )
3156		return untrailingslashit( WP_HOME );
3157	return $url;
3158}
3159
3160/**
3161 * Retrieve the WordPress site URL.
3162 *
3163 * If the constant named 'WP_SITEURL' is defined, then the value in that
3164 * constant will always be returned. This can be used for debugging a site
3165 * on your localhost while not having to change the database to your URL.
3166 *
3167 * @since 2.2.0
3168 * @access private
3169 *
3170 * @see WP_SITEURL
3171 *
3172 * @param string $url URL to set the WordPress site location.
3173 * @return string The WordPress Site URL.
3174 */
3175function _config_wp_siteurl( $url = '' ) {
3176	if ( defined( 'WP_SITEURL' ) )
3177		return untrailingslashit( WP_SITEURL );
3178	return $url;
3179}
3180
3181/**
3182 * Set the localized direction for MCE plugin.
3183 *
3184 * Will only set the direction to 'rtl', if the WordPress locale has
3185 * the text direction set to 'rtl'.
3186 *
3187 * Fills in the 'directionality' setting, enables the 'directionality'
3188 * plugin, and adds the 'ltr' button to 'toolbar1', formerly
3189 * 'theme_advanced_buttons1' array keys. These keys are then returned
3190 * in the $input (TinyMCE settings) array.
3191 *
3192 * @since 2.1.0
3193 * @access private
3194 *
3195 * @param array $input MCE settings array.
3196 * @return array Direction set for 'rtl', if needed by locale.
3197 */
3198function _mce_set_direction( $input ) {
3199	if ( is_rtl() ) {
3200		$input['directionality'] = 'rtl';
3201
3202		if ( ! empty( $input['plugins'] ) && strpos( $input['plugins'], 'directionality' ) === false ) {
3203			$input['plugins'] .= ',directionality';
3204		}
3205
3206		if ( ! empty( $input['toolbar1'] ) && ! preg_match( '/\bltr\b/', $input['toolbar1'] ) ) {
3207			$input['toolbar1'] .= ',ltr';
3208		}
3209	}
3210
3211	return $input;
3212}
3213
3214
3215/**
3216 * Convert smiley code to the icon graphic file equivalent.
3217 *
3218 * You can turn off smilies, by going to the write setting screen and unchecking
3219 * the box, or by setting 'use_smilies' option to false or removing the option.
3220 *
3221 * Plugins may override the default smiley list by setting the $wpsmiliestrans
3222 * to an array, with the key the code the blogger types in and the value the
3223 * image file.
3224 *
3225 * The $wp_smiliessearch global is for the regular expression and is set each
3226 * time the function is called.
3227 *
3228 * The full list of smilies can be found in the function and won't be listed in
3229 * the description. Probably should create a Codex page for it, so that it is
3230 * available.
3231 *
3232 * @global array $wpsmiliestrans
3233 * @global array $wp_smiliessearch
3234 *
3235 * @since 2.2.0
3236 */
3237function smilies_init() {
3238	global $wpsmiliestrans, $wp_smiliessearch;
3239
3240	// don't bother setting up smilies if they are disabled
3241	if ( !get_option( 'use_smilies' ) )
3242		return;
3243
3244	if ( !isset( $wpsmiliestrans ) ) {
3245		$wpsmiliestrans = array(
3246		':mrgreen:' => 'mrgreen.png',
3247		':neutral:' => "\xf0\x9f\x98\x90",
3248		':twisted:' => "\xf0\x9f\x98\x88",
3249		  ':arrow:' => "\xe2\x9e\xa1",
3250		  ':shock:' => "\xf0\x9f\x98\xaf",
3251		  ':smile:' => "\xf0\x9f\x99\x82",
3252		    ':???:' => "\xf0\x9f\x98\x95",
3253		   ':cool:' => "\xf0\x9f\x98\x8e",
3254		   ':evil:' => "\xf0\x9f\x91\xbf",
3255		   ':grin:' => "\xf0\x9f\x98\x80",
3256		   ':idea:' => "\xf0\x9f\x92\xa1",
3257		   ':oops:' => "\xf0\x9f\x98\xb3",
3258		   ':razz:' => "\xf0\x9f\x98\x9b",
3259		   ':roll:' => 'rolleyes.png',
3260		   ':wink:' => "\xf0\x9f\x98\x89",
3261		    ':cry:' => "\xf0\x9f\x98\xa5",
3262		    ':eek:' => "\xf0\x9f\x98\xae",
3263		    ':lol:' => "\xf0\x9f\x98\x86",
3264		    ':mad:' => "\xf0\x9f\x98\xa1",
3265		    ':sad:' => "\xf0\x9f\x99\x81",
3266		      '8-)' => "\xf0\x9f\x98\x8e",
3267		      '8-O' => "\xf0\x9f\x98\xaf",
3268		      ':-(' => "\xf0\x9f\x99\x81",
3269		      ':-)' => "\xf0\x9f\x99\x82",
3270		      ':-?' => "\xf0\x9f\x98\x95",
3271		      ':-D' => "\xf0\x9f\x98\x80",
3272		      ':-P' => "\xf0\x9f\x98\x9b",
3273		      ':-o' => "\xf0\x9f\x98\xae",
3274		      ':-x' => "\xf0\x9f\x98\xa1",
3275		      ':-|' => "\xf0\x9f\x98\x90",
3276		      ';-)' => "\xf0\x9f\x98\x89",
3277		// This one transformation breaks regular text with frequency.
3278		//     '8)' => "\xf0\x9f\x98\x8e",
3279		       '8O' => "\xf0\x9f\x98\xaf",
3280		       ':(' => "\xf0\x9f\x99\x81",
3281		       ':)' => "\xf0\x9f\x99\x82",
3282		       ':?' => "\xf0\x9f\x98\x95",
3283		       ':D' => "\xf0\x9f\x98\x80",
3284		       ':P' => "\xf0\x9f\x98\x9b",
3285		       ':o' => "\xf0\x9f\x98\xae",
3286		       ':x' => "\xf0\x9f\x98\xa1",
3287		       ':|' => "\xf0\x9f\x98\x90",
3288		       ';)' => "\xf0\x9f\x98\x89",
3289		      ':!:' => "\xe2\x9d\x97",
3290		      ':?:' => "\xe2\x9d\x93",
3291		);
3292	}
3293
3294	if (count($wpsmiliestrans) == 0) {
3295		return;
3296	}
3297
3298	/*
3299	 * NOTE: we sort the smilies in reverse key order. This is to make sure
3300	 * we match the longest possible smilie (:???: vs :?) as the regular
3301	 * expression used below is first-match
3302	 */
3303	krsort($wpsmiliestrans);
3304
3305	$spaces = wp_spaces_regexp();
3306
3307	// Begin first "subpattern"
3308	$wp_smiliessearch = '/(?<=' . $spaces . '|^)';
3309
3310	$subchar = '';
3311	foreach ( (array) $wpsmiliestrans as $smiley => $img ) {
3312		$firstchar = substr($smiley, 0, 1);
3313		$rest = substr($smiley, 1);
3314
3315		// new subpattern?
3316		if ($firstchar != $subchar) {
3317			if ($subchar != '') {
3318				$wp_smiliessearch .= ')(?=' . $spaces . '|$)';  // End previous "subpattern"
3319				$wp_smiliessearch .= '|(?<=' . $spaces . '|^)'; // Begin another "subpattern"
3320			}
3321			$subchar = $firstchar;
3322			$wp_smiliessearch .= preg_quote($firstchar, '/') . '(?:';
3323		} else {
3324			$wp_smiliessearch .= '|';
3325		}
3326		$wp_smiliessearch .= preg_quote($rest, '/');
3327	}
3328
3329	$wp_smiliessearch .= ')(?=' . $spaces . '|$)/m';
3330
3331}
3332
3333/**
3334 * Merge user defined arguments into defaults array.
3335 *
3336 * This function is used throughout WordPress to allow for both string or array
3337 * to be merged into another array.
3338 *
3339 * @since 2.2.0
3340 *
3341 * @param string|array $args     Value to merge with $defaults
3342 * @param array        $defaults Optional. Array that serves as the defaults. Default empty.
3343 * @return array Merged user defined values with defaults.
3344 */
3345function wp_parse_args( $args, $defaults = '' ) {
3346	if ( is_object( $args ) )
3347		$r = get_object_vars( $args );
3348	elseif ( is_array( $args ) )
3349		$r =& $args;
3350	else
3351		wp_parse_str( $args, $r );
3352
3353	if ( is_array( $defaults ) )
3354		return array_merge( $defaults, $r );
3355	return $r;
3356}
3357
3358/**
3359 * Clean up an array, comma- or space-separated list of IDs.
3360 *
3361 * @since 3.0.0
3362 *
3363 * @param array|string $list List of ids.
3364 * @return array Sanitized array of IDs.
3365 */
3366function wp_parse_id_list( $list ) {
3367	if ( !is_array($list) )
3368		$list = preg_split('/[\s,]+/', $list);
3369
3370	return array_unique(array_map('absint', $list));
3371}
3372
3373/**
3374 * Extract a slice of an array, given a list of keys.
3375 *
3376 * @since 3.1.0
3377 *
3378 * @param array $array The original array.
3379 * @param array $keys  The list of keys.
3380 * @return array The array slice.
3381 */
3382function wp_array_slice_assoc( $array, $keys ) {
3383	$slice = array();
3384	foreach ( $keys as $key )
3385		if ( isset( $array[ $key ] ) )
3386			$slice[ $key ] = $array[ $key ];
3387
3388	return $slice;
3389}
3390
3391/**
3392 * Determines if the variable is a numeric-indexed array.
3393 *
3394 * @since 4.4.0
3395 *
3396 * @param mixed $data Variable to check.
3397 * @return bool Whether the variable is a list.
3398 */
3399function wp_is_numeric_array( $data ) {
3400	if ( ! is_array( $data ) ) {
3401		return false;
3402	}
3403
3404	$keys = array_keys( $data );
3405	$string_keys = array_filter( $keys, 'is_string' );
3406	return count( $string_keys ) === 0;
3407}
3408
3409/**
3410 * Filters a list of objects, based on a set of key => value arguments.
3411 *
3412 * @since 3.0.0
3413 *
3414 * @param array       $list     An array of objects to filter
3415 * @param array       $args     Optional. An array of key => value arguments to match
3416 *                              against each object. Default empty array.
3417 * @param string      $operator Optional. The logical operation to perform. 'or' means
3418 *                              only one element from the array needs to match; 'and'
3419 *                              means all elements must match; 'not' means no elements may
3420 *                              match. Default 'and'.
3421 * @param bool|string $field    A field from the object to place instead of the entire object.
3422 *                              Default false.
3423 * @return array A list of objects or object fields.
3424 */
3425function wp_filter_object_list( $list, $args = array(), $operator = 'and', $field = false ) {
3426	if ( ! is_array( $list ) )
3427		return array();
3428
3429	$list = wp_list_filter( $list, $args, $operator );
3430
3431	if ( $field )
3432		$list = wp_list_pluck( $list, $field );
3433
3434	return $list;
3435}
3436
3437/**
3438 * Filters a list of objects, based on a set of key => value arguments.
3439 *
3440 * @since 3.1.0
3441 *
3442 * @param array  $list     An array of objects to filter.
3443 * @param array  $args     Optional. An array of key => value arguments to match
3444 *                         against each object. Default empty array.
3445 * @param string $operator Optional. The logical operation to perform. 'AND' means
3446 *                         all elements from the array must match. 'OR' means only
3447 *                         one element needs to match. 'NOT' means no elements may
3448 *                         match. Default 'AND'.
3449 * @return array Array of found values.
3450 */
3451function wp_list_filter( $list, $args = array(), $operator = 'AND' ) {
3452	if ( ! is_array( $list ) )
3453		return array();
3454
3455	if ( empty( $args ) )
3456		return $list;
3457
3458	$operator = strtoupper( $operator );
3459	$count = count( $args );
3460	$filtered = array();
3461
3462	foreach ( $list as $key => $obj ) {
3463		$to_match = (array) $obj;
3464
3465		$matched = 0;
3466		foreach ( $args as $m_key => $m_value ) {
3467			if ( array_key_exists( $m_key, $to_match ) && $m_value == $to_match[ $m_key ] )
3468				$matched++;
3469		}
3470
3471		if ( ( 'AND' == $operator && $matched == $count )
3472		  || ( 'OR' == $operator && $matched > 0 )
3473		  || ( 'NOT' == $operator && 0 == $matched ) ) {
3474			$filtered[$key] = $obj;
3475		}
3476	}
3477
3478	return $filtered;
3479}
3480
3481/**
3482 * Pluck a certain field out of each object in a list.
3483 *
3484 * This has the same functionality and prototype of
3485 * array_column() (PHP 5.5) but also supports objects.
3486 *
3487 * @since 3.1.0
3488 * @since 4.0.0 $index_key parameter added.
3489 *
3490 * @param array      $list      List of objects or arrays
3491 * @param int|string $field     Field from the object to place instead of the entire object
3492 * @param int|string $index_key Optional. Field from the object to use as keys for the new array.
3493 *                              Default null.
3494 * @return array Array of found values. If `$index_key` is set, an array of found values with keys
3495 *               corresponding to `$index_key`. If `$index_key` is null, array keys from the original
3496 *               `$list` will be preserved in the results.
3497 */
3498function wp_list_pluck( $list, $field, $index_key = null ) {
3499	if ( ! $index_key ) {
3500		/*
3501		 * This is simple. Could at some point wrap array_column()
3502		 * if we knew we had an array of arrays.
3503		 */
3504		foreach ( $list as $key => $value ) {
3505			if ( is_object( $value ) ) {
3506				$list[ $key ] = $value->$field;
3507			} else {
3508				$list[ $key ] = $value[ $field ];
3509			}
3510		}
3511		return $list;
3512	}
3513
3514	/*
3515	 * When index_key is not set for a particular item, push the value
3516	 * to the end of the stack. This is how array_column() behaves.
3517	 */
3518	$newlist = array();
3519	foreach ( $list as $value ) {
3520		if ( is_object( $value ) ) {
3521			if ( isset( $value->$index_key ) ) {
3522				$newlist[ $value->$index_key ] = $value->$field;
3523			} else {
3524				$newlist[] = $value->$field;
3525			}
3526		} else {
3527			if ( isset( $value[ $index_key ] ) ) {
3528				$newlist[ $value[ $index_key ] ] = $value[ $field ];
3529			} else {
3530				$newlist[] = $value[ $field ];
3531			}
3532		}
3533	}
3534
3535	return $newlist;
3536}
3537
3538/**
3539 * Determines if Widgets library should be loaded.
3540 *
3541 * Checks to make sure that the widgets library hasn't already been loaded.
3542 * If it hasn't, then it will load the widgets library and run an action hook.
3543 *
3544 * @since 2.2.0
3545 */
3546function wp_maybe_load_widgets() {
3547	/**
3548	 * Filter whether to load the Widgets library.
3549	 *
3550	 * Passing a falsey value to the filter will effectively short-circuit
3551	 * the Widgets library from loading.
3552	 *
3553	 * @since 2.8.0
3554	 *
3555	 * @param bool $wp_maybe_load_widgets Whether to load the Widgets library.
3556	 *                                    Default true.
3557	 */
3558	if ( ! apply_filters( 'load_default_widgets', true ) ) {
3559		return;
3560	}
3561
3562	require_once( ABSPATH . WPINC . '/default-widgets.php' );
3563
3564	add_action( '_admin_menu', 'wp_widgets_add_menu' );
3565}
3566
3567/**
3568 * Append the Widgets menu to the themes main menu.
3569 *
3570 * @since 2.2.0
3571 *
3572 * @global array $submenu
3573 */
3574function wp_widgets_add_menu() {
3575	global $submenu;
3576
3577	if ( ! current_theme_supports( 'widgets' ) )
3578		return;
3579
3580	$submenu['themes.php'][7] = array( __( 'Widgets' ), 'edit_theme_options', 'widgets.php' );
3581	ksort( $submenu['themes.php'], SORT_NUMERIC );
3582}
3583
3584/**
3585 * Flush all output buffers for PHP 5.2.
3586 *
3587 * Make sure all output buffers are flushed before our singletons are destroyed.
3588 *
3589 * @since 2.2.0
3590 */
3591function wp_ob_end_flush_all() {
3592	$levels = ob_get_level();
3593	for ($i=0; $i<$levels; $i++)
3594		ob_end_flush();
3595}
3596
3597/**
3598 * Load custom DB error or display WordPress DB error.
3599 *
3600 * If a file exists in the wp-content directory named db-error.php, then it will
3601 * be loaded instead of displaying the WordPress DB error. If it is not found,
3602 * then the WordPress DB error will be displayed instead.
3603 *
3604 * The WordPress DB error sets the HTTP status header to 500 to try to prevent
3605 * search engines from caching the message. Custom DB messages should do the
3606 * same.
3607 *
3608 * This function was backported to WordPress 2.3.2, but originally was added
3609 * in WordPress 2.5.0.
3610 *
3611 * @since 2.3.2
3612 *
3613 * @global wpdb $wpdb WordPress database abstraction object.
3614 */
3615function dead_db() {
3616	global $wpdb;
3617
3618	wp_load_translations_early();
3619
3620	// Load custom DB error template, if present.
3621	if ( file_exists( WP_CONTENT_DIR . '/db-error.php' ) ) {
3622		require_once( WP_CONTENT_DIR . '/db-error.php' );
3623		die();
3624	}
3625
3626	// If installing or in the admin, provide the verbose message.
3627	if ( wp_installing() || defined( 'WP_ADMIN' ) )
3628		wp_die($wpdb->error);
3629
3630	// Otherwise, be terse.
3631	status_header( 500 );
3632	nocache_headers();
3633	header( 'Content-Type: text/html; charset=utf-8' );
3634?>
3635<!DOCTYPE html>
3636<html xmlns="http://www.w3.org/1999/xhtml"<?php if ( is_rtl() ) echo ' dir="rtl"'; ?>>
3637<head>
3638<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
3639	<title><?php _e( 'Database Error' ); ?></title>
3640
3641</head>
3642<body>
3643	<h1><?php _e( 'Error establishing a database connection' ); ?></h1>
3644</body>
3645</html>
3646<?php
3647	die();
3648}
3649
3650/**
3651 * Convert a value to non-negative integer.
3652 *
3653 * @since 2.5.0
3654 *
3655 * @param mixed $maybeint Data you wish to have converted to a non-negative integer.
3656 * @return int A non-negative integer.
3657 */
3658function absint( $maybeint ) {
3659	return abs( intval( $maybeint ) );
3660}
3661
3662/**
3663 * Mark a function as deprecated and inform when it has been used.
3664 *
3665 * There is a hook deprecated_function_run that will be called that can be used
3666 * to get the backtrace up to what file and function called the deprecated
3667 * function.
3668 *
3669 * The current behavior is to trigger a user error if WP_DEBUG is true.
3670 *
3671 * This function is to be used in every function that is deprecated.
3672 *
3673 * @since 2.5.0
3674 * @access private
3675 *
3676 * @param string $function    The function that was called.
3677 * @param string $version     The version of WordPress that deprecated the function.
3678 * @param string $replacement Optional. The function that should have been called. Default null.
3679 */
3680function _deprecated_function( $function, $version, $replacement = null ) {
3681
3682	/**
3683	 * Fires when a deprecated function is called.
3684	 *
3685	 * @since 2.5.0
3686	 *
3687	 * @param string $function    The function that was called.
3688	 * @param string $replacement The function that should have been called.
3689	 * @param string $version     The version of WordPress that deprecated the function.
3690	 */
3691	do_action( 'deprecated_function_run', $function, $replacement, $version );
3692
3693	/**
3694	 * Filter whether to trigger an error for deprecated functions.
3695	 *
3696	 * @since 2.5.0
3697	 *
3698	 * @param bool $trigger Whether to trigger the error for deprecated functions. Default true.
3699	 */
3700	if ( WP_DEBUG && apply_filters( 'deprecated_function_trigger_error', true ) ) {
3701		if ( function_exists( '__' ) ) {
3702			if ( ! is_null( $replacement ) )
3703				trigger_error( sprintf( __('%1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.'), $function, $version, $replacement ) );
3704			else
3705				trigger_error( sprintf( __('%1$s is <strong>deprecated</strong> since version %2$s with no alternative available.'), $function, $version ) );
3706		} else {
3707			if ( ! is_null( $replacement ) )
3708				trigger_error( sprintf( '%1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.', $function, $version, $replacement ) );
3709			else
3710				trigger_error( sprintf( '%1$s is <strong>deprecated</strong> since version %2$s with no alternative available.', $function, $version ) );
3711		}
3712	}
3713}
3714
3715/**
3716 * Marks a constructor as deprecated and informs when it has been used.
3717 *
3718 * Similar to _deprecated_function(), but with different strings. Used to
3719 * remove PHP4 style constructors.
3720 *
3721 * The current behavior is to trigger a user error if `WP_DEBUG` is true.
3722 *
3723 * This function is to be used in every PHP4 style constructor method that is deprecated.
3724 *
3725 * @since 4.3.0
3726 * @since 4.5.0 Added the `$parent_class` parameter.
3727 *
3728 * @access private
3729 *
3730 * @param string $class        The class containing the deprecated constructor.
3731 * @param string $version      The version of WordPress that deprecated the function.
3732 * @param string $parent_class Optional. The parent class calling the deprecated constructor.
3733 *                             Default empty string.
3734 */
3735function _deprecated_constructor( $class, $version, $parent_class = '' ) {
3736
3737	/**
3738	 * Fires when a deprecated constructor is called.
3739	 *
3740	 * @since 4.3.0
3741	 * @since 4.5.0 Added the `$parent_class` parameter.
3742	 *
3743	 * @param string $class        The class containing the deprecated constructor.
3744	 * @param string $version      The version of WordPress that deprecated the function.
3745	 * @param string $parent_class The parent class calling the deprecated constructor.
3746	 */
3747	do_action( 'deprecated_constructor_run', $class, $version, $parent_class );
3748
3749	/**
3750	 * Filter whether to trigger an error for deprecated functions.
3751	 *
3752	 * `WP_DEBUG` must be true in addition to the filter evaluating to true.
3753	 *
3754	 * @since 4.3.0
3755	 *
3756	 * @param bool $trigger Whether to trigger the error for deprecated functions. Default true.
3757	 */
3758	if ( WP_DEBUG && apply_filters( 'deprecated_constructor_trigger_error', true ) ) {
3759		if ( function_exists( '__' ) ) {
3760			if ( ! empty( $parent_class ) ) {
3761				/* translators: 1: PHP class name, 2: PHP parent class name, 3: version number, 4: __construct() method */
3762				trigger_error( sprintf( __( 'The called constructor method for %1$s in %2$s is <strong>deprecated</strong> since version %3$s! Use %4$s instead.' ),
3763					$class, $parent_class, $version, '<pre>__construct()</pre>' ) );
3764			} else {
3765				/* translators: 1: PHP class name, 2: version number, 3: __construct() method */
3766				trigger_error( sprintf( __( 'The called constructor method for %1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.' ),
3767					$class, $version, '<pre>__construct()</pre>' ) );
3768			}
3769		} else {
3770			if ( ! empty( $parent_class ) ) {
3771				trigger_error( sprintf( 'The called constructor method for %1$s in %2$s is <strong>deprecated</strong> since version %3$s! Use %4$s instead.',
3772					$class, $parent_class, $version, '<pre>__construct()</pre>' ) );
3773			} else {
3774				trigger_error( sprintf( 'The called constructor method for %1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.',
3775					$class, $version, '<pre>__construct()</pre>' ) );
3776			}
3777		}
3778	}
3779
3780}
3781
3782/**
3783 * Mark a file as deprecated and inform when it has been used.
3784 *
3785 * There is a hook deprecated_file_included that will be called that can be used
3786 * to get the backtrace up to what file and function included the deprecated
3787 * file.
3788 *
3789 * The current behavior is to trigger a user error if WP_DEBUG is true.
3790 *
3791 * This function is to be used in every file that is deprecated.
3792 *
3793 * @since 2.5.0
3794 * @access private
3795 *
3796 * @param string $file        The file that was included.
3797 * @param string $version     The version of WordPress that deprecated the file.
3798 * @param string $replacement Optional. The file that should have been included based on ABSPATH.
3799 *                            Default null.
3800 * @param string $message     Optional. A message regarding the change. Default empty.
3801 */
3802function _deprecated_file( $file, $version, $replacement = null, $message = '' ) {
3803
3804	/**
3805	 * Fires when a deprecated file is called.
3806	 *
3807	 * @since 2.5.0
3808	 *
3809	 * @param string $file        The file that was called.
3810	 * @param string $replacement The file that should have been included based on ABSPATH.
3811	 * @param string $version     The version of WordPress that deprecated the file.
3812	 * @param string $message     A message regarding the change.
3813	 */
3814	do_action( 'deprecated_file_included', $file, $replacement, $version, $message );
3815
3816	/**
3817	 * Filter whether to trigger an error for deprecated files.
3818	 *
3819	 * @since 2.5.0
3820	 *
3821	 * @param bool $trigger Whether to trigger the error for deprecated files. Default true.
3822	 */
3823	if ( WP_DEBUG && apply_filters( 'deprecated_file_trigger_error', true ) ) {
3824		$message = empty( $message ) ? '' : ' ' . $message;
3825		if ( function_exists( '__' ) ) {
3826			if ( ! is_null( $replacement ) )
3827				trigger_error( sprintf( __('%1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.'), $file, $version, $replacement ) . $message );
3828			else
3829				trigger_error( sprintf( __('%1$s is <strong>deprecated</strong> since version %2$s with no alternative available.'), $file, $version ) . $message );
3830		} else {
3831			if ( ! is_null( $replacement ) )
3832				trigger_error( sprintf( '%1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.', $file, $version, $replacement ) . $message );
3833			else
3834				trigger_error( sprintf( '%1$s is <strong>deprecated</strong> since version %2$s with no alternative available.', $file, $version ) . $message );
3835		}
3836	}
3837}
3838/**
3839 * Mark a function argument as deprecated and inform when it has been used.
3840 *
3841 * This function is to be used whenever a deprecated function argument is used.
3842 * Before this function is called, the argument must be checked for whether it was
3843 * used by comparing it to its default value or evaluating whether it is empty.
3844 * For example:
3845 *
3846 *     if ( ! empty( $deprecated ) ) {
3847 *         _deprecated_argument( __FUNCTION__, '3.0' );
3848 *     }
3849 *
3850 *
3851 * There is a hook deprecated_argument_run that will be called that can be used
3852 * to get the backtrace up to what file and function used the deprecated
3853 * argument.
3854 *
3855 * The current behavior is to trigger a user error if WP_DEBUG is true.
3856 *
3857 * @since 3.0.0
3858 * @access private
3859 *
3860 * @param string $function The function that was called.
3861 * @param string $version  The version of WordPress that deprecated the argument used.
3862 * @param string $message  Optional. A message regarding the change. Default null.
3863 */
3864function _deprecated_argument( $function, $version, $message = null ) {
3865
3866	/**
3867	 * Fires when a deprecated argument is called.
3868	 *
3869	 * @since 3.0.0
3870	 *
3871	 * @param string $function The function that was called.
3872	 * @param string $message  A message regarding the change.
3873	 * @param string $version  The version of WordPress that deprecated the argument used.
3874	 */
3875	do_action( 'deprecated_argument_run', $function, $message, $version );
3876
3877	/**
3878	 * Filter whether to trigger an error for deprecated arguments.
3879	 *
3880	 * @since 3.0.0
3881	 *
3882	 * @param bool $trigger Whether to trigger the error for deprecated arguments. Default true.
3883	 */
3884	if ( WP_DEBUG && apply_filters( 'deprecated_argument_trigger_error', true ) ) {
3885		if ( function_exists( '__' ) ) {
3886			if ( ! is_null( $message ) )
3887				trigger_error( sprintf( __('%1$s was called with an argument that is <strong>deprecated</strong> since version %2$s! %3$s'), $function, $version, $message ) );
3888			else
3889				trigger_error( sprintf( __('%1$s was called with an argument that is <strong>deprecated</strong> since version %2$s with no alternative available.'), $function, $version ) );
3890		} else {
3891			if ( ! is_null( $message ) )
3892				trigger_error( sprintf( '%1$s was called with an argument that is <strong>deprecated</strong> since version %2$s! %3$s', $function, $version, $message ) );
3893			else
3894				trigger_error( sprintf( '%1$s was called with an argument that is <strong>deprecated</strong> since version %2$s with no alternative available.', $function, $version ) );
3895		}
3896	}
3897}
3898
3899/**
3900 * Mark something as being incorrectly called.
3901 *
3902 * There is a hook doing_it_wrong_run that will be called that can be used
3903 * to get the backtrace up to what file and function called the deprecated
3904 * function.
3905 *
3906 * The current behavior is to trigger a user error if WP_DEBUG is true.
3907 *
3908 * @since 3.1.0
3909 * @access private
3910 *
3911 * @param string $function The function that was called.
3912 * @param string $message  A message explaining what has been done incorrectly.
3913 * @param string $version  The version of WordPress where the message was added.
3914 */
3915function _doing_it_wrong( $function, $message, $version ) {
3916
3917	/**
3918	 * Fires when the given function is being used incorrectly.
3919	 *
3920	 * @since 3.1.0
3921	 *
3922	 * @param string $function The function that was called.
3923	 * @param string $message  A message explaining what has been done incorrectly.
3924	 * @param string $version  The version of WordPress where the message was added.
3925	 */
3926	do_action( 'doing_it_wrong_run', $function, $message, $version );
3927
3928	/**
3929	 * Filter whether to trigger an error for _doing_it_wrong() calls.
3930	 *
3931	 * @since 3.1.0
3932	 *
3933	 * @param bool $trigger Whether to trigger the error for _doing_it_wrong() calls. Default true.
3934	 */
3935	if ( WP_DEBUG && apply_filters( 'doing_it_wrong_trigger_error', true ) ) {
3936		if ( function_exists( '__' ) ) {
3937			$version = is_null( $version ) ? '' : sprintf( __( '(This message was added in version %s.)' ), $version );
3938			/* translators: %s: Codex URL */
3939			$message .= ' ' . sprintf( __( 'Please see <a href="%s">Debugging in WordPress</a> for more information.' ),
3940				__( 'https://codex.wordpress.org/Debugging_in_WordPress' )
3941			);
3942			trigger_error( sprintf( __( '%1$s was called <strong>incorrectly</strong>. %2$s %3$s' ), $function, $message, $version ) );
3943		} else {
3944			$version = is_null( $version ) ? '' : sprintf( '(This message was added in version %s.)', $version );
3945			$message .= sprintf( ' Please see <a href="%s">Debugging in WordPress</a> for more information.',
3946				'https://codex.wordpress.org/Debugging_in_WordPress'
3947			);
3948			trigger_error( sprintf( '%1$s was called <strong>incorrectly</strong>. %2$s %3$s', $function, $message, $version ) );
3949		}
3950	}
3951}
3952
3953/**
3954 * Is the server running earlier than 1.5.0 version of lighttpd?
3955 *
3956 * @since 2.5.0
3957 *
3958 * @return bool Whether the server is running lighttpd < 1.5.0.
3959 */
3960function is_lighttpd_before_150() {
3961	$server_parts = explode( '/', isset( $_SERVER['SERVER_SOFTWARE'] )? $_SERVER['SERVER_SOFTWARE'] : '' );
3962	$server_parts[1] = isset( $server_parts[1] )? $server_parts[1] : '';
3963	return  'lighttpd' == $server_parts[0] && -1 == version_compare( $server_parts[1], '1.5.0' );
3964}
3965
3966/**
3967 * Does the specified module exist in the Apache config?
3968 *
3969 * @since 2.5.0
3970 *
3971 * @global bool $is_apache
3972 *
3973 * @param string $mod     The module, e.g. mod_rewrite.
3974 * @param bool   $default Optional. The default return value if the module is not found. Default false.
3975 * @return bool Whether the specified module is loaded.
3976 */
3977function apache_mod_loaded($mod, $default = false) {
3978	global $is_apache;
3979
3980	if ( !$is_apache )
3981		return false;
3982
3983	if ( function_exists( 'apache_get_modules' ) ) {
3984		$mods = apache_get_modules();
3985		if ( in_array($mod, $mods) )
3986			return true;
3987	} elseif ( function_exists( 'phpinfo' ) && false === strpos( ini_get( 'disable_functions' ), 'phpinfo' ) ) {
3988			ob_start();
3989			phpinfo(8);
3990			$phpinfo = ob_get_clean();
3991			if ( false !== strpos($phpinfo, $mod) )
3992				return true;
3993	}
3994	return $default;
3995}
3996
3997/**
3998 * Check if IIS 7+ supports pretty permalinks.
3999 *
4000 * @since 2.8.0
4001 *
4002 * @global bool $is_iis7
4003 *
4004 * @return bool Whether IIS7 supports permalinks.
4005 */
4006function iis7_supports_permalinks() {
4007	global $is_iis7;
4008
4009	$supports_permalinks = false;
4010	if ( $is_iis7 ) {
4011		/* First we check if the DOMDocument class exists. If it does not exist, then we cannot
4012		 * easily update the xml configuration file, hence we just bail out and tell user that
4013		 * pretty permalinks cannot be used.
4014		 *
4015		 * Next we check if the URL Rewrite Module 1.1 is loaded and enabled for the web site. When
4016		 * URL Rewrite 1.1 is loaded it always sets a server variable called 'IIS_UrlRewriteModule'.
4017		 * Lastly we make sure that PHP is running via FastCGI. This is important because if it runs
4018		 * via ISAPI then pretty permalinks will not work.
4019		 */
4020		$supports_permalinks = class_exists( 'DOMDocument', false ) && isset($_SERVER['IIS_UrlRewriteModule']) && ( PHP_SAPI == 'cgi-fcgi' );
4021	}
4022
4023	/**
4024	 * Filter whether IIS 7+ supports pretty permalinks.
4025	 *
4026	 * @since 2.8.0
4027	 *
4028	 * @param bool $supports_permalinks Whether IIS7 supports permalinks. Default false.
4029	 */
4030	return apply_filters( 'iis7_supports_permalinks', $supports_permalinks );
4031}
4032
4033/**
4034 * File validates against allowed set of defined rules.
4035 *
4036 * A return value of '1' means that the $file contains either '..' or './'. A
4037 * return value of '2' means that the $file contains ':' after the first
4038 * character. A return value of '3' means that the file is not in the allowed
4039 * files list.
4040 *
4041 * @since 1.2.0
4042 *
4043 * @param string $file File path.
4044 * @param array  $allowed_files List of allowed files.
4045 * @return int 0 means nothing is wrong, greater than 0 means something was wrong.
4046 */
4047function validate_file( $file, $allowed_files = '' ) {
4048	if ( false !== strpos( $file, '..' ) )
4049		return 1;
4050
4051	if ( false !== strpos( $file, './' ) )
4052		return 1;
4053
4054	if ( ! empty( $allowed_files ) && ! in_array( $file, $allowed_files ) )
4055		return 3;
4056
4057	if (':' == substr( $file, 1, 1 ) )
4058		return 2;
4059
4060	return 0;
4061}
4062
4063/**
4064 * Determine if SSL is used.
4065 *
4066 * @since 2.6.0
4067 *
4068 * @return bool True if SSL, false if not used.
4069 */
4070function is_ssl() {
4071	if ( isset($_SERVER['HTTPS']) ) {
4072		if ( 'on' == strtolower($_SERVER['HTTPS']) )
4073			return true;
4074		if ( '1' == $_SERVER['HTTPS'] )
4075			return true;
4076	} elseif ( isset($_SERVER['SERVER_PORT']) && ( '443' == $_SERVER['SERVER_PORT'] ) ) {
4077		return true;
4078	}
4079	return false;
4080}
4081
4082/**
4083 * Whether to force SSL used for the Administration Screens.
4084 *
4085 * @since 2.6.0
4086 *
4087 * @staticvar bool $forced
4088 *
4089 * @param string|bool $force Optional. Whether to force SSL in admin screens. Default null.
4090 * @return bool True if forced, false if not forced.
4091 */
4092function force_ssl_admin( $force = null ) {
4093	static $forced = false;
4094
4095	if ( !is_null( $force ) ) {
4096		$old_forced = $forced;
4097		$forced = $force;
4098		return $old_forced;
4099	}
4100
4101	return $forced;
4102}
4103
4104/**
4105 * Guess the URL for the site.
4106 *
4107 * Will remove wp-admin links to retrieve only return URLs not in the wp-admin
4108 * directory.
4109 *
4110 * @since 2.6.0
4111 *
4112 * @return string The guessed URL.
4113 */
4114function wp_guess_url() {
4115	if ( defined('WP_SITEURL') && '' != WP_SITEURL ) {
4116		$url = WP_SITEURL;
4117	} else {
4118		$abspath_fix = str_replace( '\\', '/', ABSPATH );
4119		$script_filename_dir = dirname( $_SERVER['SCRIPT_FILENAME'] );
4120
4121		// The request is for the admin
4122		if ( strpos( $_SERVER['REQUEST_URI'], 'wp-admin' ) !== false || strpos( $_SERVER['REQUEST_URI'], 'wp-login.php' ) !== false ) {
4123			$path = preg_replace( '#/(wp-admin/.*|wp-login.php)#i', '', $_SERVER['REQUEST_URI'] );
4124
4125		// The request is for a file in ABSPATH
4126		} elseif ( $script_filename_dir . '/' == $abspath_fix ) {
4127			// Strip off any file/query params in the path
4128			$path = preg_replace( '#/[^/]*$#i', '', $_SERVER['PHP_SELF'] );
4129
4130		} else {
4131			if ( false !== strpos( $_SERVER['SCRIPT_FILENAME'], $abspath_fix ) ) {
4132				// Request is hitting a file inside ABSPATH
4133				$directory = str_replace( ABSPATH, '', $script_filename_dir );
4134				// Strip off the sub directory, and any file/query params
4135				$path = preg_replace( '#/' . preg_quote( $directory, '#' ) . '/[^/]*$#i', '' , $_SERVER['REQUEST_URI'] );
4136			} elseif ( false !== strpos( $abspath_fix, $script_filename_dir ) ) {
4137				// Request is hitting a file above ABSPATH
4138				$subdirectory = substr( $abspath_fix, strpos( $abspath_fix, $script_filename_dir ) + strlen( $script_filename_dir ) );
4139				// Strip off any file/query params from the path, appending the sub directory to the install
4140				$path = preg_replace( '#/[^/]*$#i', '' , $_SERVER['REQUEST_URI'] ) . $subdirectory;
4141			} else {
4142				$path = $_SERVER['REQUEST_URI'];
4143			}
4144		}
4145
4146		$schema = is_ssl() ? 'https://' : 'http://'; // set_url_scheme() is not defined yet
4147		$url = $schema . $_SERVER['HTTP_HOST'] . $path;
4148	}
4149
4150	return rtrim($url, '/');
4151}
4152
4153/**
4154 * Temporarily suspend cache additions.
4155 *
4156 * Stops more data being added to the cache, but still allows cache retrieval.
4157 * This is useful for actions, such as imports, when a lot of data would otherwise
4158 * be almost uselessly added to the cache.
4159 *
4160 * Suspension lasts for a single page load at most. Remember to call this
4161 * function again if you wish to re-enable cache adds earlier.
4162 *
4163 * @since 3.3.0
4164 *
4165 * @staticvar bool $_suspend
4166 *
4167 * @param bool $suspend Optional. Suspends additions if true, re-enables them if false.
4168 * @return bool The current suspend setting
4169 */
4170function wp_suspend_cache_addition( $suspend = null ) {
4171	static $_suspend = false;
4172
4173	if ( is_bool( $suspend ) )
4174		$_suspend = $suspend;
4175
4176	return $_suspend;
4177}
4178
4179/**
4180 * Suspend cache invalidation.
4181 *
4182 * Turns cache invalidation on and off. Useful during imports where you don't wont to do
4183 * invalidations every time a post is inserted. Callers must be sure that what they are
4184 * doing won't lead to an inconsistent cache when invalidation is suspended.
4185 *
4186 * @since 2.7.0
4187 *
4188 * @global bool $_wp_suspend_cache_invalidation
4189 *
4190 * @param bool $suspend Optional. Whether to suspend or enable cache invalidation. Default true.
4191 * @return bool The current suspend setting.
4192 */
4193function wp_suspend_cache_invalidation( $suspend = true ) {
4194	global $_wp_suspend_cache_invalidation;
4195
4196	$current_suspend = $_wp_suspend_cache_invalidation;
4197	$_wp_suspend_cache_invalidation = $suspend;
4198	return $current_suspend;
4199}
4200
4201/**
4202 * Determine whether a site is the main site of the current network.
4203 *
4204 * @since 3.0.0
4205 *
4206 * @global object $current_site
4207 *
4208 * @param int $site_id Optional. Site ID to test. Defaults to current site.
4209 *                     Defaults to current site.
4210 * @return bool True if $site_id is the main site of the network, or if not
4211 *              running Multisite.
4212 */
4213function is_main_site( $site_id = null ) {
4214	// This is the current network's information; 'site' is old terminology.
4215	global $current_site;
4216
4217	if ( ! is_multisite() )
4218		return true;
4219
4220	if ( ! $site_id )
4221		$site_id = get_current_blog_id();
4222
4223	return (int) $site_id === (int) $current_site->blog_id;
4224}
4225
4226/**
4227 * Determine whether a network is the main network of the Multisite install.
4228 *
4229 * @since 3.7.0
4230 *
4231 * @param int $network_id Optional. Network ID to test. Defaults to current network.
4232 * @return bool True if $network_id is the main network, or if not running Multisite.
4233 */
4234function is_main_network( $network_id = null ) {
4235	if ( ! is_multisite() ) {
4236		return true;
4237	}
4238
4239	$current_network_id = (int) get_current_site()->id;
4240
4241	if ( null === $network_id ) {
4242		$network_id = $current_network_id;
4243	}
4244
4245	$network_id = (int) $network_id;
4246
4247	return ( $network_id === get_main_network_id() );
4248}
4249
4250/**
4251 * Get the main network ID.
4252 *
4253 * @since 4.3.0
4254 *
4255 * @global wpdb $wpdb WordPress database abstraction object.
4256 *
4257 * @return int The ID of the main network.
4258 */
4259function get_main_network_id() {
4260	global $wpdb;
4261
4262	if ( ! is_multisite() ) {
4263		return 1;
4264	}
4265
4266	if ( defined( 'PRIMARY_NETWORK_ID' ) ) {
4267		$main_network_id = PRIMARY_NETWORK_ID;
4268	} elseif ( 1 === (int) get_current_site()->id ) {
4269		// If the current network has an ID of 1, assume it is the main network.
4270		$main_network_id = 1;
4271	} else {
4272		$main_network_id = wp_cache_get( 'primary_network_id', 'site-options' );
4273
4274		if ( false === $main_network_id ) {
4275			$main_network_id = (int) $wpdb->get_var( "SELECT id FROM {$wpdb->site} ORDER BY id LIMIT 1" );
4276			wp_cache_add( 'primary_network_id', $main_network_id, 'site-options' );
4277		}
4278	}
4279
4280	/**
4281	 * Filter the main network ID.
4282	 *
4283	 * @since 4.3.0
4284	 *
4285	 * @param int $main_network_id The ID of the main network.
4286	 */
4287	return (int) apply_filters( 'get_main_network_id', $main_network_id );
4288}
4289
4290/**
4291 * Determine whether global terms are enabled.
4292 *
4293 * @since 3.0.0
4294 *
4295 * @staticvar bool $global_terms
4296 *
4297 * @return bool True if multisite and global terms enabled.
4298 */
4299function global_terms_enabled() {
4300	if ( ! is_multisite() )
4301		return false;
4302
4303	static $global_terms = null;
4304	if ( is_null( $global_terms ) ) {
4305
4306		/**
4307		 * Filter whether global terms are enabled.
4308		 *
4309		 * Passing a non-null value to the filter will effectively short-circuit the function,
4310		 * returning the value of the 'global_terms_enabled' site option instead.
4311		 *
4312		 * @since 3.0.0
4313		 *
4314		 * @param null $enabled Whether global terms are enabled.
4315		 */
4316		$filter = apply_filters( 'global_terms_enabled', null );
4317		if ( ! is_null( $filter ) )
4318			$global_terms = (bool) $filter;
4319		else
4320			$global_terms = (bool) get_site_option( 'global_terms_enabled', false );
4321	}
4322	return $global_terms;
4323}
4324
4325/**
4326 * gmt_offset modification for smart timezone handling.
4327 *
4328 * Overrides the gmt_offset option if we have a timezone_string available.
4329 *
4330 * @since 2.8.0
4331 *
4332 * @return float|false Timezone GMT offset, false otherwise.
4333 */
4334function wp_timezone_override_offset() {
4335	if ( !$timezone_string = get_option( 'timezone_string' ) ) {
4336		return false;
4337	}
4338
4339	$timezone_object = timezone_open( $timezone_string );
4340	$datetime_object = date_create();
4341	if ( false === $timezone_object || false === $datetime_object ) {
4342		return false;
4343	}
4344	return round( timezone_offset_get( $timezone_object, $datetime_object ) / HOUR_IN_SECONDS, 2 );
4345}
4346
4347/**
4348 * Sort-helper for timezones.
4349 *
4350 * @since 2.9.0
4351 * @access private
4352 *
4353 * @param array $a
4354 * @param array $b
4355 * @return int
4356 */
4357function _wp_timezone_choice_usort_callback( $a, $b ) {
4358	// Don't use translated versions of Etc
4359	if ( 'Etc' === $a['continent'] && 'Etc' === $b['continent'] ) {
4360		// Make the order of these more like the old dropdown
4361		if ( 'GMT+' === substr( $a['city'], 0, 4 ) && 'GMT+' === substr( $b['city'], 0, 4 ) ) {
4362			return -1 * ( strnatcasecmp( $a['city'], $b['city'] ) );
4363		}
4364		if ( 'UTC' === $a['city'] ) {
4365			if ( 'GMT+' === substr( $b['city'], 0, 4 ) ) {
4366				return 1;
4367			}
4368			return -1;
4369		}
4370		if ( 'UTC' === $b['city'] ) {
4371			if ( 'GMT+' === substr( $a['city'], 0, 4 ) ) {
4372				return -1;
4373			}
4374			return 1;
4375		}
4376		return strnatcasecmp( $a['city'], $b['city'] );
4377	}
4378	if ( $a['t_continent'] == $b['t_continent'] ) {
4379		if ( $a['t_city'] == $b['t_city'] ) {
4380			return strnatcasecmp( $a['t_subcity'], $b['t_subcity'] );
4381		}
4382		return strnatcasecmp( $a['t_city'], $b['t_city'] );
4383	} else {
4384		// Force Etc to the bottom of the list
4385		if ( 'Etc' === $a['continent'] ) {
4386			return 1;
4387		}
4388		if ( 'Etc' === $b['continent'] ) {
4389			return -1;
4390		}
4391		return strnatcasecmp( $a['t_continent'], $b['t_continent'] );
4392	}
4393}
4394
4395/**
4396 * Gives a nicely-formatted list of timezone strings.
4397 *
4398 * @since 2.9.0
4399 *
4400 * @staticvar bool $mo_loaded
4401 *
4402 * @param string $selected_zone Selected timezone.
4403 * @return string
4404 */
4405function wp_timezone_choice( $selected_zone ) {
4406	static $mo_loaded = false;
4407
4408	$continents = array( 'Africa', 'America', 'Antarctica', 'Arctic', 'Asia', 'Atlantic', 'Australia', 'Europe', 'Indian', 'Pacific');
4409
4410	// Load translations for continents and cities
4411	if ( !$mo_loaded ) {
4412		$locale = get_locale();
4413		$mofile = WP_LANG_DIR . '/continents-cities-' . $locale . '.mo';
4414		load_textdomain( 'continents-cities', $mofile );
4415		$mo_loaded = true;
4416	}
4417
4418	$zonen = array();
4419	foreach ( timezone_identifiers_list() as $zone ) {
4420		$zone = explode( '/', $zone );
4421		if ( !in_array( $zone[0], $continents ) ) {
4422			continue;
4423		}
4424
4425		// This determines what gets set and translated - we don't translate Etc/* strings here, they are done later
4426		$exists = array(
4427			0 => ( isset( $zone[0] ) && $zone[0] ),
4428			1 => ( isset( $zone[1] ) && $zone[1] ),
4429			2 => ( isset( $zone[2] ) && $zone[2] ),
4430		);
4431		$exists[3] = ( $exists[0] && 'Etc' !== $zone[0] );
4432		$exists[4] = ( $exists[1] && $exists[3] );
4433		$exists[5] = ( $exists[2] && $exists[3] );
4434
4435		$zonen[] = array(
4436			'continent'   => ( $exists[0] ? $zone[0] : '' ),
4437			'city'        => ( $exists[1] ? $zone[1] : '' ),
4438			'subcity'     => ( $exists[2] ? $zone[2] : '' ),
4439			't_continent' => ( $exists[3] ? translate( str_replace( '_', ' ', $zone[0] ), 'continents-cities' ) : '' ),
4440			't_city'      => ( $exists[4] ? translate( str_replace( '_', ' ', $zone[1] ), 'continents-cities' ) : '' ),
4441			't_subcity'   => ( $exists[5] ? translate( str_replace( '_', ' ', $zone[2] ), 'continents-cities' ) : '' )
4442		);
4443	}
4444	usort( $zonen, '_wp_timezone_choice_usort_callback' );
4445
4446	$structure = array();
4447
4448	if ( empty( $selected_zone ) ) {
4449		$structure[] = '<option selected="selected" value="">' . __( 'Select a city' ) . '</option>';
4450	}
4451
4452	foreach ( $zonen as $key => $zone ) {
4453		// Build value in an array to join later
4454		$value = array( $zone['continent'] );
4455
4456		if ( empty( $zone['city'] ) ) {
4457			// It's at the continent level (generally won't happen)
4458			$display = $zone['t_continent'];
4459		} else {
4460			// It's inside a continent group
4461
4462			// Continent optgroup
4463			if ( !isset( $zonen[$key - 1] ) || $zonen[$key - 1]['continent'] !== $zone['continent'] ) {
4464				$label = $zone['t_continent'];
4465				$structure[] = '<optgroup label="'. esc_attr( $label ) .'">';
4466			}
4467
4468			// Add the city to the value
4469			$value[] = $zone['city'];
4470
4471			$display = $zone['t_city'];
4472			if ( !empty( $zone['subcity'] ) ) {
4473				// Add the subcity to the value
4474				$value[] = $zone['subcity'];
4475				$display .= ' - ' . $zone['t_subcity'];
4476			}
4477		}
4478
4479		// Build the value
4480		$value = join( '/', $value );
4481		$selected = '';
4482		if ( $value === $selected_zone ) {
4483			$selected = 'selected="selected" ';
4484		}
4485		$structure[] = '<option ' . $selected . 'value="' . esc_attr( $value ) . '">' . esc_html( $display ) . "</option>";
4486
4487		// Close continent optgroup
4488		if ( !empty( $zone['city'] ) && ( !isset($zonen[$key + 1]) || (isset( $zonen[$key + 1] ) && $zonen[$key + 1]['continent'] !== $zone['continent']) ) ) {
4489			$structure[] = '</optgroup>';
4490		}
4491	}
4492
4493	// Do UTC
4494	$structure[] = '<optgroup label="'. esc_attr__( 'UTC' ) .'">';
4495	$selected = '';
4496	if ( 'UTC' === $selected_zone )
4497		$selected = 'selected="selected" ';
4498	$structure[] = '<option ' . $selected . 'value="' . esc_attr( 'UTC' ) . '">' . __('UTC') . '</option>';
4499	$structure[] = '</optgroup>';
4500
4501	// Do manual UTC offsets
4502	$structure[] = '<optgroup label="'. esc_attr__( 'Manual Offsets' ) .'">';
4503	$offset_range = array (-12, -11.5, -11, -10.5, -10, -9.5, -9, -8.5, -8, -7.5, -7, -6.5, -6, -5.5, -5, -4.5, -4, -3.5, -3, -2.5, -2, -1.5, -1, -0.5,
4504		0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 5.75, 6, 6.5, 7, 7.5, 8, 8.5, 8.75, 9, 9.5, 10, 10.5, 11, 11.5, 12, 12.75, 13, 13.75, 14);
4505	foreach ( $offset_range as $offset ) {
4506		if ( 0 <= $offset )
4507			$offset_name = '+' . $offset;
4508		else
4509			$offset_name = (string) $offset;
4510
4511		$offset_value = $offset_name;
4512		$offset_name = str_replace(array('.25','.5','.75'), array(':15',':30',':45'), $offset_name);
4513		$offset_name = 'UTC' . $offset_name;
4514		$offset_value = 'UTC' . $offset_value;
4515		$selected = '';
4516		if ( $offset_value === $selected_zone )
4517			$selected = 'selected="selected" ';
4518		$structure[] = '<option ' . $selected . 'value="' . esc_attr( $offset_value ) . '">' . esc_html( $offset_name ) . "</option>";
4519
4520	}
4521	$structure[] = '</optgroup>';
4522
4523	return join( "\n", $structure );
4524}
4525
4526/**
4527 * Strip close comment and close php tags from file headers used by WP.
4528 *
4529 * @since 2.8.0
4530 * @access private
4531 *
4532 * @see https://core.trac.wordpress.org/ticket/8497
4533 *
4534 * @param string $str Header comment to clean up.
4535 * @return string
4536 */
4537function _cleanup_header_comment( $str ) {
4538	return trim(preg_replace("/\s*(?:\*\/|\?>).*/", '', $str));
4539}
4540
4541/**
4542 * Permanently delete comments or posts of any type that have held a status
4543 * of 'trash' for the number of days defined in EMPTY_TRASH_DAYS.
4544 *
4545 * The default value of `EMPTY_TRASH_DAYS` is 30 (days).
4546 *
4547 * @since 2.9.0
4548 *
4549 * @global wpdb $wpdb WordPress database abstraction object.
4550 */
4551function wp_scheduled_delete() {
4552	global $wpdb;
4553
4554	$delete_timestamp = time() - ( DAY_IN_SECONDS * EMPTY_TRASH_DAYS );
4555
4556	$posts_to_delete = $wpdb->get_results($wpdb->prepare("SELECT post_id FROM $wpdb->postmeta WHERE meta_key = '_wp_trash_meta_time' AND meta_value < '%d'", $delete_timestamp), ARRAY_A);
4557
4558	foreach ( (array) $posts_to_delete as $post ) {
4559		$post_id = (int) $post['post_id'];
4560		if ( !$post_id )
4561			continue;
4562
4563		$del_post = get_post($post_id);
4564
4565		if ( !$del_post || 'trash' != $del_post->post_status ) {
4566			delete_post_meta($post_id, '_wp_trash_meta_status');
4567			delete_post_meta($post_id, '_wp_trash_meta_time');
4568		} else {
4569			wp_delete_post($post_id);
4570		}
4571	}
4572
4573	$comments_to_delete = $wpdb->get_results($wpdb->prepare("SELECT comment_id FROM $wpdb->commentmeta WHERE meta_key = '_wp_trash_meta_time' AND meta_value < '%d'", $delete_timestamp), ARRAY_A);
4574
4575	foreach ( (array) $comments_to_delete as $comment ) {
4576		$comment_id = (int) $comment['comment_id'];
4577		if ( !$comment_id )
4578			continue;
4579
4580		$del_comment = get_comment($comment_id);
4581
4582		if ( !$del_comment || 'trash' != $del_comment->comment_approved ) {
4583			delete_comment_meta($comment_id, '_wp_trash_meta_time');
4584			delete_comment_meta($comment_id, '_wp_trash_meta_status');
4585		} else {
4586			wp_delete_comment( $del_comment );
4587		}
4588	}
4589}
4590
4591/**
4592 * Retrieve metadata from a file.
4593 *
4594 * Searches for metadata in the first 8kiB of a file, such as a plugin or theme.
4595 * Each piece of metadata must be on its own line. Fields can not span multiple
4596 * lines, the value will get cut at the end of the first line.
4597 *
4598 * If the file data is not within that first 8kiB, then the author should correct
4599 * their plugin file and move the data headers to the top.
4600 *
4601 * @link https://codex.wordpress.org/File_Header
4602 *
4603 * @since 2.9.0
4604 *
4605 * @param string $file            Path to the file.
4606 * @param array  $default_headers List of headers, in the format array('HeaderKey' => 'Header Name').
4607 * @param string $context         Optional. If specified adds filter hook "extra_{$context}_headers".
4608 *                                Default empty.
4609 * @return array Array of file headers in `HeaderKey => Header Value` format.
4610 */
4611function get_file_data( $file, $default_headers, $context = '' ) {
4612	// We don't need to write to the file, so just open for reading.
4613	$fp = fopen( $file, 'r' );
4614
4615	// Pull only the first 8kiB of the file in.
4616	$file_data = fread( $fp, 8192 );
4617
4618	// PHP will close file handle, but we are good citizens.
4619	fclose( $fp );
4620
4621	// Make sure we catch CR-only line endings.
4622	$file_data = str_replace( "\r", "\n", $file_data );
4623
4624	/**
4625	 * Filter extra file headers by context.
4626	 *
4627	 * The dynamic portion of the hook name, `$context`, refers to
4628	 * the context where extra headers might be loaded.
4629	 *
4630	 * @since 2.9.0
4631	 *
4632	 * @param array $extra_context_headers Empty array by default.
4633	 */
4634	if ( $context && $extra_headers = apply_filters( "extra_{$context}_headers", array() ) ) {
4635		$extra_headers = array_combine( $extra_headers, $extra_headers ); // keys equal values
4636		$all_headers = array_merge( $extra_headers, (array) $default_headers );
4637	} else {
4638		$all_headers = $default_headers;
4639	}
4640
4641	foreach ( $all_headers as $field => $regex ) {
4642		if ( preg_match( '/^[ \t\/*#@]*' . preg_quote( $regex, '/' ) . ':(.*)$/mi', $file_data, $match ) && $match[1] )
4643			$all_headers[ $field ] = _cleanup_header_comment( $match[1] );
4644		else
4645			$all_headers[ $field ] = '';
4646	}
4647
4648	return $all_headers;
4649}
4650
4651/**
4652 * Returns true.
4653 *
4654 * Useful for returning true to filters easily.
4655 *
4656 * @since 3.0.0
4657 *
4658 * @see __return_false()
4659 *
4660 * @return true True.
4661 */
4662function __return_true() {
4663	return true;
4664}
4665
4666/**
4667 * Returns false.
4668 *
4669 * Useful for returning false to filters easily.
4670 *
4671 * @since 3.0.0
4672 *
4673 * @see __return_true()
4674 *
4675 * @return false False.
4676 */
4677function __return_false() {
4678	return false;
4679}
4680
4681/**
4682 * Returns 0.
4683 *
4684 * Useful for returning 0 to filters easily.
4685 *
4686 * @since 3.0.0
4687 *
4688 * @return int 0.
4689 */
4690function __return_zero() {
4691	return 0;
4692}
4693
4694/**
4695 * Returns an empty array.
4696 *
4697 * Useful for returning an empty array to filters easily.
4698 *
4699 * @since 3.0.0
4700 *
4701 * @return array Empty array.
4702 */
4703function __return_empty_array() {
4704	return array();
4705}
4706
4707/**
4708 * Returns null.
4709 *
4710 * Useful for returning null to filters easily.
4711 *
4712 * @since 3.4.0
4713 *
4714 * @return null Null value.
4715 */
4716function __return_null() {
4717	return null;
4718}
4719
4720/**
4721 * Returns an empty string.
4722 *
4723 * Useful for returning an empty string to filters easily.
4724 *
4725 * @since 3.7.0
4726 *
4727 * @see __return_null()
4728 *
4729 * @return string Empty string.
4730 */
4731function __return_empty_string() {
4732	return '';
4733}
4734
4735/**
4736 * Send a HTTP header to disable content type sniffing in browsers which support it.
4737 *
4738 * @since 3.0.0
4739 *
4740 * @see http://blogs.msdn.com/ie/archive/2008/07/02/ie8-security-part-v-comprehensive-protection.aspx
4741 * @see http://src.chromium.org/viewvc/chrome?view=rev&revision=6985
4742 */
4743function send_nosniff_header() {
4744	@header( 'X-Content-Type-Options: nosniff' );
4745}
4746
4747/**
4748 * Return a MySQL expression for selecting the week number based on the start_of_week option.
4749 *
4750 * @ignore
4751 * @since 3.0.0
4752 *
4753 * @param string $column Database column.
4754 * @return string SQL clause.
4755 */
4756function _wp_mysql_week( $column ) {
4757	switch ( $start_of_week = (int) get_option( 'start_of_week' ) ) {
4758	case 1 :
4759		return "WEEK( $column, 1 )";
4760	case 2 :
4761	case 3 :
4762	case 4 :
4763	case 5 :
4764	case 6 :
4765		return "WEEK( DATE_SUB( $column, INTERVAL $start_of_week DAY ), 0 )";
4766	case 0 :
4767	default :
4768		return "WEEK( $column, 0 )";
4769	}
4770}
4771
4772/**
4773 * Find hierarchy loops using a callback function that maps object IDs to parent IDs.
4774 *
4775 * @since 3.1.0
4776 * @access private
4777 *
4778 * @param callable $callback      Function that accepts ( ID, $callback_args ) and outputs parent_ID.
4779 * @param int      $start         The ID to start the loop check at.
4780 * @param int      $start_parent  The parent_ID of $start to use instead of calling $callback( $start ).
4781 *                                Use null to always use $callback
4782 * @param array    $callback_args Optional. Additional arguments to send to $callback.
4783 * @return array IDs of all members of loop.
4784 */
4785function wp_find_hierarchy_loop( $callback, $start, $start_parent, $callback_args = array() ) {
4786	$override = is_null( $start_parent ) ? array() : array( $start => $start_parent );
4787
4788	if ( !$arbitrary_loop_member = wp_find_hierarchy_loop_tortoise_hare( $callback, $start, $override, $callback_args ) )
4789		return array();
4790
4791	return wp_find_hierarchy_loop_tortoise_hare( $callback, $arbitrary_loop_member, $override, $callback_args, true );
4792}
4793
4794/**
4795 * Use the "The Tortoise and the Hare" algorithm to detect loops.
4796 *
4797 * For every step of the algorithm, the hare takes two steps and the tortoise one.
4798 * If the hare ever laps the tortoise, there must be a loop.
4799 *
4800 * @since 3.1.0
4801 * @access private
4802 *
4803 * @param callable $callback      Function that accepts ( ID, callback_arg, ... ) and outputs parent_ID.
4804 * @param int      $start         The ID to start the loop check at.
4805 * @param array    $override      Optional. An array of ( ID => parent_ID, ... ) to use instead of $callback.
4806 *                                Default empty array.
4807 * @param array    $callback_args Optional. Additional arguments to send to $callback. Default empty array.
4808 * @param bool     $_return_loop  Optional. Return loop members or just detect presence of loop? Only set
4809 *                                to true if you already know the given $start is part of a loop (otherwise
4810 *                                the returned array might include branches). Default false.
4811 * @return mixed Scalar ID of some arbitrary member of the loop, or array of IDs of all members of loop if
4812 *               $_return_loop
4813 */
4814function wp_find_hierarchy_loop_tortoise_hare( $callback, $start, $override = array(), $callback_args = array(), $_return_loop = false ) {
4815	$tortoise = $hare = $evanescent_hare = $start;
4816	$return = array();
4817
4818	// Set evanescent_hare to one past hare
4819	// Increment hare two steps
4820	while (
4821		$tortoise
4822	&&
4823		( $evanescent_hare = isset( $override[$hare] ) ? $override[$hare] : call_user_func_array( $callback, array_merge( array( $hare ), $callback_args ) ) )
4824	&&
4825		( $hare = isset( $override[$evanescent_hare] ) ? $override[$evanescent_hare] : call_user_func_array( $callback, array_merge( array( $evanescent_hare ), $callback_args ) ) )
4826	) {
4827		if ( $_return_loop )
4828			$return[$tortoise] = $return[$evanescent_hare] = $return[$hare] = true;
4829
4830		// tortoise got lapped - must be a loop
4831		if ( $tortoise == $evanescent_hare || $tortoise == $hare )
4832			return $_return_loop ? $return : $tortoise;
4833
4834		// Increment tortoise by one step
4835		$tortoise = isset( $override[$tortoise] ) ? $override[$tortoise] : call_user_func_array( $callback, array_merge( array( $tortoise ), $callback_args ) );
4836	}
4837
4838	return false;
4839}
4840
4841/**
4842 * Send a HTTP header to limit rendering of pages to same origin iframes.
4843 *
4844 * @since 3.1.3
4845 *
4846 * @see https://developer.mozilla.org/en/the_x-frame-options_response_header
4847 */
4848function send_frame_options_header() {
4849	@header( 'X-Frame-Options: SAMEORIGIN' );
4850}
4851
4852/**
4853 * Retrieve a list of protocols to allow in HTML attributes.
4854 *
4855 * @since 3.3.0
4856 * @since 4.3.0 Added 'webcal' to the protocols array.
4857 *
4858 * @see wp_kses()
4859 * @see esc_url()
4860 *
4861 * @staticvar array $protocols
4862 *
4863 * @return array Array of allowed protocols. Defaults to an array containing 'http', 'https',
4864 *               'ftp', 'ftps', 'mailto', 'news', 'irc', 'gopher', 'nntp', 'feed', 'telnet',
4865 *               'mms', 'rtsp', 'svn', 'tel', 'fax', 'xmpp', and 'webcal'.
4866 */
4867function wp_allowed_protocols() {
4868	static $protocols = array();
4869
4870	if ( empty( $protocols ) ) {
4871		$protocols = array( 'http', 'https', 'ftp', 'ftps', 'mailto', 'news', 'irc', 'gopher', 'nntp', 'feed', 'telnet', 'mms', 'rtsp', 'svn', 'tel', 'fax', 'xmpp', 'webcal' );
4872
4873		/**
4874		 * Filter the list of protocols allowed in HTML attributes.
4875		 *
4876		 * @since 3.0.0
4877		 *
4878		 * @param array $protocols Array of allowed protocols e.g. 'http', 'ftp', 'tel', and more.
4879		 */
4880		$protocols = apply_filters( 'kses_allowed_protocols', $protocols );
4881	}
4882
4883	return $protocols;
4884}
4885
4886/**
4887 * Return a comma-separated string of functions that have been called to get
4888 * to the current point in code.
4889 *
4890 * @since 3.4.0
4891 *
4892 * @see https://core.trac.wordpress.org/ticket/19589
4893 *
4894 * @param string $ignore_class Optional. A class to ignore all function calls within - useful
4895 *                             when you want to just give info about the callee. Default null.
4896 * @param int    $skip_frames  Optional. A number of stack frames to skip - useful for unwinding
4897 *                             back to the source of the issue. Default 0.
4898 * @param bool   $pretty       Optional. Whether or not you want a comma separated string or raw
4899 *                             array returned. Default true.
4900 * @return string|array Either a string containing a reversed comma separated trace or an array
4901 *                      of individual calls.
4902 */
4903function wp_debug_backtrace_summary( $ignore_class = null, $skip_frames = 0, $pretty = true ) {
4904	if ( version_compare( PHP_VERSION, '5.2.5', '>=' ) )
4905		$trace = debug_backtrace( false );
4906	else
4907		$trace = debug_backtrace();
4908
4909	$caller = array();
4910	$check_class = ! is_null( $ignore_class );
4911	$skip_frames++; // skip this function
4912
4913	foreach ( $trace as $call ) {
4914		if ( $skip_frames > 0 ) {
4915			$skip_frames--;
4916		} elseif ( isset( $call['class'] ) ) {
4917			if ( $check_class && $ignore_class == $call['class'] )
4918				continue; // Filter out calls
4919
4920			$caller[] = "{$call['class']}{$call['type']}{$call['function']}";
4921		} else {
4922			if ( in_array( $call['function'], array( 'do_action', 'apply_filters' ) ) ) {
4923				$caller[] = "{$call['function']}('{$call['args'][0]}')";
4924			} elseif ( in_array( $call['function'], array( 'include', 'include_once', 'require', 'require_once' ) ) ) {
4925				$caller[] = $call['function'] . "('" . str_replace( array( WP_CONTENT_DIR, ABSPATH ) , '', $call['args'][0] ) . "')";
4926			} else {
4927				$caller[] = $call['function'];
4928			}
4929		}
4930	}
4931	if ( $pretty )
4932		return join( ', ', array_reverse( $caller ) );
4933	else
4934		return $caller;
4935}
4936
4937/**
4938 * Retrieve ids that are not already present in the cache.
4939 *
4940 * @since 3.4.0
4941 * @access private
4942 *
4943 * @param array  $object_ids ID list.
4944 * @param string $cache_key  The cache bucket to check against.
4945 *
4946 * @return array List of ids not present in the cache.
4947 */
4948function _get_non_cached_ids( $object_ids, $cache_key ) {
4949	$clean = array();
4950	foreach ( $object_ids as $id ) {
4951		$id = (int) $id;
4952		if ( !wp_cache_get( $id, $cache_key ) ) {
4953			$clean[] = $id;
4954		}
4955	}
4956
4957	return $clean;
4958}
4959
4960/**
4961 * Test if the current device has the capability to upload files.
4962 *
4963 * @since 3.4.0
4964 * @access private
4965 *
4966 * @return bool Whether the device is able to upload files.
4967 */
4968function _device_can_upload() {
4969	if ( ! wp_is_mobile() )
4970		return true;
4971
4972	$ua = $_SERVER['HTTP_USER_AGENT'];
4973
4974	if ( strpos($ua, 'iPhone') !== false
4975		|| strpos($ua, 'iPad') !== false
4976		|| strpos($ua, 'iPod') !== false ) {
4977			return preg_match( '#OS ([\d_]+) like Mac OS X#', $ua, $version ) && version_compare( $version[1], '6', '>=' );
4978	}
4979
4980	return true;
4981}
4982
4983/**
4984 * Test if a given path is a stream URL
4985 *
4986 * @param string $path The resource path or URL.
4987 * @return bool True if the path is a stream URL.
4988 */
4989function wp_is_stream( $path ) {
4990	$wrappers = stream_get_wrappers();
4991	$wrappers_re = '(' . join('|', $wrappers) . ')';
4992
4993	return preg_match( "!^$wrappers_re://!", $path ) === 1;
4994}
4995
4996/**
4997 * Test if the supplied date is valid for the Gregorian calendar.
4998 *
4999 * @since 3.5.0
5000 *
5001 * @see checkdate()
5002 *
5003 * @param  int    $month       Month number.
5004 * @param  int    $day         Day number.
5005 * @param  int    $year        Year number.
5006 * @param  string $source_date The date to filter.
5007 * @return bool True if valid date, false if not valid date.
5008 */
5009function wp_checkdate( $month, $day, $year, $source_date ) {
5010	/**
5011	 * Filter whether the given date is valid for the Gregorian calendar.
5012	 *
5013	 * @since 3.5.0
5014	 *
5015	 * @param bool   $checkdate   Whether the given date is valid.
5016	 * @param string $source_date Date to check.
5017	 */
5018	return apply_filters( 'wp_checkdate', checkdate( $month, $day, $year ), $source_date );
5019}
5020
5021/**
5022 * Load the auth check for monitoring whether the user is still logged in.
5023 *
5024 * Can be disabled with remove_action( 'admin_enqueue_scripts', 'wp_auth_check_load' );
5025 *
5026 * This is disabled for certain screens where a login screen could cause an
5027 * inconvenient interruption. A filter called wp_auth_check_load can be used
5028 * for fine-grained control.
5029 *
5030 * @since 3.6.0
5031 */
5032function wp_auth_check_load() {
5033	if ( ! is_admin() && ! is_user_logged_in() )
5034		return;
5035
5036	if ( defined( 'IFRAME_REQUEST' ) )
5037		return;
5038
5039	$screen = get_current_screen();
5040	$hidden = array( 'update', 'update-network', 'update-core', 'update-core-network', 'upgrade', 'upgrade-network', 'network' );
5041	$show = ! in_array( $screen->id, $hidden );
5042
5043	/**
5044	 * Filter whether to load the authentication check.
5045	 *
5046	 * Passing a falsey value to the filter will effectively short-circuit
5047	 * loading the authentication check.
5048	 *
5049	 * @since 3.6.0
5050	 *
5051	 * @param bool      $show   Whether to load the authentication check.
5052	 * @param WP_Screen $screen The current screen object.
5053	 */
5054	if ( apply_filters( 'wp_auth_check_load', $show, $screen ) ) {
5055		wp_enqueue_style( 'wp-auth-check' );
5056		wp_enqueue_script( 'wp-auth-check' );
5057
5058		add_action( 'admin_print_footer_scripts', 'wp_auth_check_html', 5 );
5059		add_action( 'wp_print_footer_scripts', 'wp_auth_check_html', 5 );
5060	}
5061}
5062
5063/**
5064 * Output the HTML that shows the wp-login dialog when the user is no longer logged in.
5065 *
5066 * @since 3.6.0
5067 */
5068function wp_auth_check_html() {
5069	$login_url = wp_login_url();
5070	$current_domain = ( is_ssl() ? 'https://' : 'http://' ) . $_SERVER['HTTP_HOST'];
5071	$same_domain = ( strpos( $login_url, $current_domain ) === 0 );
5072
5073	/**
5074	 * Filter whether the authentication check originated at the same domain.
5075	 *
5076	 * @since 3.6.0
5077	 *
5078	 * @param bool $same_domain Whether the authentication check originated at the same domain.
5079	 */
5080	$same_domain = apply_filters( 'wp_auth_check_same_domain', $same_domain );
5081	$wrap_class = $same_domain ? 'hidden' : 'hidden fallback';
5082
5083	?>
5084	<div id="wp-auth-check-wrap" class="<?php echo $wrap_class; ?>">
5085	<div id="wp-auth-check-bg"></div>
5086	<div id="wp-auth-check">
5087	<button type="button" class="wp-auth-check-close button-link"><span class="screen-reader-text"><?php _e( 'Close dialog' ); ?></span></button>
5088	<?php
5089
5090	if ( $same_domain ) {
5091		?>
5092		<div id="wp-auth-check-form" class="loading" data-src="<?php echo esc_url( add_query_arg( array( 'interim-login' => 1 ), $login_url ) ); ?>"></div>
5093		<?php
5094	}
5095
5096	?>
5097	<div class="wp-auth-fallback">
5098		<p><b class="wp-auth-fallback-expired" tabindex="0"><?php _e('Session expired'); ?></b></p>
5099		<p><a href="<?php echo esc_url( $login_url ); ?>" target="_blank"><?php _e('Please log in again.'); ?></a>
5100		<?php _e('The login page will open in a new window. After logging in you can close it and return to this page.'); ?></p>
5101	</div>
5102	</div>
5103	</div>
5104	<?php
5105}
5106
5107/**
5108 * Check whether a user is still logged in, for the heartbeat.
5109 *
5110 * Send a result that shows a log-in box if the user is no longer logged in,
5111 * or if their cookie is within the grace period.
5112 *
5113 * @since 3.6.0
5114 *
5115 * @global int $login_grace_period
5116 *
5117 * @param array $response  The Heartbeat response.
5118 * @return array $response The Heartbeat response with 'wp-auth-check' value set.
5119 */
5120function wp_auth_check( $response ) {
5121	$response['wp-auth-check'] = is_user_logged_in() && empty( $GLOBALS['login_grace_period'] );
5122	return $response;
5123}
5124
5125/**
5126 * Return RegEx body to liberally match an opening HTML tag.
5127 *
5128 * Matches an opening HTML tag that:
5129 * 1. Is self-closing or
5130 * 2. Has no body but has a closing tag of the same name or
5131 * 3. Contains a body and a closing tag of the same name
5132 *
5133 * Note: this RegEx does not balance inner tags and does not attempt
5134 * to produce valid HTML
5135 *
5136 * @since 3.6.0
5137 *
5138 * @param string $tag An HTML tag name. Example: 'video'.
5139 * @return string Tag RegEx.
5140 */
5141function get_tag_regex( $tag ) {
5142	if ( empty( $tag ) )
5143		return;
5144	return sprintf( '<%1$s[^<]*(?:>[\s\S]*<\/%1$s>|\s*\/>)', tag_escape( $tag ) );
5145}
5146
5147/**
5148 * Retrieve a canonical form of the provided charset appropriate for passing to PHP
5149 * functions such as htmlspecialchars() and charset html attributes.
5150 *
5151 * @since 3.6.0
5152 * @access private
5153 *
5154 * @see https://core.trac.wordpress.org/ticket/23688
5155 *
5156 * @param string $charset A charset name.
5157 * @return string The canonical form of the charset.
5158 */
5159function _canonical_charset( $charset ) {
5160	if ( 'UTF-8' === $charset || 'utf-8' === $charset || 'utf8' === $charset ||
5161		'UTF8' === $charset )
5162		return 'UTF-8';
5163
5164	if ( 'ISO-8859-1' === $charset || 'iso-8859-1' === $charset ||
5165		'iso8859-1' === $charset || 'ISO8859-1' === $charset )
5166		return 'ISO-8859-1';
5167
5168	return $charset;
5169}
5170
5171/**
5172 * Set the mbstring internal encoding to a binary safe encoding when func_overload
5173 * is enabled.
5174 *
5175 * When mbstring.func_overload is in use for multi-byte encodings, the results from
5176 * strlen() and similar functions respect the utf8 characters, causing binary data
5177 * to return incorrect lengths.
5178 *
5179 * This function overrides the mbstring encoding to a binary-safe encoding, and
5180 * resets it to the users expected encoding afterwards through the
5181 * `reset_mbstring_encoding` function.
5182 *
5183 * It is safe to recursively call this function, however each
5184 * `mbstring_binary_safe_encoding()` call must be followed up with an equal number
5185 * of `reset_mbstring_encoding()` calls.
5186 *
5187 * @since 3.7.0
5188 *
5189 * @see reset_mbstring_encoding()
5190 *
5191 * @staticvar array $encodings
5192 * @staticvar bool  $overloaded
5193 *
5194 * @param bool $reset Optional. Whether to reset the encoding back to a previously-set encoding.
5195 *                    Default false.
5196 */
5197function mbstring_binary_safe_encoding( $reset = false ) {
5198	static $encodings = array();
5199	static $overloaded = null;
5200
5201	if ( is_null( $overloaded ) )
5202		$overloaded = function_exists( 'mb_internal_encoding' ) && ( ini_get( 'mbstring.func_overload' ) & 2 );
5203
5204	if ( false === $overloaded )
5205		return;
5206
5207	if ( ! $reset ) {
5208		$encoding = mb_internal_encoding();
5209		array_push( $encodings, $encoding );
5210		mb_internal_encoding( 'ISO-8859-1' );
5211	}
5212
5213	if ( $reset && $encodings ) {
5214		$encoding = array_pop( $encodings );
5215		mb_internal_encoding( $encoding );
5216	}
5217}
5218
5219/**
5220 * Reset the mbstring internal encoding to a users previously set encoding.
5221 *
5222 * @see mbstring_binary_safe_encoding()
5223 *
5224 * @since 3.7.0
5225 */
5226function reset_mbstring_encoding() {
5227	mbstring_binary_safe_encoding( true );
5228}
5229
5230/**
5231 * Filter/validate a variable as a boolean.
5232 *
5233 * Alternative to `filter_var( $var, FILTER_VALIDATE_BOOLEAN )`.
5234 *
5235 * @since 4.0.0
5236 *
5237 * @param mixed $var Boolean value to validate.
5238 * @return bool Whether the value is validated.
5239 */
5240function wp_validate_boolean( $var ) {
5241	if ( is_bool( $var ) ) {
5242		return $var;
5243	}
5244
5245	if ( is_string( $var ) && 'false' === strtolower( $var ) ) {
5246		return false;
5247	}
5248
5249	return (bool) $var;
5250}
5251
5252/**
5253 * Delete a file
5254 *
5255 * @since 4.2.0
5256 *
5257 * @param string $file The path to the file to delete.
5258 */
5259function wp_delete_file( $file ) {
5260	/**
5261	 * Filter the path of the file to delete.
5262	 *
5263	 * @since 2.1.0
5264	 *
5265	 * @param string $medium Path to the file to delete.
5266	 */
5267	$delete = apply_filters( 'wp_delete_file', $file );
5268	if ( ! empty( $delete ) ) {
5269		@unlink( $delete );
5270	}
5271}
5272
5273/**
5274 * Outputs a small JS snippet on preview tabs/windows to remove `window.name` on unload.
5275 *
5276 * This prevents reusing the same tab for a preview when the user has navigated away.
5277 *
5278 * @since 4.3.0
5279 */
5280function wp_post_preview_js() {
5281	global $post;
5282
5283	if ( ! is_preview() || empty( $post ) ) {
5284		return;
5285	}
5286
5287	// Has to match the window name used in post_submit_meta_box()
5288	$name = 'wp-preview-' . (int) $post->ID;
5289
5290	?>
5291	<script>
5292	( function() {
5293		var query = document.location.search;
5294
5295		if ( query && query.indexOf( 'preview=true' ) !== -1 ) {
5296			window.name = '<?php echo $name; ?>';
5297		}
5298
5299		if ( window.addEventListener ) {
5300			window.addEventListener( 'unload', function() { window.name = ''; }, false );
5301		}
5302	}());
5303	</script>
5304	<?php
5305}
5306
5307/**
5308 * Parses and formats a MySQL datetime (Y-m-d H:i:s) for ISO8601/RFC3339.
5309 *
5310 * Explicitly strips timezones, as datetimes are not saved with any timezone
5311 * information. Including any information on the offset could be misleading.
5312 *
5313 * @since 4.4.0
5314 *
5315 * @param string $date_string Date string to parse and format.
5316 * @return string Date formatted for ISO8601/RFC3339.
5317 */
5318function mysql_to_rfc3339( $date_string ) {
5319	$formatted = mysql2date( 'c', $date_string, false );
5320
5321	// Strip timezone information
5322	return preg_replace( '/(?:Z|[+-]\d{2}(?::\d{2})?)$/', '', $formatted );
5323}