mtNGZTG7

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		$i = current_time( 'timestamp', $gmt );
95	}
96
97	/*
98	 * Store original value for language with untypical grammars.
99	 * See https://core.trac.wordpress.org/ticket/9396
100	 */
101	$req_format = $dateformatstring;
102
103	if ( ( !empty( $wp_locale->month ) ) && ( !empty( $wp_locale->weekday ) ) ) {
104		$datemonth = $wp_locale->get_month( date( 'm', $i ) );
105		$datemonth_abbrev = $wp_locale->get_month_abbrev( $datemonth );
106		$dateweekday = $wp_locale->get_weekday( date( 'w', $i ) );
107		$dateweekday_abbrev = $wp_locale->get_weekday_abbrev( $dateweekday );
108		$datemeridiem = $wp_locale->get_meridiem( date( 'a', $i ) );
109		$datemeridiem_capital = $wp_locale->get_meridiem( date( 'A', $i ) );
110		$dateformatstring = ' '.$dateformatstring;
111		$dateformatstring = preg_replace( "/([^\\\])D/", "\\1" . backslashit( $dateweekday_abbrev ), $dateformatstring );
112		$dateformatstring = preg_replace( "/([^\\\])F/", "\\1" . backslashit( $datemonth ), $dateformatstring );
113		$dateformatstring = preg_replace( "/([^\\\])l/", "\\1" . backslashit( $dateweekday ), $dateformatstring );
114		$dateformatstring = preg_replace( "/([^\\\])M/", "\\1" . backslashit( $datemonth_abbrev ), $dateformatstring );
115		$dateformatstring = preg_replace( "/([^\\\])a/", "\\1" . backslashit( $datemeridiem ), $dateformatstring );
116		$dateformatstring = preg_replace( "/([^\\\])A/", "\\1" . backslashit( $datemeridiem_capital ), $dateformatstring );
117
118		$dateformatstring = substr( $dateformatstring, 1, strlen( $dateformatstring ) -1 );
119	}
120	$timezone_formats = array( 'P', 'I', 'O', 'T', 'Z', 'e' );
121	$timezone_formats_re = implode( '|', $timezone_formats );
122	if ( preg_match( "/$timezone_formats_re/", $dateformatstring ) ) {
123		$timezone_string = get_option( 'timezone_string' );
124		if ( $timezone_string ) {
125			$timezone_object = timezone_open( $timezone_string );
126			$date_object = date_create( null, $timezone_object );
127			foreach ( $timezone_formats as $timezone_format ) {
128				if ( false !== strpos( $dateformatstring, $timezone_format ) ) {
129					$formatted = date_format( $date_object, $timezone_format );
130					$dateformatstring = ' '.$dateformatstring;
131					$dateformatstring = preg_replace( "/([^\\\])$timezone_format/", "\\1" . backslashit( $formatted ), $dateformatstring );
132					$dateformatstring = substr( $dateformatstring, 1, strlen( $dateformatstring ) -1 );
133				}
134			}
135		}
136	}
137	$j = @date( $dateformatstring, $i );
138
139	/**
140	 * Filters the date formatted based on the locale.
141	 *
142	 * @since 2.8.0
143	 *
144	 * @param string $j          Formatted date string.
145	 * @param string $req_format Format to display the date.
146	 * @param int    $i          Unix timestamp.
147	 * @param bool   $gmt        Whether to convert to GMT for time. Default false.
148	 */
149	$j = apply_filters( 'date_i18n', $j, $req_format, $i, $gmt );
150	return $j;
151}
152
153/**
154 * Determines if the date should be declined.
155 *
156 * If the locale specifies that month names require a genitive case in certain
157 * formats (like 'j F Y'), the month name will be replaced with a correct form.
158 *
159 * @since 4.4.0
160 *
161 * @param string $date Formatted date string.
162 * @return string The date, declined if locale specifies it.
163 */
164function wp_maybe_decline_date( $date ) {
165	global $wp_locale;
166
167	// i18n functions are not available in SHORTINIT mode
168	if ( ! function_exists( '_x' ) ) {
169		return $date;
170	}
171
172	/* translators: If months in your language require a genitive case,
173	 * translate this to 'on'. Do not translate into your own language.
174	 */
175	if ( 'on' === _x( 'off', 'decline months names: on or off' ) ) {
176		// Match a format like 'j F Y' or 'j. F'
177		if ( @preg_match( '#^\d{1,2}\.? [^\d ]+#u', $date ) ) {
178			$months          = $wp_locale->month;
179			$months_genitive = $wp_locale->month_genitive;
180
181			foreach ( $months as $key => $month ) {
182				$months[ $key ] = '# ' . $month . '( |$)#u';
183			}
184
185			foreach ( $months_genitive as $key => $month ) {
186				$months_genitive[ $key ] = ' ' . $month . '$1';
187			}
188
189			$date = preg_replace( $months, $months_genitive, $date );
190		}
191	}
192
193	// Used for locale-specific rules
194	$locale = get_locale();
195
196	if ( 'ca' === $locale ) {
197		// " de abril| de agost| de octubre..." -> " d'abril| d'agost| d'octubre..."
198		$date = preg_replace( '# de ([ao])#i', " d'\\1", $date );
199	}
200
201	return $date;
202}
203
204/**
205 * Convert float number to format based on the locale.
206 *
207 * @since 2.3.0
208 *
209 * @global WP_Locale $wp_locale
210 *
211 * @param float $number   The number to convert based on locale.
212 * @param int   $decimals Optional. Precision of the number of decimal places. Default 0.
213 * @return string Converted number in string format.
214 */
215function number_format_i18n( $number, $decimals = 0 ) {
216	global $wp_locale;
217
218	if ( isset( $wp_locale ) ) {
219		$formatted = number_format( $number, absint( $decimals ), $wp_locale->number_format['decimal_point'], $wp_locale->number_format['thousands_sep'] );
220	} else {
221		$formatted = number_format( $number, absint( $decimals ) );
222	}
223
224	/**
225	 * Filters the number formatted based on the locale.
226	 *
227	 * @since  2.8.0
228	 *
229	 * @param string $formatted Converted number in string format.
230	 */
231	return apply_filters( 'number_format_i18n', $formatted );
232}
233
234/**
235 * Convert number of bytes largest unit bytes will fit into.
236 *
237 * It is easier to read 1 KB than 1024 bytes and 1 MB than 1048576 bytes. Converts
238 * number of bytes to human readable number by taking the number of that unit
239 * that the bytes will go into it. Supports TB value.
240 *
241 * Please note that integers in PHP are limited to 32 bits, unless they are on
242 * 64 bit architecture, then they have 64 bit size. If you need to place the
243 * larger size then what PHP integer type will hold, then use a string. It will
244 * be converted to a double, which should always have 64 bit length.
245 *
246 * Technically the correct unit names for powers of 1024 are KiB, MiB etc.
247 *
248 * @since 2.3.0
249 *
250 * @param int|string $bytes    Number of bytes. Note max integer size for integers.
251 * @param int        $decimals Optional. Precision of number of decimal places. Default 0.
252 * @return string|false False on failure. Number string on success.
253 */
254function size_format( $bytes, $decimals = 0 ) {
255	$quant = array(
256		'TB' => TB_IN_BYTES,
257		'GB' => GB_IN_BYTES,
258		'MB' => MB_IN_BYTES,
259		'KB' => KB_IN_BYTES,
260		'B'  => 1,
261	);
262
263	if ( 0 === $bytes ) {
264		return number_format_i18n( 0, $decimals ) . ' B';
265	}
266
267	foreach ( $quant as $unit => $mag ) {
268		if ( doubleval( $bytes ) >= $mag ) {
269			return number_format_i18n( $bytes / $mag, $decimals ) . ' ' . $unit;
270		}
271	}
272
273	return false;
274}
275
276/**
277 * Get the week start and end from the datetime or date string from MySQL.
278 *
279 * @since 0.71
280 *
281 * @param string     $mysqlstring   Date or datetime field type from MySQL.
282 * @param int|string $start_of_week Optional. Start of the week as an integer. Default empty string.
283 * @return array Keys are 'start' and 'end'.
284 */
285function get_weekstartend( $mysqlstring, $start_of_week = '' ) {
286	// MySQL string year.
287	$my = substr( $mysqlstring, 0, 4 );
288
289	// MySQL string month.
290	$mm = substr( $mysqlstring, 8, 2 );
291
292	// MySQL string day.
293	$md = substr( $mysqlstring, 5, 2 );
294
295	// The timestamp for MySQL string day.
296	$day = mktime( 0, 0, 0, $md, $mm, $my );
297
298	// The day of the week from the timestamp.
299	$weekday = date( 'w', $day );
300
301	if ( !is_numeric($start_of_week) )
302		$start_of_week = get_option( 'start_of_week' );
303
304	if ( $weekday < $start_of_week )
305		$weekday += 7;
306
307	// The most recent week start day on or before $day.
308	$start = $day - DAY_IN_SECONDS * ( $weekday - $start_of_week );
309
310	// $start + 1 week - 1 second.
311	$end = $start + WEEK_IN_SECONDS - 1;
312	return compact( 'start', 'end' );
313}
314
315/**
316 * Unserialize value only if it was serialized.
317 *
318 * @since 2.0.0
319 *
320 * @param string $original Maybe unserialized original, if is needed.
321 * @return mixed Unserialized data can be any type.
322 */
323function maybe_unserialize( $original ) {
324	if ( is_serialized( $original ) ) // don't attempt to unserialize data that wasn't serialized going in
325		return @unserialize( $original );
326	return $original;
327}
328
329/**
330 * Check value to find if it was serialized.
331 *
332 * If $data is not an string, then returned value will always be false.
333 * Serialized data is always a string.
334 *
335 * @since 2.0.5
336 *
337 * @param string $data   Value to check to see if was serialized.
338 * @param bool   $strict Optional. Whether to be strict about the end of the string. Default true.
339 * @return bool False if not serialized and true if it was.
340 */
341function is_serialized( $data, $strict = true ) {
342	// if it isn't a string, it isn't serialized.
343	if ( ! is_string( $data ) ) {
344		return false;
345	}
346	$data = trim( $data );
347 	if ( 'N;' == $data ) {
348		return true;
349	}
350	if ( strlen( $data ) < 4 ) {
351		return false;
352	}
353	if ( ':' !== $data[1] ) {
354		return false;
355	}
356	if ( $strict ) {
357		$lastc = substr( $data, -1 );
358		if ( ';' !== $lastc && '}' !== $lastc ) {
359			return false;
360		}
361	} else {
362		$semicolon = strpos( $data, ';' );
363		$brace     = strpos( $data, '}' );
364		// Either ; or } must exist.
365		if ( false === $semicolon && false === $brace )
366			return false;
367		// But neither must be in the first X characters.
368		if ( false !== $semicolon && $semicolon < 3 )
369			return false;
370		if ( false !== $brace && $brace < 4 )
371			return false;
372	}
373	$token = $data[0];
374	switch ( $token ) {
375		case 's' :
376			if ( $strict ) {
377				if ( '"' !== substr( $data, -2, 1 ) ) {
378					return false;
379				}
380			} elseif ( false === strpos( $data, '"' ) ) {
381				return false;
382			}
383			// or else fall through
384		case 'a' :
385		case 'O' :
386			return (bool) preg_match( "/^{$token}:[0-9]+:/s", $data );
387		case 'b' :
388		case 'i' :
389		case 'd' :
390			$end = $strict ? '$' : '';
391			return (bool) preg_match( "/^{$token}:[0-9.E-]+;$end/", $data );
392	}
393	return false;
394}
395
396/**
397 * Check whether serialized data is of string type.
398 *
399 * @since 2.0.5
400 *
401 * @param string $data Serialized data.
402 * @return bool False if not a serialized string, true if it is.
403 */
404function is_serialized_string( $data ) {
405	// if it isn't a string, it isn't a serialized string.
406	if ( ! is_string( $data ) ) {
407		return false;
408	}
409	$data = trim( $data );
410	if ( strlen( $data ) < 4 ) {
411		return false;
412	} elseif ( ':' !== $data[1] ) {
413		return false;
414	} elseif ( ';' !== substr( $data, -1 ) ) {
415		return false;
416	} elseif ( $data[0] !== 's' ) {
417		return false;
418	} elseif ( '"' !== substr( $data, -2, 1 ) ) {
419		return false;
420	} else {
421		return true;
422	}
423}
424
425/**
426 * Serialize data, if needed.
427 *
428 * @since 2.0.5
429 *
430 * @param string|array|object $data Data that might be serialized.
431 * @return mixed A scalar data
432 */
433function maybe_serialize( $data ) {
434	if ( is_array( $data ) || is_object( $data ) )
435		return serialize( $data );
436
437	// Double serialization is required for backward compatibility.
438	// See https://core.trac.wordpress.org/ticket/12930
439	// Also the world will end. See WP 3.6.1.
440	if ( is_serialized( $data, false ) )
441		return serialize( $data );
442
443	return $data;
444}
445
446/**
447 * Retrieve post title from XMLRPC XML.
448 *
449 * If the title element is not part of the XML, then the default post title from
450 * the $post_default_title will be used instead.
451 *
452 * @since 0.71
453 *
454 * @global string $post_default_title Default XML-RPC post title.
455 *
456 * @param string $content XMLRPC XML Request content
457 * @return string Post title
458 */
459function xmlrpc_getposttitle( $content ) {
460	global $post_default_title;
461	if ( preg_match( '/<title>(.+?)<\/title>/is', $content, $matchtitle ) ) {
462		$post_title = $matchtitle[1];
463	} else {
464		$post_title = $post_default_title;
465	}
466	return $post_title;
467}
468
469/**
470 * Retrieve the post category or categories from XMLRPC XML.
471 *
472 * If the category element is not found, then the default post category will be
473 * used. The return type then would be what $post_default_category. If the
474 * category is found, then it will always be an array.
475 *
476 * @since 0.71
477 *
478 * @global string $post_default_category Default XML-RPC post category.
479 *
480 * @param string $content XMLRPC XML Request content
481 * @return string|array List of categories or category name.
482 */
483function xmlrpc_getpostcategory( $content ) {
484	global $post_default_category;
485	if ( preg_match( '/<category>(.+?)<\/category>/is', $content, $matchcat ) ) {
486		$post_category = trim( $matchcat[1], ',' );
487		$post_category = explode( ',', $post_category );
488	} else {
489		$post_category = $post_default_category;
490	}
491	return $post_category;
492}
493
494/**
495 * XMLRPC XML content without title and category elements.
496 *
497 * @since 0.71
498 *
499 * @param string $content XML-RPC XML Request content.
500 * @return string XMLRPC XML Request content without title and category elements.
501 */
502function xmlrpc_removepostdata( $content ) {
503	$content = preg_replace( '/<title>(.+?)<\/title>/si', '', $content );
504	$content = preg_replace( '/<category>(.+?)<\/category>/si', '', $content );
505	$content = trim( $content );
506	return $content;
507}
508
509/**
510 * Use RegEx to extract URLs from arbitrary content.
511 *
512 * @since 3.7.0
513 *
514 * @param string $content Content to extract URLs from.
515 * @return array URLs found in passed string.
516 */
517function wp_extract_urls( $content ) {
518	preg_match_all(
519		"#([\"']?)("
520			. "(?:([\w-]+:)?//?)"
521			. "[^\s()<>]+"
522			. "[.]"
523			. "(?:"
524				. "\([\w\d]+\)|"
525				. "(?:"
526					. "[^`!()\[\]{};:'\".,<>«»“”‘’\s]|"
527					. "(?:[:]\d+)?/?"
528				. ")+"
529			. ")"
530		. ")\\1#",
531		$content,
532		$post_links
533	);
534
535	$post_links = array_unique( array_map( 'html_entity_decode', $post_links[2] ) );
536
537	return array_values( $post_links );
538}
539
540/**
541 * Check content for video and audio links to add as enclosures.
542 *
543 * Will not add enclosures that have already been added and will
544 * remove enclosures that are no longer in the post. This is called as
545 * pingbacks and trackbacks.
546 *
547 * @since 1.5.0
548 *
549 * @global wpdb $wpdb WordPress database abstraction object.
550 *
551 * @param string $content Post Content.
552 * @param int    $post_ID Post ID.
553 */
554function do_enclose( $content, $post_ID ) {
555	global $wpdb;
556
557	//TODO: Tidy this ghetto code up and make the debug code optional
558	include_once( ABSPATH . WPINC . '/class-IXR.php' );
559
560	$post_links = array();
561
562	$pung = get_enclosed( $post_ID );
563
564	$post_links_temp = wp_extract_urls( $content );
565
566	foreach ( $pung as $link_test ) {
567		if ( ! in_array( $link_test, $post_links_temp ) ) { // link no longer in post
568			$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 ) . '%') );
569			foreach ( $mids as $mid )
570				delete_metadata_by_mid( 'post', $mid );
571		}
572	}
573
574	foreach ( (array) $post_links_temp as $link_test ) {
575		if ( !in_array( $link_test, $pung ) ) { // If we haven't pung it already
576			$test = @parse_url( $link_test );
577			if ( false === $test )
578				continue;
579			if ( isset( $test['query'] ) )
580				$post_links[] = $link_test;
581			elseif ( isset($test['path']) && ( $test['path'] != '/' ) &&  ($test['path'] != '' ) )
582				$post_links[] = $link_test;
583		}
584	}
585
586	/**
587	 * Filters the list of enclosure links before querying the database.
588	 *
589	 * Allows for the addition and/or removal of potential enclosures to save
590	 * to postmeta before checking the database for existing enclosures.
591	 *
592	 * @since 4.4.0
593	 *
594	 * @param array $post_links An array of enclosure links.
595	 * @param int   $post_ID    Post ID.
596	 */
597	$post_links = apply_filters( 'enclosure_links', $post_links, $post_ID );
598
599	foreach ( (array) $post_links as $url ) {
600		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 ) . '%' ) ) ) {
601
602			if ( $headers = wp_get_http_headers( $url) ) {
603				$len = isset( $headers['content-length'] ) ? (int) $headers['content-length'] : 0;
604				$type = isset( $headers['content-type'] ) ? $headers['content-type'] : '';
605				$allowed_types = array( 'video', 'audio' );
606
607				// Check to see if we can figure out the mime type from
608				// the extension
609				$url_parts = @parse_url( $url );
610				if ( false !== $url_parts ) {
611					$extension = pathinfo( $url_parts['path'], PATHINFO_EXTENSION );
612					if ( !empty( $extension ) ) {
613						foreach ( wp_get_mime_types() as $exts => $mime ) {
614							if ( preg_match( '!^(' . $exts . ')$!i', $extension ) ) {
615								$type = $mime;
616								break;
617							}
618						}
619					}
620				}
621
622				if ( in_array( substr( $type, 0, strpos( $type, "/" ) ), $allowed_types ) ) {
623					add_post_meta( $post_ID, 'enclosure', "$url\n$len\n$mime\n" );
624				}
625			}
626		}
627	}
628}
629
630/**
631 * Retrieve HTTP Headers from URL.
632 *
633 * @since 1.5.1
634 *
635 * @param string $url        URL to retrieve HTTP headers from.
636 * @param bool   $deprecated Not Used.
637 * @return bool|string False on failure, headers on success.
638 */
639function wp_get_http_headers( $url, $deprecated = false ) {
640	if ( !empty( $deprecated ) )
641		_deprecated_argument( __FUNCTION__, '2.7.0' );
642
643	$response = wp_safe_remote_head( $url );
644
645	if ( is_wp_error( $response ) )
646		return false;
647
648	return wp_remote_retrieve_headers( $response );
649}
650
651/**
652 * Whether the publish date of the current post in the loop is different from the
653 * publish date of the previous post in the loop.
654 *
655 * @since 0.71
656 *
657 * @global string $currentday  The day of the current post in the loop.
658 * @global string $previousday The day of the previous post in the loop.
659 *
660 * @return int 1 when new day, 0 if not a new day.
661 */
662function is_new_day() {
663	global $currentday, $previousday;
664	if ( $currentday != $previousday )
665		return 1;
666	else
667		return 0;
668}
669
670/**
671 * Build URL query based on an associative and, or indexed array.
672 *
673 * This is a convenient function for easily building url queries. It sets the
674 * separator to '&' and uses _http_build_query() function.
675 *
676 * @since 2.3.0
677 *
678 * @see _http_build_query() Used to build the query
679 * @link https://secure.php.net/manual/en/function.http-build-query.php for more on what
680 *		 http_build_query() does.
681 *
682 * @param array $data URL-encode key/value pairs.
683 * @return string URL-encoded string.
684 */
685function build_query( $data ) {
686	return _http_build_query( $data, null, '&', '', false );
687}
688
689/**
690 * From php.net (modified by Mark Jaquith to behave like the native PHP5 function).
691 *
692 * @since 3.2.0
693 * @access private
694 *
695 * @see https://secure.php.net/manual/en/function.http-build-query.php
696 *
697 * @param array|object  $data       An array or object of data. Converted to array.
698 * @param string        $prefix     Optional. Numeric index. If set, start parameter numbering with it.
699 *                                  Default null.
700 * @param string        $sep        Optional. Argument separator; defaults to 'arg_separator.output'.
701 *                                  Default null.
702 * @param string        $key        Optional. Used to prefix key name. Default empty.
703 * @param bool          $urlencode  Optional. Whether to use urlencode() in the result. Default true.
704 *
705 * @return string The query string.
706 */
707function _http_build_query( $data, $prefix = null, $sep = null, $key = '', $urlencode = true ) {
708	$ret = array();
709
710	foreach ( (array) $data as $k => $v ) {
711		if ( $urlencode)
712			$k = urlencode($k);
713		if ( is_int($k) && $prefix != null )
714			$k = $prefix.$k;
715		if ( !empty($key) )
716			$k = $key . '%5B' . $k . '%5D';
717		if ( $v === null )
718			continue;
719		elseif ( $v === false )
720			$v = '0';
721
722		if ( is_array($v) || is_object($v) )
723			array_push($ret,_http_build_query($v, '', $sep, $k, $urlencode));
724		elseif ( $urlencode )
725			array_push($ret, $k.'='.urlencode($v));
726		else
727			array_push($ret, $k.'='.$v);
728	}
729
730	if ( null === $sep )
731		$sep = ini_get('arg_separator.output');
732
733	return implode($sep, $ret);
734}
735
736/**
737 * Retrieves a modified URL query string.
738 *
739 * You can rebuild the URL and append query variables to the URL query by using this function.
740 * There are two ways to use this function; either a single key and value, or an associative array.
741 *
742 * Using a single key and value:
743 *
744 *     add_query_arg( 'key', 'value', 'http://example.com' );
745 *
746 * Using an associative array:
747 *
748 *     add_query_arg( array(
749 *         'key1' => 'value1',
750 *         'key2' => 'value2',
751 *     ), 'http://example.com' );
752 *
753 * Omitting the URL from either use results in the current URL being used
754 * (the value of `$_SERVER['REQUEST_URI']`).
755 *
756 * Values are expected to be encoded appropriately with urlencode() or rawurlencode().
757 *
758 * Setting any query variable's value to boolean false removes the key (see remove_query_arg()).
759 *
760 * Important: The return value of add_query_arg() is not escaped by default. Output should be
761 * late-escaped with esc_url() or similar to help prevent vulnerability to cross-site scripting
762 * (XSS) attacks.
763 *
764 * @since 1.5.0
765 *
766 * @param string|array $key   Either a query variable key, or an associative array of query variables.
767 * @param string       $value Optional. Either a query variable value, or a URL to act upon.
768 * @param string       $url   Optional. A URL to act upon.
769 * @return string New URL query string (unescaped).
770 */
771function add_query_arg() {
772	$args = func_get_args();
773	if ( is_array( $args[0] ) ) {
774		if ( count( $args ) < 2 || false === $args[1] )
775			$uri = $_SERVER['REQUEST_URI'];
776		else
777			$uri = $args[1];
778	} else {
779		if ( count( $args ) < 3 || false === $args[2] )
780			$uri = $_SERVER['REQUEST_URI'];
781		else
782			$uri = $args[2];
783	}
784
785	if ( $frag = strstr( $uri, '#' ) )
786		$uri = substr( $uri, 0, -strlen( $frag ) );
787	else
788		$frag = '';
789
790	if ( 0 === stripos( $uri, 'http://' ) ) {
791		$protocol = 'http://';
792		$uri = substr( $uri, 7 );
793	} elseif ( 0 === stripos( $uri, 'https://' ) ) {
794		$protocol = 'https://';
795		$uri = substr( $uri, 8 );
796	} else {
797		$protocol = '';
798	}
799
800	if ( strpos( $uri, '?' ) !== false ) {
801		list( $base, $query ) = explode( '?', $uri, 2 );
802		$base .= '?';
803	} elseif ( $protocol || strpos( $uri, '=' ) === false ) {
804		$base = $uri . '?';
805		$query = '';
806	} else {
807		$base = '';
808		$query = $uri;
809	}
810
811	wp_parse_str( $query, $qs );
812	$qs = urlencode_deep( $qs ); // this re-URL-encodes things that were already in the query string
813	if ( is_array( $args[0] ) ) {
814		foreach ( $args[0] as $k => $v ) {
815			$qs[ $k ] = $v;
816		}
817	} else {
818		$qs[ $args[0] ] = $args[1];
819	}
820
821	foreach ( $qs as $k => $v ) {
822		if ( $v === false )
823			unset( $qs[$k] );
824	}
825
826	$ret = build_query( $qs );
827	$ret = trim( $ret, '?' );
828	$ret = preg_replace( '#=(&|$)#', '$1', $ret );
829	$ret = $protocol . $base . $ret . $frag;
830	$ret = rtrim( $ret, '?' );
831	return $ret;
832}
833
834/**
835 * Removes an item or items from a query string.
836 *
837 * @since 1.5.0
838 *
839 * @param string|array $key   Query key or keys to remove.
840 * @param bool|string  $query Optional. When false uses the current URL. Default false.
841 * @return string New URL query string.
842 */
843function remove_query_arg( $key, $query = false ) {
844	if ( is_array( $key ) ) { // removing multiple keys
845		foreach ( $key as $k )
846			$query = add_query_arg( $k, false, $query );
847		return $query;
848	}
849	return add_query_arg( $key, false, $query );
850}
851
852/**
853 * Returns an array of single-use query variable names that can be removed from a URL.
854 *
855 * @since 4.4.0
856 *
857 * @return array An array of parameters to remove from the URL.
858 */
859function wp_removable_query_args() {
860	$removable_query_args = array(
861		'activate',
862		'activated',
863		'approved',
864		'deactivate',
865		'deleted',
866		'disabled',
867		'enabled',
868		'error',
869		'hotkeys_highlight_first',
870		'hotkeys_highlight_last',
871		'locked',
872		'message',
873		'same',
874		'saved',
875		'settings-updated',
876		'skipped',
877		'spammed',
878		'trashed',
879		'unspammed',
880		'untrashed',
881		'update',
882		'updated',
883		'wp-post-new-reload',
884	);
885
886	/**
887	 * Filters the list of query variables to remove.
888	 *
889	 * @since 4.2.0
890	 *
891	 * @param array $removable_query_args An array of query variables to remove from a URL.
892	 */
893	return apply_filters( 'removable_query_args', $removable_query_args );
894}
895
896/**
897 * Walks the array while sanitizing the contents.
898 *
899 * @since 0.71
900 *
901 * @param array $array Array to walk while sanitizing contents.
902 * @return array Sanitized $array.
903 */
904function add_magic_quotes( $array ) {
905	foreach ( (array) $array as $k => $v ) {
906		if ( is_array( $v ) ) {
907			$array[$k] = add_magic_quotes( $v );
908		} else {
909			$array[$k] = addslashes( $v );
910		}
911	}
912	return $array;
913}
914
915/**
916 * HTTP request for URI to retrieve content.
917 *
918 * @since 1.5.1
919 *
920 * @see wp_safe_remote_get()
921 *
922 * @param string $uri URI/URL of web page to retrieve.
923 * @return false|string HTTP content. False on failure.
924 */
925function wp_remote_fopen( $uri ) {
926	$parsed_url = @parse_url( $uri );
927
928	if ( !$parsed_url || !is_array( $parsed_url ) )
929		return false;
930
931	$options = array();
932	$options['timeout'] = 10;
933
934	$response = wp_safe_remote_get( $uri, $options );
935
936	if ( is_wp_error( $response ) )
937		return false;
938
939	return wp_remote_retrieve_body( $response );
940}
941
942/**
943 * Set up the WordPress query.
944 *
945 * @since 2.0.0
946 *
947 * @global WP       $wp_locale
948 * @global WP_Query $wp_query
949 * @global WP_Query $wp_the_query
950 *
951 * @param string|array $query_vars Default WP_Query arguments.
952 */
953function wp( $query_vars = '' ) {
954	global $wp, $wp_query, $wp_the_query;
955	$wp->main( $query_vars );
956
957	if ( !isset($wp_the_query) )
958		$wp_the_query = $wp_query;
959}
960
961/**
962 * Retrieve the description for the HTTP status.
963 *
964 * @since 2.3.0
965 *
966 * @global array $wp_header_to_desc
967 *
968 * @param int $code HTTP status code.
969 * @return string Empty string if not found, or description if found.
970 */
971function get_status_header_desc( $code ) {
972	global $wp_header_to_desc;
973
974	$code = absint( $code );
975
976	if ( !isset( $wp_header_to_desc ) ) {
977		$wp_header_to_desc = array(
978			100 => 'Continue',
979			101 => 'Switching Protocols',
980			102 => 'Processing',
981
982			200 => 'OK',
983			201 => 'Created',
984			202 => 'Accepted',
985			203 => 'Non-Authoritative Information',
986			204 => 'No Content',
987			205 => 'Reset Content',
988			206 => 'Partial Content',
989			207 => 'Multi-Status',
990			226 => 'IM Used',
991
992			300 => 'Multiple Choices',
993			301 => 'Moved Permanently',
994			302 => 'Found',
995			303 => 'See Other',
996			304 => 'Not Modified',
997			305 => 'Use Proxy',
998			306 => 'Reserved',
999			307 => 'Temporary Redirect',
1000			308 => 'Permanent Redirect',
1001
1002			400 => 'Bad Request',
1003			401 => 'Unauthorized',
1004			402 => 'Payment Required',
1005			403 => 'Forbidden',
1006			404 => 'Not Found',
1007			405 => 'Method Not Allowed',
1008			406 => 'Not Acceptable',
1009			407 => 'Proxy Authentication Required',
1010			408 => 'Request Timeout',
1011			409 => 'Conflict',
1012			410 => 'Gone',
1013			411 => 'Length Required',
1014			412 => 'Precondition Failed',
1015			413 => 'Request Entity Too Large',
1016			414 => 'Request-URI Too Long',
1017			415 => 'Unsupported Media Type',
1018			416 => 'Requested Range Not Satisfiable',
1019			417 => 'Expectation Failed',
1020			418 => 'I\'m a teapot',
1021			421 => 'Misdirected Request',
1022			422 => 'Unprocessable Entity',
1023			423 => 'Locked',
1024			424 => 'Failed Dependency',
1025			426 => 'Upgrade Required',
1026			428 => 'Precondition Required',
1027			429 => 'Too Many Requests',
1028			431 => 'Request Header Fields Too Large',
1029			451 => 'Unavailable For Legal Reasons',
1030
1031			500 => 'Internal Server Error',
1032			501 => 'Not Implemented',
1033			502 => 'Bad Gateway',
1034			503 => 'Service Unavailable',
1035			504 => 'Gateway Timeout',
1036			505 => 'HTTP Version Not Supported',
1037			506 => 'Variant Also Negotiates',
1038			507 => 'Insufficient Storage',
1039			510 => 'Not Extended',
1040			511 => 'Network Authentication Required',
1041		);
1042	}
1043
1044	if ( isset( $wp_header_to_desc[$code] ) )
1045		return $wp_header_to_desc[$code];
1046	else
1047		return '';
1048}
1049
1050/**
1051 * Set HTTP status header.
1052 *
1053 * @since 2.0.0
1054 * @since 4.4.0 Added the `$description` parameter.
1055 *
1056 * @see get_status_header_desc()
1057 *
1058 * @param int    $code        HTTP status code.
1059 * @param string $description Optional. A custom description for the HTTP status.
1060 */
1061function status_header( $code, $description = '' ) {
1062	if ( ! $description ) {
1063		$description = get_status_header_desc( $code );
1064	}
1065
1066	if ( empty( $description ) ) {
1067		return;
1068	}
1069
1070	$protocol = wp_get_server_protocol();
1071	$status_header = "$protocol $code $description";
1072	if ( function_exists( 'apply_filters' ) )
1073
1074		/**
1075		 * Filters an HTTP status header.
1076		 *
1077		 * @since 2.2.0
1078		 *
1079		 * @param string $status_header HTTP status header.
1080		 * @param int    $code          HTTP status code.
1081		 * @param string $description   Description for the status code.
1082		 * @param string $protocol      Server protocol.
1083		 */
1084		$status_header = apply_filters( 'status_header', $status_header, $code, $description, $protocol );
1085
1086	@header( $status_header, true, $code );
1087}
1088
1089/**
1090 * Get the header information to prevent caching.
1091 *
1092 * The several different headers cover the different ways cache prevention
1093 * is handled by different browsers
1094 *
1095 * @since 2.8.0
1096 *
1097 * @return array The associative array of header names and field values.
1098 */
1099function wp_get_nocache_headers() {
1100	$headers = array(
1101		'Expires' => 'Wed, 11 Jan 1984 05:00:00 GMT',
1102		'Cache-Control' => 'no-cache, must-revalidate, max-age=0',
1103	);
1104
1105	if ( function_exists('apply_filters') ) {
1106		/**
1107		 * Filters the cache-controlling headers.
1108		 *
1109		 * @since 2.8.0
1110		 *
1111		 * @see wp_get_nocache_headers()
1112		 *
1113		 * @param array $headers {
1114		 *     Header names and field values.
1115		 *
1116		 *     @type string $Expires       Expires header.
1117		 *     @type string $Cache-Control Cache-Control header.
1118		 * }
1119		 */
1120		$headers = (array) apply_filters( 'nocache_headers', $headers );
1121	}
1122	$headers['Last-Modified'] = false;
1123	return $headers;
1124}
1125
1126/**
1127 * Set the headers to prevent caching for the different browsers.
1128 *
1129 * Different browsers support different nocache headers, so several
1130 * headers must be sent so that all of them get the point that no
1131 * caching should occur.
1132 *
1133 * @since 2.0.0
1134 *
1135 * @see wp_get_nocache_headers()
1136 */
1137function nocache_headers() {
1138	$headers = wp_get_nocache_headers();
1139
1140	unset( $headers['Last-Modified'] );
1141
1142	// In PHP 5.3+, make sure we are not sending a Last-Modified header.
1143	if ( function_exists( 'header_remove' ) ) {
1144		@header_remove( 'Last-Modified' );
1145	} else {
1146		// In PHP 5.2, send an empty Last-Modified header, but only as a
1147		// last resort to override a header already sent. #WP23021
1148		foreach ( headers_list() as $header ) {
1149			if ( 0 === stripos( $header, 'Last-Modified' ) ) {
1150				$headers['Last-Modified'] = '';
1151				break;
1152			}
1153		}
1154	}
1155
1156	foreach ( $headers as $name => $field_value )
1157		@header("{$name}: {$field_value}");
1158}
1159
1160/**
1161 * Set the headers for caching for 10 days with JavaScript content type.
1162 *
1163 * @since 2.1.0
1164 */
1165function cache_javascript_headers() {
1166	$expiresOffset = 10 * DAY_IN_SECONDS;
1167
1168	header( "Content-Type: text/javascript; charset=" . get_bloginfo( 'charset' ) );
1169	header( "Vary: Accept-Encoding" ); // Handle proxies
1170	header( "Expires: " . gmdate( "D, d M Y H:i:s", time() + $expiresOffset ) . " GMT" );
1171}
1172
1173/**
1174 * Retrieve the number of database queries during the WordPress execution.
1175 *
1176 * @since 2.0.0
1177 *
1178 * @global wpdb $wpdb WordPress database abstraction object.
1179 *
1180 * @return int Number of database queries.
1181 */
1182function get_num_queries() {
1183	global $wpdb;
1184	return $wpdb->num_queries;
1185}
1186
1187/**
1188 * Whether input is yes or no.
1189 *
1190 * Must be 'y' to be true.
1191 *
1192 * @since 1.0.0
1193 *
1194 * @param string $yn Character string containing either 'y' (yes) or 'n' (no).
1195 * @return bool True if yes, false on anything else.
1196 */
1197function bool_from_yn( $yn ) {
1198	return ( strtolower( $yn ) == 'y' );
1199}
1200
1201/**
1202 * Load the feed template from the use of an action hook.
1203 *
1204 * If the feed action does not have a hook, then the function will die with a
1205 * message telling the visitor that the feed is not valid.
1206 *
1207 * It is better to only have one hook for each feed.
1208 *
1209 * @since 2.1.0
1210 *
1211 * @global WP_Query $wp_query Used to tell if the use a comment feed.
1212 */
1213function do_feed() {
1214	global $wp_query;
1215
1216	// Determine if we are looking at the main comment feed
1217	$is_main_comments_feed = ( $wp_query->is_comment_feed() && ! $wp_query->is_singular() );
1218
1219	/*
1220	 * Check the queried object for the existence of posts if it is not a feed for an archive,
1221	 * search result, or main comments. By checking for the absense of posts we can prevent rendering the feed
1222	 * templates at invalid endpoints. e.g.) /wp-content/plugins/feed/
1223	 */
1224	if ( ! $wp_query->have_posts() && ! ( $wp_query->is_archive() || $wp_query->is_search() || $is_main_comments_feed ) ) {
1225		wp_die( __( 'ERROR: This is not a valid feed.' ), '', array( 'response' => 404 ) );
1226	}
1227
1228	$feed = get_query_var( 'feed' );
1229
1230	// Remove the pad, if present.
1231	$feed = preg_replace( '/^_+/', '', $feed );
1232
1233	if ( $feed == '' || $feed == 'feed' )
1234		$feed = get_default_feed();
1235
1236	if ( ! has_action( "do_feed_{$feed}" ) ) {
1237		wp_die( __( 'ERROR: This is not a valid feed template.' ), '', array( 'response' => 404 ) );
1238	}
1239
1240	/**
1241	 * Fires once the given feed is loaded.
1242	 *
1243	 * The dynamic portion of the hook name, `$feed`, refers to the feed template name.
1244	 * Possible values include: 'rdf', 'rss', 'rss2', and 'atom'.
1245	 *
1246	 * @since 2.1.0
1247	 * @since 4.4.0 The `$feed` parameter was added.
1248	 *
1249	 * @param bool   $is_comment_feed Whether the feed is a comment feed.
1250	 * @param string $feed            The feed name.
1251	 */
1252	do_action( "do_feed_{$feed}", $wp_query->is_comment_feed, $feed );
1253}
1254
1255/**
1256 * Load the RDF RSS 0.91 Feed template.
1257 *
1258 * @since 2.1.0
1259 *
1260 * @see load_template()
1261 */
1262function do_feed_rdf() {
1263	load_template( ABSPATH . WPINC . '/feed-rdf.php' );
1264}
1265
1266/**
1267 * Load the RSS 1.0 Feed Template.
1268 *
1269 * @since 2.1.0
1270 *
1271 * @see load_template()
1272 */
1273function do_feed_rss() {
1274	load_template( ABSPATH . WPINC . '/feed-rss.php' );
1275}
1276
1277/**
1278 * Load either the RSS2 comment feed or the RSS2 posts feed.
1279 *
1280 * @since 2.1.0
1281 *
1282 * @see load_template()
1283 *
1284 * @param bool $for_comments True for the comment feed, false for normal feed.
1285 */
1286function do_feed_rss2( $for_comments ) {
1287	if ( $for_comments )
1288		load_template( ABSPATH . WPINC . '/feed-rss2-comments.php' );
1289	else
1290		load_template( ABSPATH . WPINC . '/feed-rss2.php' );
1291}
1292
1293/**
1294 * Load either Atom comment feed or Atom posts feed.
1295 *
1296 * @since 2.1.0
1297 *
1298 * @see load_template()
1299 *
1300 * @param bool $for_comments True for the comment feed, false for normal feed.
1301 */
1302function do_feed_atom( $for_comments ) {
1303	if ($for_comments)
1304		load_template( ABSPATH . WPINC . '/feed-atom-comments.php');
1305	else
1306		load_template( ABSPATH . WPINC . '/feed-atom.php' );
1307}
1308
1309/**
1310 * Display the robots.txt file content.
1311 *
1312 * The echo content should be with usage of the permalinks or for creating the
1313 * robots.txt file.
1314 *
1315 * @since 2.1.0
1316 */
1317function do_robots() {
1318	header( 'Content-Type: text/plain; charset=utf-8' );
1319
1320	/**
1321	 * Fires when displaying the robots.txt file.
1322	 *
1323	 * @since 2.1.0
1324	 */
1325	do_action( 'do_robotstxt' );
1326
1327	$output = "User-agent: *\n";
1328	$public = get_option( 'blog_public' );
1329	if ( '0' == $public ) {
1330		$output .= "Disallow: /\n";
1331	} else {
1332		$site_url = parse_url( site_url() );
1333		$path = ( !empty( $site_url['path'] ) ) ? $site_url['path'] : '';
1334		$output .= "Disallow: $path/wp-admin/\n";
1335		$output .= "Allow: $path/wp-admin/admin-ajax.php\n";
1336	}
1337
1338	/**
1339	 * Filters the robots.txt output.
1340	 *
1341	 * @since 3.0.0
1342	 *
1343	 * @param string $output Robots.txt output.
1344	 * @param bool   $public Whether the site is considered "public".
1345	 */
1346	echo apply_filters( 'robots_txt', $output, $public );
1347}
1348
1349/**
1350 * Test whether WordPress is already installed.
1351 *
1352 * The cache will be checked first. If you have a cache plugin, which saves
1353 * the cache values, then this will work. If you use the default WordPress
1354 * cache, and the database goes away, then you might have problems.
1355 *
1356 * Checks for the 'siteurl' option for whether WordPress is installed.
1357 *
1358 * @since 2.1.0
1359 *
1360 * @global wpdb $wpdb WordPress database abstraction object.
1361 *
1362 * @return bool Whether the site is already installed.
1363 */
1364function is_blog_installed() {
1365	global $wpdb;
1366
1367	/*
1368	 * Check cache first. If options table goes away and we have true
1369	 * cached, oh well.
1370	 */
1371	if ( wp_cache_get( 'is_blog_installed' ) )
1372		return true;
1373
1374	$suppress = $wpdb->suppress_errors();
1375	if ( ! wp_installing() ) {
1376		$alloptions = wp_load_alloptions();
1377	}
1378	// If siteurl is not set to autoload, check it specifically
1379	if ( !isset( $alloptions['siteurl'] ) )
1380		$installed = $wpdb->get_var( "SELECT option_value FROM $wpdb->options WHERE option_name = 'siteurl'" );
1381	else
1382		$installed = $alloptions['siteurl'];
1383	$wpdb->suppress_errors( $suppress );
1384
1385	$installed = !empty( $installed );
1386	wp_cache_set( 'is_blog_installed', $installed );
1387
1388	if ( $installed )
1389		return true;
1390
1391	// If visiting repair.php, return true and let it take over.
1392	if ( defined( 'WP_REPAIRING' ) )
1393		return true;
1394
1395	$suppress = $wpdb->suppress_errors();
1396
1397	/*
1398	 * Loop over the WP tables. If none exist, then scratch install is allowed.
1399	 * If one or more exist, suggest table repair since we got here because the
1400	 * options table could not be accessed.
1401	 */
1402	$wp_tables = $wpdb->tables();
1403	foreach ( $wp_tables as $table ) {
1404		// The existence of custom user tables shouldn't suggest an insane state or prevent a clean install.
1405		if ( defined( 'CUSTOM_USER_TABLE' ) && CUSTOM_USER_TABLE == $table )
1406			continue;
1407		if ( defined( 'CUSTOM_USER_META_TABLE' ) && CUSTOM_USER_META_TABLE == $table )
1408			continue;
1409
1410		if ( ! $wpdb->get_results( "DESCRIBE $table;" ) )
1411			continue;
1412
1413		// One or more tables exist. We are insane.
1414
1415		wp_load_translations_early();
1416
1417		// Die with a DB error.
1418		$wpdb->error = sprintf(
1419			/* translators: %s: database repair URL */
1420			__( 'One or more database tables are unavailable. The database may need to be <a href="%s">repaired</a>.' ),
1421			'maint/repair.php?referrer=is_blog_installed'
1422		);
1423
1424		dead_db();
1425	}
1426
1427	$wpdb->suppress_errors( $suppress );
1428
1429	wp_cache_set( 'is_blog_installed', false );
1430
1431	return false;
1432}
1433
1434/**
1435 * Retrieve URL with nonce added to URL query.
1436 *
1437 * @since 2.0.4
1438 *
1439 * @param string     $actionurl URL to add nonce action.
1440 * @param int|string $action    Optional. Nonce action name. Default -1.
1441 * @param string     $name      Optional. Nonce name. Default '_wpnonce'.
1442 * @return string Escaped URL with nonce action added.
1443 */
1444function wp_nonce_url( $actionurl, $action = -1, $name = '_wpnonce' ) {
1445	$actionurl = str_replace( '&amp;', '&', $actionurl );
1446	return esc_html( add_query_arg( $name, wp_create_nonce( $action ), $actionurl ) );
1447}
1448
1449/**
1450 * Retrieve or display nonce hidden field for forms.
1451 *
1452 * The nonce field is used to validate that the contents of the form came from
1453 * the location on the current site and not somewhere else. The nonce does not
1454 * offer absolute protection, but should protect against most cases. It is very
1455 * important to use nonce field in forms.
1456 *
1457 * The $action and $name are optional, but if you want to have better security,
1458 * it is strongly suggested to set those two parameters. It is easier to just
1459 * call the function without any parameters, because validation of the nonce
1460 * doesn't require any parameters, but since crackers know what the default is
1461 * it won't be difficult for them to find a way around your nonce and cause
1462 * damage.
1463 *
1464 * The input name will be whatever $name value you gave. The input value will be
1465 * the nonce creation value.
1466 *
1467 * @since 2.0.4
1468 *
1469 * @param int|string $action  Optional. Action name. Default -1.
1470 * @param string     $name    Optional. Nonce name. Default '_wpnonce'.
1471 * @param bool       $referer Optional. Whether to set the referer field for validation. Default true.
1472 * @param bool       $echo    Optional. Whether to display or return hidden form field. Default true.
1473 * @return string Nonce field HTML markup.
1474 */
1475function wp_nonce_field( $action = -1, $name = "_wpnonce", $referer = true , $echo = true ) {
1476	$name = esc_attr( $name );
1477	$nonce_field = '<input type="hidden" id="' . $name . '" name="' . $name . '" value="' . wp_create_nonce( $action ) . '" />';
1478
1479	if ( $referer )
1480		$nonce_field .= wp_referer_field( false );
1481
1482	if ( $echo )
1483		echo $nonce_field;
1484
1485	return $nonce_field;
1486}
1487
1488/**
1489 * Retrieve or display referer hidden field for forms.
1490 *
1491 * The referer link is the current Request URI from the server super global. The
1492 * input name is '_wp_http_referer', in case you wanted to check manually.
1493 *
1494 * @since 2.0.4
1495 *
1496 * @param bool $echo Optional. Whether to echo or return the referer field. Default true.
1497 * @return string Referer field HTML markup.
1498 */
1499function wp_referer_field( $echo = true ) {
1500	$referer_field = '<input type="hidden" name="_wp_http_referer" value="'. esc_attr( wp_unslash( $_SERVER['REQUEST_URI'] ) ) . '" />';
1501
1502	if ( $echo )
1503		echo $referer_field;
1504	return $referer_field;
1505}
1506
1507/**
1508 * Retrieve or display original referer hidden field for forms.
1509 *
1510 * The input name is '_wp_original_http_referer' and will be either the same
1511 * value of wp_referer_field(), if that was posted already or it will be the
1512 * current page, if it doesn't exist.
1513 *
1514 * @since 2.0.4
1515 *
1516 * @param bool   $echo         Optional. Whether to echo the original http referer. Default true.
1517 * @param string $jump_back_to Optional. Can be 'previous' or page you want to jump back to.
1518 *                             Default 'current'.
1519 * @return string Original referer field.
1520 */
1521function wp_original_referer_field( $echo = true, $jump_back_to = 'current' ) {
1522	if ( ! $ref = wp_get_original_referer() ) {
1523		$ref = 'previous' == $jump_back_to ? wp_get_referer() : wp_unslash( $_SERVER['REQUEST_URI'] );
1524	}
1525	$orig_referer_field = '<input type="hidden" name="_wp_original_http_referer" value="' . esc_attr( $ref ) . '" />';
1526	if ( $echo )
1527		echo $orig_referer_field;
1528	return $orig_referer_field;
1529}
1530
1531/**
1532 * Retrieve referer from '_wp_http_referer' or HTTP referer.
1533 *
1534 * If it's the same as the current request URL, will return false.
1535 *
1536 * @since 2.0.4
1537 *
1538 * @return false|string False on failure. Referer URL on success.
1539 */
1540function wp_get_referer() {
1541	if ( ! function_exists( 'wp_validate_redirect' ) ) {
1542		return false;
1543	}
1544
1545	$ref = wp_get_raw_referer();
1546
1547	if ( $ref && $ref !== wp_unslash( $_SERVER['REQUEST_URI'] ) && $ref !== home_url() . wp_unslash( $_SERVER['REQUEST_URI'] ) ) {
1548		return wp_validate_redirect( $ref, false );
1549	}
1550
1551	return false;
1552}
1553
1554/**
1555 * Retrieves unvalidated referer from '_wp_http_referer' or HTTP referer.
1556 *
1557 * Do not use for redirects, use wp_get_referer() instead.
1558 *
1559 * @since 4.5.0
1560 *
1561 * @return string|false Referer URL on success, false on failure.
1562 */
1563function wp_get_raw_referer() {
1564	if ( ! empty( $_REQUEST['_wp_http_referer'] ) ) {
1565		return wp_unslash( $_REQUEST['_wp_http_referer'] );
1566	} else if ( ! empty( $_SERVER['HTTP_REFERER'] ) ) {
1567		return wp_unslash( $_SERVER['HTTP_REFERER'] );
1568	}
1569
1570	return false;
1571}
1572
1573/**
1574 * Retrieve original referer that was posted, if it exists.
1575 *
1576 * @since 2.0.4
1577 *
1578 * @return string|false False if no original referer or original referer if set.
1579 */
1580function wp_get_original_referer() {
1581	if ( ! empty( $_REQUEST['_wp_original_http_referer'] ) && function_exists( 'wp_validate_redirect' ) )
1582		return wp_validate_redirect( wp_unslash( $_REQUEST['_wp_original_http_referer'] ), false );
1583	return false;
1584}
1585
1586/**
1587 * Recursive directory creation based on full path.
1588 *
1589 * Will attempt to set permissions on folders.
1590 *
1591 * @since 2.0.1
1592 *
1593 * @param string $target Full path to attempt to create.
1594 * @return bool Whether the path was created. True if path already exists.
1595 */
1596function wp_mkdir_p( $target ) {
1597	$wrapper = null;
1598
1599	// Strip the protocol.
1600	if ( wp_is_stream( $target ) ) {
1601		list( $wrapper, $target ) = explode( '://', $target, 2 );
1602	}
1603
1604	// From php.net/mkdir user contributed notes.
1605	$target = str_replace( '//', '/', $target );
1606
1607	// Put the wrapper back on the target.
1608	if ( $wrapper !== null ) {
1609		$target = $wrapper . '://' . $target;
1610	}
1611
1612	/*
1613	 * Safe mode fails with a trailing slash under certain PHP versions.
1614	 * Use rtrim() instead of untrailingslashit to avoid formatting.php dependency.
1615	 */
1616	$target = rtrim($target, '/');
1617	if ( empty($target) )
1618		$target = '/';
1619
1620	if ( file_exists( $target ) )
1621		return @is_dir( $target );
1622
1623	// We need to find the permissions of the parent folder that exists and inherit that.
1624	$target_parent = dirname( $target );
1625	while ( '.' != $target_parent && ! is_dir( $target_parent ) ) {
1626		$target_parent = dirname( $target_parent );
1627	}
1628
1629	// Get the permission bits.
1630	if ( $stat = @stat( $target_parent ) ) {
1631		$dir_perms = $stat['mode'] & 0007777;
1632	} else {
1633		$dir_perms = 0777;
1634	}
1635
1636	if ( @mkdir( $target, $dir_perms, true ) ) {
1637
1638		/*
1639		 * If a umask is set that modifies $dir_perms, we'll have to re-set
1640		 * the $dir_perms correctly with chmod()
1641		 */
1642		if ( $dir_perms != ( $dir_perms & ~umask() ) ) {
1643			$folder_parts = explode( '/', substr( $target, strlen( $target_parent ) + 1 ) );
1644			for ( $i = 1, $c = count( $folder_parts ); $i <= $c; $i++ ) {
1645				@chmod( $target_parent . '/' . implode( '/', array_slice( $folder_parts, 0, $i ) ), $dir_perms );
1646			}
1647		}
1648
1649		return true;
1650	}
1651
1652	return false;
1653}
1654
1655/**
1656 * Test if a give filesystem path is absolute.
1657 *
1658 * For example, '/foo/bar', or 'c:\windows'.
1659 *
1660 * @since 2.5.0
1661 *
1662 * @param string $path File path.
1663 * @return bool True if path is absolute, false is not absolute.
1664 */
1665function path_is_absolute( $path ) {
1666	/*
1667	 * This is definitive if true but fails if $path does not exist or contains
1668	 * a symbolic link.
1669	 */
1670	if ( realpath($path) == $path )
1671		return true;
1672
1673	if ( strlen($path) == 0 || $path[0] == '.' )
1674		return false;
1675
1676	// Windows allows absolute paths like this.
1677	if ( preg_match('#^[a-zA-Z]:\\\\#', $path) )
1678		return true;
1679
1680	// A path starting with / or \ is absolute; anything else is relative.
1681	return ( $path[0] == '/' || $path[0] == '\\' );
1682}
1683
1684/**
1685 * Join two filesystem paths together.
1686 *
1687 * For example, 'give me $path relative to $base'. If the $path is absolute,
1688 * then it the full path is returned.
1689 *
1690 * @since 2.5.0
1691 *
1692 * @param string $base Base path.
1693 * @param string $path Path relative to $base.
1694 * @return string The path with the base or absolute path.
1695 */
1696function path_join( $base, $path ) {
1697	if ( path_is_absolute($path) )
1698		return $path;
1699
1700	return rtrim($base, '/') . '/' . ltrim($path, '/');
1701}
1702
1703/**
1704 * Normalize a filesystem path.
1705 *
1706 * On windows systems, replaces backslashes with forward slashes
1707 * and forces upper-case drive letters.
1708 * Allows for two leading slashes for Windows network shares, but
1709 * ensures that all other duplicate slashes are reduced to a single.
1710 *
1711 * @since 3.9.0
1712 * @since 4.4.0 Ensures upper-case drive letters on Windows systems.
1713 * @since 4.5.0 Allows for Windows network shares.
1714 *
1715 * @param string $path Path to normalize.
1716 * @return string Normalized path.
1717 */
1718function wp_normalize_path( $path ) {
1719	$path = str_replace( '\\', '/', $path );
1720	$path = preg_replace( '|(?<=.)/+|', '/', $path );
1721	if ( ':' === substr( $path, 1, 1 ) ) {
1722		$path = ucfirst( $path );
1723	}
1724	return $path;
1725}
1726
1727/**
1728 * Determine a writable directory for temporary files.
1729 *
1730 * Function's preference is the return value of sys_get_temp_dir(),
1731 * followed by your PHP temporary upload directory, followed by WP_CONTENT_DIR,
1732 * before finally defaulting to /tmp/
1733 *
1734 * In the event that this function does not find a writable location,
1735 * It may be overridden by the WP_TEMP_DIR constant in your wp-config.php file.
1736 *
1737 * @since 2.5.0
1738 *
1739 * @staticvar string $temp
1740 *
1741 * @return string Writable temporary directory.
1742 */
1743function get_temp_dir() {
1744	static $temp = '';
1745	if ( defined('WP_TEMP_DIR') )
1746		return trailingslashit(WP_TEMP_DIR);
1747
1748	if ( $temp )
1749		return trailingslashit( $temp );
1750
1751	if ( function_exists('sys_get_temp_dir') ) {
1752		$temp = sys_get_temp_dir();
1753		if ( @is_dir( $temp ) && wp_is_writable( $temp ) )
1754			return trailingslashit( $temp );
1755	}
1756
1757	$temp = ini_get('upload_tmp_dir');
1758	if ( @is_dir( $temp ) && wp_is_writable( $temp ) )
1759		return trailingslashit( $temp );
1760
1761	$temp = WP_CONTENT_DIR . '/';
1762	if ( is_dir( $temp ) && wp_is_writable( $temp ) )
1763		return $temp;
1764
1765	return '/tmp/';
1766}
1767
1768/**
1769 * Determine if a directory is writable.
1770 *
1771 * This function is used to work around certain ACL issues in PHP primarily
1772 * affecting Windows Servers.
1773 *
1774 * @since 3.6.0
1775 *
1776 * @see win_is_writable()
1777 *
1778 * @param string $path Path to check for write-ability.
1779 * @return bool Whether the path is writable.
1780 */
1781function wp_is_writable( $path ) {
1782	if ( 'WIN' === strtoupper( substr( PHP_OS, 0, 3 ) ) )
1783		return win_is_writable( $path );
1784	else
1785		return @is_writable( $path );
1786}
1787
1788/**
1789 * Workaround for Windows bug in is_writable() function
1790 *
1791 * PHP has issues with Windows ACL's for determine if a
1792 * directory is writable or not, this works around them by
1793 * checking the ability to open files rather than relying
1794 * upon PHP to interprate the OS ACL.
1795 *
1796 * @since 2.8.0
1797 *
1798 * @see https://bugs.php.net/bug.php?id=27609
1799 * @see https://bugs.php.net/bug.php?id=30931
1800 *
1801 * @param string $path Windows path to check for write-ability.
1802 * @return bool Whether the path is writable.
1803 */
1804function win_is_writable( $path ) {
1805
1806	if ( $path[strlen( $path ) - 1] == '/' ) { // if it looks like a directory, check a random file within the directory
1807		return win_is_writable( $path . uniqid( mt_rand() ) . '.tmp');
1808	} elseif ( is_dir( $path ) ) { // If it's a directory (and not a file) check a random file within the directory
1809		return win_is_writable( $path . '/' . uniqid( mt_rand() ) . '.tmp' );
1810	}
1811	// check tmp file for read/write capabilities
1812	$should_delete_tmp_file = !file_exists( $path );
1813	$f = @fopen( $path, 'a' );
1814	if ( $f === false )
1815		return false;
1816	fclose( $f );
1817	if ( $should_delete_tmp_file )
1818		unlink( $path );
1819	return true;
1820}
1821
1822/**
1823 * Retrieves uploads directory information.
1824 *
1825 * Same as wp_upload_dir() but "light weight" as it doesn't attempt to create the uploads directory.
1826 * Intended for use in themes, when only 'basedir' and 'baseurl' are needed, generally in all cases
1827 * when not uploading files.
1828 *
1829 * @since 4.5.0
1830 *
1831 * @see wp_upload_dir()
1832 *
1833 * @return array See wp_upload_dir() for description.
1834 */
1835function wp_get_upload_dir() {
1836	return wp_upload_dir( null, false );
1837}
1838
1839/**
1840 * Get an array containing the current upload directory's path and url.
1841 *
1842 * Checks the 'upload_path' option, which should be from the web root folder,
1843 * and if it isn't empty it will be used. If it is empty, then the path will be
1844 * 'WP_CONTENT_DIR/uploads'. If the 'UPLOADS' constant is defined, then it will
1845 * override the 'upload_path' option and 'WP_CONTENT_DIR/uploads' path.
1846 *
1847 * The upload URL path is set either by the 'upload_url_path' option or by using
1848 * the 'WP_CONTENT_URL' constant and appending '/uploads' to the path.
1849 *
1850 * If the 'uploads_use_yearmonth_folders' is set to true (checkbox if checked in
1851 * the administration settings panel), then the time will be used. The format
1852 * will be year first and then month.
1853 *
1854 * If the path couldn't be created, then an error will be returned with the key
1855 * 'error' containing the error message. The error suggests that the parent
1856 * directory is not writable by the server.
1857 *
1858 * On success, the returned array will have many indices:
1859 * 'path' - base directory and sub directory or full path to upload directory.
1860 * 'url' - base url and sub directory or absolute URL to upload directory.
1861 * 'subdir' - sub directory if uploads use year/month folders option is on.
1862 * 'basedir' - path without subdir.
1863 * 'baseurl' - URL path without subdir.
1864 * 'error' - false or error message.
1865 *
1866 * @since 2.0.0
1867 * @uses _wp_upload_dir()
1868 *
1869 * @param string $time Optional. Time formatted in 'yyyy/mm'. Default null.
1870 * @param bool   $create_dir Optional. Whether to check and create the uploads directory.
1871 *                           Default true for backward compatibility.
1872 * @param bool   $refresh_cache Optional. Whether to refresh the cache. Default false.
1873 * @return array See above for description.
1874 */
1875function wp_upload_dir( $time = null, $create_dir = true, $refresh_cache = false ) {
1876	static $cache = array(), $tested_paths = array();
1877
1878	$key = sprintf( '%d-%s', get_current_blog_id(), (string) $time );
1879
1880	if ( $refresh_cache || empty( $cache[ $key ] ) ) {
1881		$cache[ $key ] = _wp_upload_dir( $time );
1882	}
1883
1884	/**
1885	 * Filters the uploads directory data.
1886	 *
1887	 * @since 2.0.0
1888	 *
1889	 * @param array $uploads Array of upload directory data with keys of 'path',
1890	 *                       'url', 'subdir, 'basedir', and 'error'.
1891	 */
1892	$uploads = apply_filters( 'upload_dir', $cache[ $key ] );
1893
1894	if ( $create_dir ) {
1895		$path = $uploads['path'];
1896
1897		if ( array_key_exists( $path, $tested_paths ) ) {
1898			$uploads['error'] = $tested_paths[ $path ];
1899		} else {
1900			if ( ! wp_mkdir_p( $path ) ) {
1901				if ( 0 === strpos( $uploads['basedir'], ABSPATH ) ) {
1902					$error_path = str_replace( ABSPATH, '', $uploads['basedir'] ) . $uploads['subdir'];
1903				} else {
1904					$error_path = basename( $uploads['basedir'] ) . $uploads['subdir'];
1905				}
1906
1907				$uploads['error'] = sprintf(
1908					/* translators: %s: directory path */
1909					__( 'Unable to create directory %s. Is its parent directory writable by the server?' ),
1910					esc_html( $error_path )
1911				);
1912			}
1913
1914			$tested_paths[ $path ] = $uploads['error'];
1915		}
1916	}
1917
1918	return $uploads;
1919}
1920
1921/**
1922 * A non-filtered, non-cached version of wp_upload_dir() that doesn't check the path.
1923 *
1924 * @access private
1925 *
1926 * @param string $time Optional. Time formatted in 'yyyy/mm'. Default null.
1927 * @return array See wp_upload_dir()
1928 */
1929function _wp_upload_dir( $time = null ) {
1930	$siteurl = get_option( 'siteurl' );
1931	$upload_path = trim( get_option( 'upload_path' ) );
1932
1933	if ( empty( $upload_path ) || 'wp-content/uploads' == $upload_path ) {
1934		$dir = WP_CONTENT_DIR . '/uploads';
1935	} elseif ( 0 !== strpos( $upload_path, ABSPATH ) ) {
1936		// $dir is absolute, $upload_path is (maybe) relative to ABSPATH
1937		$dir = path_join( ABSPATH, $upload_path );
1938	} else {
1939		$dir = $upload_path;
1940	}
1941
1942	if ( !$url = get_option( 'upload_url_path' ) ) {
1943		if ( empty($upload_path) || ( 'wp-content/uploads' == $upload_path ) || ( $upload_path == $dir ) )
1944			$url = WP_CONTENT_URL . '/uploads';
1945		else
1946			$url = trailingslashit( $siteurl ) . $upload_path;
1947	}
1948
1949	/*
1950	 * Honor the value of UPLOADS. This happens as long as ms-files rewriting is disabled.
1951	 * We also sometimes obey UPLOADS when rewriting is enabled -- see the next block.
1952	 */
1953	if ( defined( 'UPLOADS' ) && ! ( is_multisite() && get_site_option( 'ms_files_rewriting' ) ) ) {
1954		$dir = ABSPATH . UPLOADS;
1955		$url = trailingslashit( $siteurl ) . UPLOADS;
1956	}
1957
1958	// If multisite (and if not the main site in a post-MU network)
1959	if ( is_multisite() && ! ( is_main_network() && is_main_site() && defined( 'MULTISITE' ) ) ) {
1960
1961		if ( ! get_site_option( 'ms_files_rewriting' ) ) {
1962			/*
1963			 * If ms-files rewriting is disabled (networks created post-3.5), it is fairly
1964			 * straightforward: Append sites/%d if we're not on the main site (for post-MU
1965			 * networks). (The extra directory prevents a four-digit ID from conflicting with
1966			 * a year-based directory for the main site. But if a MU-era network has disabled
1967			 * ms-files rewriting manually, they don't need the extra directory, as they never
1968			 * had wp-content/uploads for the main site.)
1969			 */
1970
1971			if ( defined( 'MULTISITE' ) )
1972				$ms_dir = '/sites/' . get_current_blog_id();
1973			else
1974				$ms_dir = '/' . get_current_blog_id();
1975
1976			$dir .= $ms_dir;
1977			$url .= $ms_dir;
1978
1979		} elseif ( defined( 'UPLOADS' ) && ! ms_is_switched() ) {
1980			/*
1981			 * Handle the old-form ms-files.php rewriting if the network still has that enabled.
1982			 * When ms-files rewriting is enabled, then we only listen to UPLOADS when:
1983			 * 1) We are not on the main site in a post-MU network, as wp-content/uploads is used
1984			 *    there, and
1985			 * 2) We are not switched, as ms_upload_constants() hardcodes these constants to reflect
1986			 *    the original blog ID.
1987			 *
1988			 * Rather than UPLOADS, we actually use BLOGUPLOADDIR if it is set, as it is absolute.
1989			 * (And it will be set, see ms_upload_constants().) Otherwise, UPLOADS can be used, as
1990			 * as it is relative to ABSPATH. For the final piece: when UPLOADS is used with ms-files
1991			 * rewriting in multisite, the resulting URL is /files. (#WP22702 for background.)
1992			 */
1993
1994			if ( defined( 'BLOGUPLOADDIR' ) )
1995				$dir = untrailingslashit( BLOGUPLOADDIR );
1996			else
1997				$dir = ABSPATH . UPLOADS;
1998			$url = trailingslashit( $siteurl ) . 'files';
1999		}
2000	}
2001
2002	$basedir = $dir;
2003	$baseurl = $url;
2004
2005	$subdir = '';
2006	if ( get_option( 'uploads_use_yearmonth_folders' ) ) {
2007		// Generate the yearly and monthly dirs
2008		if ( !$time )
2009			$time = current_time( 'mysql' );
2010		$y = substr( $time, 0, 4 );
2011		$m = substr( $time, 5, 2 );
2012		$subdir = "/$y/$m";
2013	}
2014
2015	$dir .= $subdir;
2016	$url .= $subdir;
2017
2018	return array(
2019		'path'    => $dir,
2020		'url'     => $url,
2021		'subdir'  => $subdir,
2022		'basedir' => $basedir,
2023		'baseurl' => $baseurl,
2024		'error'   => false,
2025	);
2026}
2027
2028/**
2029 * Get a filename that is sanitized and unique for the given directory.
2030 *
2031 * If the filename is not unique, then a number will be added to the filename
2032 * before the extension, and will continue adding numbers until the filename is
2033 * unique.
2034 *
2035 * The callback is passed three parameters, the first one is the directory, the
2036 * second is the filename, and the third is the extension.
2037 *
2038 * @since 2.5.0
2039 *
2040 * @param string   $dir                      Directory.
2041 * @param string   $filename                 File name.
2042 * @param callable $unique_filename_callback Callback. Default null.
2043 * @return string New filename, if given wasn't unique.
2044 */
2045function wp_unique_filename( $dir, $filename, $unique_filename_callback = null ) {
2046	// Sanitize the file name before we begin processing.
2047	$filename = sanitize_file_name($filename);
2048
2049	// Separate the filename into a name and extension.
2050	$ext = pathinfo( $filename, PATHINFO_EXTENSION );
2051	$name = pathinfo( $filename, PATHINFO_BASENAME );
2052	if ( $ext ) {
2053		$ext = '.' . $ext;
2054	}
2055
2056	// Edge case: if file is named '.ext', treat as an empty name.
2057	if ( $name === $ext ) {
2058		$name = '';
2059	}
2060
2061	/*
2062	 * Increment the file number until we have a unique file to save in $dir.
2063	 * Use callback if supplied.
2064	 */
2065	if ( $unique_filename_callback && is_callable( $unique_filename_callback ) ) {
2066		$filename = call_user_func( $unique_filename_callback, $dir, $name, $ext );
2067	} else {
2068		$number = '';
2069
2070		// Change '.ext' to lower case.
2071		if ( $ext && strtolower($ext) != $ext ) {
2072			$ext2 = strtolower($ext);
2073			$filename2 = preg_replace( '|' . preg_quote($ext) . '$|', $ext2, $filename );
2074
2075			// Check for both lower and upper case extension or image sub-sizes may be overwritten.
2076			while ( file_exists($dir . "/$filename") || file_exists($dir . "/$filename2") ) {
2077				$new_number = $number + 1;
2078				$filename = str_replace( array( "-$number$ext", "$number$ext" ), "-$new_number$ext", $filename );
2079				$filename2 = str_replace( array( "-$number$ext2", "$number$ext2" ), "-$new_number$ext2", $filename2 );
2080				$number = $new_number;
2081			}
2082
2083			/**
2084			 * Filters the result when generating a unique file name.
2085			 *
2086			 * @since 4.5.0
2087			 *
2088			 * @param string        $filename                 Unique file name.
2089			 * @param string        $ext                      File extension, eg. ".png".
2090			 * @param string        $dir                      Directory path.
2091			 * @param callable|null $unique_filename_callback Callback function that generates the unique file name.
2092			 */
2093			return apply_filters( 'wp_unique_filename', $filename2, $ext, $dir, $unique_filename_callback );
2094		}
2095
2096		while ( file_exists( $dir . "/$filename" ) ) {
2097			if ( '' == "$number$ext" ) {
2098				$filename = "$filename-" . ++$number;
2099			} else {
2100				$filename = str_replace( array( "-$number$ext", "$number$ext" ), "-" . ++$number . $ext, $filename );
2101			}
2102		}
2103	}
2104
2105	/** This filter is documented in wp-includes/functions.php */
2106	return apply_filters( 'wp_unique_filename', $filename, $ext, $dir, $unique_filename_callback );
2107}
2108
2109/**
2110 * Create a file in the upload folder with given content.
2111 *
2112 * If there is an error, then the key 'error' will exist with the error message.
2113 * If success, then the key 'file' will have the unique file path, the 'url' key
2114 * will have the link to the new file. and the 'error' key will be set to false.
2115 *
2116 * This function will not move an uploaded file to the upload folder. It will
2117 * create a new file with the content in $bits parameter. If you move the upload
2118 * file, read the content of the uploaded file, and then you can give the
2119 * filename and content to this function, which will add it to the upload
2120 * folder.
2121 *
2122 * The permissions will be set on the new file automatically by this function.
2123 *
2124 * @since 2.0.0
2125 *
2126 * @param string       $name       Filename.
2127 * @param null|string  $deprecated Never used. Set to null.
2128 * @param mixed        $bits       File content
2129 * @param string       $time       Optional. Time formatted in 'yyyy/mm'. Default null.
2130 * @return array
2131 */
2132function wp_upload_bits( $name, $deprecated, $bits, $time = null ) {
2133	if ( !empty( $deprecated ) )
2134		_deprecated_argument( __FUNCTION__, '2.0.0' );
2135
2136	if ( empty( $name ) )
2137		return array( 'error' => __( 'Empty filename' ) );
2138
2139	$wp_filetype = wp_check_filetype( $name );
2140	if ( ! $wp_filetype['ext'] && ! current_user_can( 'unfiltered_upload' ) )
2141		return array( 'error' => __( 'Invalid file type' ) );
2142
2143	$upload = wp_upload_dir( $time );
2144
2145	if ( $upload['error'] !== false )
2146		return $upload;
2147
2148	/**
2149	 * Filters whether to treat the upload bits as an error.
2150	 *
2151	 * Passing a non-array to the filter will effectively short-circuit preparing
2152	 * the upload bits, returning that value instead.
2153	 *
2154	 * @since 3.0.0
2155	 *
2156	 * @param mixed $upload_bits_error An array of upload bits data, or a non-array error to return.
2157	 */
2158	$upload_bits_error = apply_filters( 'wp_upload_bits', array( 'name' => $name, 'bits' => $bits, 'time' => $time ) );
2159	if ( !is_array( $upload_bits_error ) ) {
2160		$upload[ 'error' ] = $upload_bits_error;
2161		return $upload;
2162	}
2163
2164	$filename = wp_unique_filename( $upload['path'], $name );
2165
2166	$new_file = $upload['path'] . "/$filename";
2167	if ( ! wp_mkdir_p( dirname( $new_file ) ) ) {
2168		if ( 0 === strpos( $upload['basedir'], ABSPATH ) )
2169			$error_path = str_replace( ABSPATH, '', $upload['basedir'] ) . $upload['subdir'];
2170		else
2171			$error_path = basename( $upload['basedir'] ) . $upload['subdir'];
2172
2173		$message = sprintf(
2174			/* translators: %s: directory path */
2175			__( 'Unable to create directory %s. Is its parent directory writable by the server?' ),
2176			$error_path
2177		);
2178		return array( 'error' => $message );
2179	}
2180
2181	$ifp = @ fopen( $new_file, 'wb' );
2182	if ( ! $ifp )
2183		return array( 'error' => sprintf( __( 'Could not write file %s' ), $new_file ) );
2184
2185	@fwrite( $ifp, $bits );
2186	fclose( $ifp );
2187	clearstatcache();
2188
2189	// Set correct file permissions
2190	$stat = @ stat( dirname( $new_file ) );
2191	$perms = $stat['mode'] & 0007777;
2192	$perms = $perms & 0000666;
2193	@ chmod( $new_file, $perms );
2194	clearstatcache();
2195
2196	// Compute the URL
2197	$url = $upload['url'] . "/$filename";
2198
2199	/** This filter is documented in wp-admin/includes/file.php */
2200	return apply_filters( 'wp_handle_upload', array( 'file' => $new_file, 'url' => $url, 'type' => $wp_filetype['type'], 'error' => false ), 'sideload' );
2201}
2202
2203/**
2204 * Retrieve the file type based on the extension name.
2205 *
2206 * @since 2.5.0
2207 *
2208 * @param string $ext The extension to search.
2209 * @return string|void The file type, example: audio, video, document, spreadsheet, etc.
2210 */
2211function wp_ext2type( $ext ) {
2212	$ext = strtolower( $ext );
2213
2214	$ext2type = wp_get_ext_types();
2215	foreach ( $ext2type as $type => $exts )
2216		if ( in_array( $ext, $exts ) )
2217			return $type;
2218}
2219
2220/**
2221 * Retrieve the file type from the file name.
2222 *
2223 * You can optionally define the mime array, if needed.
2224 *
2225 * @since 2.0.4
2226 *
2227 * @param string $filename File name or path.
2228 * @param array  $mimes    Optional. Key is the file extension with value as the mime type.
2229 * @return array Values with extension first and mime type.
2230 */
2231function wp_check_filetype( $filename, $mimes = null ) {
2232	if ( empty($mimes) )
2233		$mimes = get_allowed_mime_types();
2234	$type = false;
2235	$ext = false;
2236
2237	foreach ( $mimes as $ext_preg => $mime_match ) {
2238		$ext_preg = '!\.(' . $ext_preg . ')$!i';
2239		if ( preg_match( $ext_preg, $filename, $ext_matches ) ) {
2240			$type = $mime_match;
2241			$ext = $ext_matches[1];
2242			break;
2243		}
2244	}
2245
2246	return compact( 'ext', 'type' );
2247}
2248
2249/**
2250 * Attempt to determine the real file type of a file.
2251 *
2252 * If unable to, the file name extension will be used to determine type.
2253 *
2254 * If it's determined that the extension does not match the file's real type,
2255 * then the "proper_filename" value will be set with a proper filename and extension.
2256 *
2257 * Currently this function only supports renaming images validated via wp_get_image_mime().
2258 *
2259 * @since 3.0.0
2260 *
2261 * @param string $file     Full path to the file.
2262 * @param string $filename The name of the file (may differ from $file due to $file being
2263 *                         in a tmp directory).
2264 * @param array   $mimes   Optional. Key is the file extension with value as the mime type.
2265 * @return array Values for the extension, MIME, and either a corrected filename or false
2266 *               if original $filename is valid.
2267 */
2268function wp_check_filetype_and_ext( $file, $filename, $mimes = null ) {
2269	$proper_filename = false;
2270
2271	// Do basic extension validation and MIME mapping
2272	$wp_filetype = wp_check_filetype( $filename, $mimes );
2273	$ext = $wp_filetype['ext'];
2274	$type = $wp_filetype['type'];
2275
2276	// We can't do any further validation without a file to work with
2277	if ( ! file_exists( $file ) ) {
2278		return compact( 'ext', 'type', 'proper_filename' );
2279	}
2280
2281	// Validate image types.
2282	if ( $type && 0 === strpos( $type, 'image/' ) ) {
2283
2284		// Attempt to figure out what type of image it actually is
2285		$real_mime = wp_get_image_mime( $file );
2286
2287		if ( ! $real_mime ) {
2288			$type = $ext = false;
2289		} elseif ( $real_mime != $type ) {
2290			/**
2291			 * Filters the list mapping image mime types to their respective extensions.
2292			 *
2293			 * @since 3.0.0
2294			 *
2295			 * @param  array $mime_to_ext Array of image mime types and their matching extensions.
2296			 */
2297			$mime_to_ext = apply_filters( 'getimagesize_mimes_to_exts', array(
2298				'image/jpeg' => 'jpg',
2299				'image/png'  => 'png',
2300				'image/gif'  => 'gif',
2301				'image/bmp'  => 'bmp',
2302				'image/tiff' => 'tif',
2303			) );
2304
2305			// Replace whatever is after the last period in the filename with the correct extension
2306			if ( ! empty( $mime_to_ext[ $real_mime ] ) ) {
2307				$filename_parts = explode( '.', $filename );
2308				array_pop( $filename_parts );
2309				$filename_parts[] = $mime_to_ext[ $real_mime ];
2310				$new_filename = implode( '.', $filename_parts );
2311
2312				if ( $new_filename != $filename ) {
2313					$proper_filename = $new_filename; // Mark that it changed
2314				}
2315				// Redefine the extension / MIME
2316				$wp_filetype = wp_check_filetype( $new_filename, $mimes );
2317				$ext = $wp_filetype['ext'];
2318				$type = $wp_filetype['type'];
2319			} else {
2320				$type = $ext = false;
2321			}
2322		}
2323	} elseif ( function_exists( 'finfo_file' ) ) {
2324		// Use finfo_file if available to validate non-image files.
2325		$finfo = finfo_open( FILEINFO_MIME_TYPE );
2326		$real_mime = finfo_file( $finfo, $file );
2327		finfo_close( $finfo );
2328
2329		// If the extension does not match the file's real type, return false.
2330		if ( $real_mime !== $type ) {
2331			$type = $ext = false;
2332		}
2333	}
2334
2335	/**
2336	 * Filters the "real" file type of the given file.
2337	 *
2338	 * @since 3.0.0
2339	 *
2340	 * @param array  $wp_check_filetype_and_ext File data array containing 'ext', 'type', and
2341	 *                                          'proper_filename' keys.
2342	 * @param string $file                      Full path to the file.
2343	 * @param string $filename                  The name of the file (may differ from $file due to
2344	 *                                          $file being in a tmp directory).
2345	 * @param array  $mimes                     Key is the file extension with value as the mime type.
2346	 */
2347	return apply_filters( 'wp_check_filetype_and_ext', compact( 'ext', 'type', 'proper_filename' ), $file, $filename, $mimes );
2348}
2349
2350/**
2351 * Returns the real mime type of an image file.
2352 *
2353 * This depends on exif_imagetype() or getimagesize() to determine real mime types.
2354 *
2355 * @since 4.7.1
2356 *
2357 * @param string $file Full path to the file.
2358 * @return string|false The actual mime type or false if the type cannot be determined.
2359 */
2360function wp_get_image_mime( $file ) {
2361	/*
2362	 * Use exif_imagetype() to check the mimetype if available or fall back to
2363	 * getimagesize() if exif isn't avaialbe. If either function throws an Exception
2364	 * we assume the file could not be validated.
2365	 */
2366	try {
2367		if ( is_callable( 'exif_imagetype' ) ) {
2368			$mime = image_type_to_mime_type( exif_imagetype( $file ) );
2369		} elseif ( function_exists( 'getimagesize' ) ) {
2370			$imagesize = getimagesize( $file );
2371			$mime = ( isset( $imagesize['mime'] ) ) ? $imagesize['mime'] : false;
2372		} else {
2373			$mime = false;
2374		}
2375	} catch ( Exception $e ) {
2376		$mime = false;
2377	}
2378
2379	return $mime;
2380}
2381
2382/**
2383 * Retrieve list of mime types and file extensions.
2384 *
2385 * @since 3.5.0
2386 * @since 4.2.0 Support was added for GIMP (xcf) files.
2387 *
2388 * @return array Array of mime types keyed by the file extension regex corresponding to those types.
2389 */
2390function wp_get_mime_types() {
2391	/**
2392	 * Filters the list of mime types and file extensions.
2393	 *
2394	 * This filter should be used to add, not remove, mime types. To remove
2395	 * mime types, use the {@see 'upload_mimes'} filter.
2396	 *
2397	 * @since 3.5.0
2398	 *
2399	 * @param array $wp_get_mime_types Mime types keyed by the file extension regex
2400	 *                                 corresponding to those types.
2401	 */
2402	return apply_filters( 'mime_types', array(
2403	// Image formats.
2404	'jpg|jpeg|jpe' => 'image/jpeg',
2405	'gif' => 'image/gif',
2406	'png' => 'image/png',
2407	'bmp' => 'image/bmp',
2408	'tiff|tif' => 'image/tiff',
2409	'ico' => 'image/x-icon',
2410	// Video formats.
2411	'asf|asx' => 'video/x-ms-asf',
2412	'wmv' => 'video/x-ms-wmv',
2413	'wmx' => 'video/x-ms-wmx',
2414	'wm' => 'video/x-ms-wm',
2415	'avi' => 'video/avi',
2416	'divx' => 'video/divx',
2417	'flv' => 'video/x-flv',
2418	'mov|qt' => 'video/quicktime',
2419	'mpeg|mpg|mpe' => 'video/mpeg',
2420	'mp4|m4v' => 'video/mp4',
2421	'ogv' => 'video/ogg',
2422	'webm' => 'video/webm',
2423	'mkv' => 'video/x-matroska',
2424	'3gp|3gpp' => 'video/3gpp', // Can also be audio
2425	'3g2|3gp2' => 'video/3gpp2', // Can also be audio
2426	// Text formats.
2427	'txt|asc|c|cc|h|srt' => 'text/plain',
2428	'csv' => 'text/csv',
2429	'tsv' => 'text/tab-separated-values',
2430	'ics' => 'text/calendar',
2431	'rtx' => 'text/richtext',
2432	'css' => 'text/css',
2433	'htm|html' => 'text/html',
2434	'vtt' => 'text/vtt',
2435	'dfxp' => 'application/ttaf+xml',
2436	// Audio formats.
2437	'mp3|m4a|m4b' => 'audio/mpeg',
2438	'ra|ram' => 'audio/x-realaudio',
2439	'wav' => 'audio/wav',
2440	'ogg|oga' => 'audio/ogg',
2441	'mid|midi' => 'audio/midi',
2442	'wma' => 'audio/x-ms-wma',
2443	'wax' => 'audio/x-ms-wax',
2444	'mka' => 'audio/x-matroska',
2445	// Misc application formats.
2446	'rtf' => 'application/rtf',
2447	'js' => 'application/javascript',
2448	'pdf' => 'application/pdf',
2449	'swf' => 'application/x-shockwave-flash',
2450	'class' => 'application/java',
2451	'tar' => 'application/x-tar',
2452	'zip' => 'application/zip',
2453	'gz|gzip' => 'application/x-gzip',
2454	'rar' => 'application/rar',
2455	'7z' => 'application/x-7z-compressed',
2456	'exe' => 'application/x-msdownload',
2457	'psd' => 'application/octet-stream',
2458	'xcf' => 'application/octet-stream',
2459	// MS Office formats.
2460	'doc' => 'application/msword',
2461	'pot|pps|ppt' => 'application/vnd.ms-powerpoint',
2462	'wri' => 'application/vnd.ms-write',
2463	'xla|xls|xlt|xlw' => 'application/vnd.ms-excel',
2464	'mdb' => 'application/vnd.ms-access',
2465	'mpp' => 'application/vnd.ms-project',
2466	'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
2467	'docm' => 'application/vnd.ms-word.document.macroEnabled.12',
2468	'dotx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
2469	'dotm' => 'application/vnd.ms-word.template.macroEnabled.12',
2470	'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
2471	'xlsm' => 'application/vnd.ms-excel.sheet.macroEnabled.12',
2472	'xlsb' => 'application/vnd.ms-excel.sheet.binary.macroEnabled.12',
2473	'xltx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
2474	'xltm' => 'application/vnd.ms-excel.template.macroEnabled.12',
2475	'xlam' => 'application/vnd.ms-excel.addin.macroEnabled.12',
2476	'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
2477	'pptm' => 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
2478	'ppsx' => 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
2479	'ppsm' => 'application/vnd.ms-powerpoint.slideshow.macroEnabled.12',
2480	'potx' => 'application/vnd.openxmlformats-officedocument.presentationml.template',
2481	'potm' => 'application/vnd.ms-powerpoint.template.macroEnabled.12',
2482	'ppam' => 'application/vnd.ms-powerpoint.addin.macroEnabled.12',
2483	'sldx' => 'application/vnd.openxmlformats-officedocument.presentationml.slide',
2484	'sldm' => 'application/vnd.ms-powerpoint.slide.macroEnabled.12',
2485	'onetoc|onetoc2|onetmp|onepkg' => 'application/onenote',
2486	'oxps' => 'application/oxps',
2487	'xps' => 'application/vnd.ms-xpsdocument',
2488	// OpenOffice formats.
2489	'odt' => 'application/vnd.oasis.opendocument.text',
2490	'odp' => 'application/vnd.oasis.opendocument.presentation',
2491	'ods' => 'application/vnd.oasis.opendocument.spreadsheet',
2492	'odg' => 'application/vnd.oasis.opendocument.graphics',
2493	'odc' => 'application/vnd.oasis.opendocument.chart',
2494	'odb' => 'application/vnd.oasis.opendocument.database',
2495	'odf' => 'application/vnd.oasis.opendocument.formula',
2496	// WordPerfect formats.
2497	'wp|wpd' => 'application/wordperfect',
2498	// iWork formats.
2499	'key' => 'application/vnd.apple.keynote',
2500	'numbers' => 'application/vnd.apple.numbers',
2501	'pages' => 'application/vnd.apple.pages',
2502	) );
2503}
2504
2505/**
2506 * Retrieves the list of common file extensions and their types.
2507 *
2508 * @since 4.6.0
2509 *
2510 * @return array Array of file extensions types keyed by the type of file.
2511 */
2512function wp_get_ext_types() {
2513
2514	/**
2515	 * Filters file type based on the extension name.
2516	 *
2517	 * @since 2.5.0
2518	 *
2519	 * @see wp_ext2type()
2520	 *
2521	 * @param array $ext2type Multi-dimensional array with extensions for a default set
2522	 *                        of file types.
2523	 */
2524	return apply_filters( 'ext2type', array(
2525		'image'       => array( 'jpg', 'jpeg', 'jpe',  'gif',  'png',  'bmp',   'tif',  'tiff', 'ico' ),
2526		'audio'       => array( 'aac', 'ac3',  'aif',  'aiff', 'm3a',  'm4a',   'm4b',  'mka',  'mp1',  'mp2',  'mp3', 'ogg', 'oga', 'ram', 'wav', 'wma' ),
2527		'video'       => array( '3g2',  '3gp', '3gpp', 'asf', 'avi',  'divx', 'dv',   'flv',  'm4v',   'mkv',  'mov',  'mp4',  'mpeg', 'mpg', 'mpv', 'ogm', 'ogv', 'qt',  'rm', 'vob', 'wmv' ),
2528		'document'    => array( 'doc', 'docx', 'docm', 'dotm', 'odt',  'pages', 'pdf',  'xps',  'oxps', 'rtf',  'wp', 'wpd', 'psd', 'xcf' ),
2529		'spreadsheet' => array( 'numbers',     'ods',  'xls',  'xlsx', 'xlsm',  'xlsb' ),
2530		'interactive' => array( 'swf', 'key',  'ppt',  'pptx', 'pptm', 'pps',   'ppsx', 'ppsm', 'sldx', 'sldm', 'odp' ),
2531		'text'        => array( 'asc', 'csv',  'tsv',  'txt' ),
2532		'archive'     => array( 'bz2', 'cab',  'dmg',  'gz',   'rar',  'sea',   'sit',  'sqx',  'tar',  'tgz',  'zip', '7z' ),
2533		'code'        => array( 'css', 'htm',  'html', 'php',  'js' ),
2534	) );
2535}
2536
2537/**
2538 * Retrieve list of allowed mime types and file extensions.
2539 *
2540 * @since 2.8.6
2541 *
2542 * @param int|WP_User $user Optional. User to check. Defaults to current user.
2543 * @return array Array of mime types keyed by the file extension regex corresponding
2544 *               to those types.
2545 */
2546function get_allowed_mime_types( $user = null ) {
2547	$t = wp_get_mime_types();
2548
2549	unset( $t['swf'], $t['exe'] );
2550	if ( function_exists( 'current_user_can' ) )
2551		$unfiltered = $user ? user_can( $user, 'unfiltered_html' ) : current_user_can( 'unfiltered_html' );
2552
2553	if ( empty( $unfiltered ) )
2554		unset( $t['htm|html'] );
2555
2556	/**
2557	 * Filters list of allowed mime types and file extensions.
2558	 *
2559	 * @since 2.0.0
2560	 *
2561	 * @param array            $t    Mime types keyed by the file extension regex corresponding to
2562	 *                               those types. 'swf' and 'exe' removed from full list. 'htm|html' also
2563	 *                               removed depending on '$user' capabilities.
2564	 * @param int|WP_User|null $user User ID, User object or null if not provided (indicates current user).
2565	 */
2566	return apply_filters( 'upload_mimes', $t, $user );
2567}
2568
2569/**
2570 * Display "Are You Sure" message to confirm the action being taken.
2571 *
2572 * If the action has the nonce explain message, then it will be displayed
2573 * along with the "Are you sure?" message.
2574 *
2575 * @since 2.0.4
2576 *
2577 * @param string $action The nonce action.
2578 */
2579function wp_nonce_ays( $action ) {
2580	if ( 'log-out' == $action ) {
2581		$html = sprintf(
2582			/* translators: %s: site name */
2583			__( 'You are attempting to log out of %s' ),
2584			get_bloginfo( 'name' )
2585		);
2586		$html .= '</p><p>';
2587		$redirect_to = isset( $_REQUEST['redirect_to'] ) ? $_REQUEST['redirect_to'] : '';
2588		$html .= sprintf(
2589			/* translators: %s: logout URL */
2590			__( 'Do you really want to <a href="%s">log out</a>?' ),
2591			wp_logout_url( $redirect_to )
2592		);
2593	} else {
2594		$html = __( 'Are you sure you want to do this?' );
2595		if ( wp_get_referer() ) {
2596			$html .= '</p><p>';
2597			$html .= sprintf( '<a href="%s">%s</a>',
2598				esc_url( remove_query_arg( 'updated', wp_get_referer() ) ),
2599				__( 'Please try again.' )
2600			);
2601		}
2602	}
2603
2604	wp_die( $html, __( 'WordPress Failure Notice' ), 403 );
2605}
2606
2607/**
2608 * Kill WordPress execution and display HTML message with error message.
2609 *
2610 * This function complements the `die()` PHP function. The difference is that
2611 * HTML will be displayed to the user. It is recommended to use this function
2612 * only when the execution should not continue any further. It is not recommended
2613 * to call this function very often, and try to handle as many errors as possible
2614 * silently or more gracefully.
2615 *
2616 * As a shorthand, the desired HTTP response code may be passed as an integer to
2617 * the `$title` parameter (the default title would apply) or the `$args` parameter.
2618 *
2619 * @since 2.0.4
2620 * @since 4.1.0 The `$title` and `$args` parameters were changed to optionally accept
2621 *              an integer to be used as the response code.
2622 *
2623 * @param string|WP_Error  $message Optional. Error message. If this is a WP_Error object,
2624 *                                  and not an Ajax or XML-RPC request, the error's messages are used.
2625 *                                  Default empty.
2626 * @param string|int       $title   Optional. Error title. If `$message` is a `WP_Error` object,
2627 *                                  error data with the key 'title' may be used to specify the title.
2628 *                                  If `$title` is an integer, then it is treated as the response
2629 *                                  code. Default empty.
2630 * @param string|array|int $args {
2631 *     Optional. Arguments to control behavior. If `$args` is an integer, then it is treated
2632 *     as the response code. Default empty array.
2633 *
2634 *     @type int    $response       The HTTP response code. Default 200 for Ajax requests, 500 otherwise.
2635 *     @type bool   $back_link      Whether to include a link to go back. Default false.
2636 *     @type string $text_direction The text direction. This is only useful internally, when WordPress
2637 *                                  is still loading and the site's locale is not set up yet. Accepts 'rtl'.
2638 *                                  Default is the value of is_rtl().
2639 * }
2640 */
2641function wp_die( $message = '', $title = '', $args = array() ) {
2642
2643	if ( is_int( $args ) ) {
2644		$args = array( 'response' => $args );
2645	} elseif ( is_int( $title ) ) {
2646		$args  = array( 'response' => $title );
2647		$title = '';
2648	}
2649
2650	if ( wp_doing_ajax() ) {
2651		/**
2652		 * Filters the callback for killing WordPress execution for Ajax requests.
2653		 *
2654		 * @since 3.4.0
2655		 *
2656		 * @param callable $function Callback function name.
2657		 */
2658		$function = apply_filters( 'wp_die_ajax_handler', '_ajax_wp_die_handler' );
2659	} elseif ( defined( 'XMLRPC_REQUEST' ) && XMLRPC_REQUEST ) {
2660		/**
2661		 * Filters the callback for killing WordPress execution for XML-RPC requests.
2662		 *
2663		 * @since 3.4.0
2664		 *
2665		 * @param callable $function Callback function name.
2666		 */
2667		$function = apply_filters( 'wp_die_xmlrpc_handler', '_xmlrpc_wp_die_handler' );
2668	} else {
2669		/**
2670		 * Filters the callback for killing WordPress execution for all non-Ajax, non-XML-RPC requests.
2671		 *
2672		 * @since 3.0.0
2673		 *
2674		 * @param callable $function Callback function name.
2675		 */
2676		$function = apply_filters( 'wp_die_handler', '_default_wp_die_handler' );
2677	}
2678
2679	call_user_func( $function, $message, $title, $args );
2680}
2681
2682/**
2683 * Kills WordPress execution and display HTML message with error message.
2684 *
2685 * This is the default handler for wp_die if you want a custom one for your
2686 * site then you can overload using the {@see 'wp_die_handler'} filter in wp_die().
2687 *
2688 * @since 3.0.0
2689 * @access private
2690 *
2691 * @param string|WP_Error $message Error message or WP_Error object.
2692 * @param string          $title   Optional. Error title. Default empty.
2693 * @param string|array    $args    Optional. Arguments to control behavior. Default empty array.
2694 */
2695function _default_wp_die_handler( $message, $title = '', $args = array() ) {
2696	$defaults = array( 'response' => 500 );
2697	$r = wp_parse_args($args, $defaults);
2698
2699	$have_gettext = function_exists('__');
2700
2701	if ( function_exists( 'is_wp_error' ) && is_wp_error( $message ) ) {
2702		if ( empty( $title ) ) {
2703			$error_data = $message->get_error_data();
2704			if ( is_array( $error_data ) && isset( $error_data['title'] ) )
2705				$title = $error_data['title'];
2706		}
2707		$errors = $message->get_error_messages();
2708		switch ( count( $errors ) ) {
2709		case 0 :
2710			$message = '';
2711			break;
2712		case 1 :
2713			$message = "<p>{$errors[0]}</p>";
2714			break;
2715		default :
2716			$message = "<ul>\n\t\t<li>" . join( "</li>\n\t\t<li>", $errors ) . "</li>\n\t</ul>";
2717			break;
2718		}
2719	} elseif ( is_string( $message ) ) {
2720		$message = "<p>$message</p>";
2721	}
2722
2723	if ( isset( $r['back_link'] ) && $r['back_link'] ) {
2724		$back_text = $have_gettext? __('&laquo; Back') : '&laquo; Back';
2725		$message .= "\n<p><a href='javascript:history.back()'>$back_text</a></p>";
2726	}
2727
2728	if ( ! did_action( 'admin_head' ) ) :
2729		if ( !headers_sent() ) {
2730			status_header( $r['response'] );
2731			nocache_headers();
2732			header( 'Content-Type: text/html; charset=utf-8' );
2733		}
2734
2735		if ( empty($title) )
2736			$title = $have_gettext ? __('WordPress &rsaquo; Error') : 'WordPress &rsaquo; Error';
2737
2738		$text_direction = 'ltr';
2739		if ( isset($r['text_direction']) && 'rtl' == $r['text_direction'] )
2740			$text_direction = 'rtl';
2741		elseif ( function_exists( 'is_rtl' ) && is_rtl() )
2742			$text_direction = 'rtl';
2743?>
2744<!DOCTYPE html>
2745<!-- 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
2746-->
2747<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'"; ?>>
2748<head>
2749	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
2750	<meta name="viewport" content="width=device-width">
2751	<?php
2752	if ( function_exists( 'wp_no_robots' ) ) {
2753		wp_no_robots();
2754	}
2755	?>
2756	<title><?php echo $title ?></title>
2757	<style type="text/css">
2758		html {
2759			background: #f1f1f1;
2760		}
2761		body {
2762			background: #fff;
2763			color: #444;
2764			font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif;
2765			margin: 2em auto;
2766			padding: 1em 2em;
2767			max-width: 700px;
2768			-webkit-box-shadow: 0 1px 3px rgba(0,0,0,0.13);
2769			box-shadow: 0 1px 3px rgba(0,0,0,0.13);
2770		}
2771		h1 {
2772			border-bottom: 1px solid #dadada;
2773			clear: both;
2774			color: #666;
2775			font-size: 24px;
2776			margin: 30px 0 0 0;
2777			padding: 0;
2778			padding-bottom: 7px;
2779		}
2780		#error-page {
2781			margin-top: 50px;
2782		}
2783		#error-page p {
2784			font-size: 14px;
2785			line-height: 1.5;
2786			margin: 25px 0 20px;
2787		}
2788		#error-page code {
2789			font-family: Consolas, Monaco, monospace;
2790		}
2791		ul li {
2792			margin-bottom: 10px;
2793			font-size: 14px ;
2794		}
2795		a {
2796			color: #0073aa;
2797		}
2798		a:hover,
2799		a:active {
2800			color: #00a0d2;
2801		}
2802		a:focus {
2803			color: #124964;
2804		    -webkit-box-shadow:
2805		    	0 0 0 1px #5b9dd9,
2806				0 0 2px 1px rgba(30, 140, 190, .8);
2807		    box-shadow:
2808		    	0 0 0 1px #5b9dd9,
2809				0 0 2px 1px rgba(30, 140, 190, .8);
2810			outline: none;
2811		}
2812		.button {
2813			background: #f7f7f7;
2814			border: 1px solid #ccc;
2815			color: #555;
2816			display: inline-block;
2817			text-decoration: none;
2818			font-size: 13px;
2819			line-height: 26px;
2820			height: 28px;
2821			margin: 0;
2822			padding: 0 10px 1px;
2823			cursor: pointer;
2824			-webkit-border-radius: 3px;
2825			-webkit-appearance: none;
2826			border-radius: 3px;
2827			white-space: nowrap;
2828			-webkit-box-sizing: border-box;
2829			-moz-box-sizing:    border-box;
2830			box-sizing:         border-box;
2831
2832			-webkit-box-shadow: 0 1px 0 #ccc;
2833			box-shadow: 0 1px 0 #ccc;
2834		 	vertical-align: top;
2835		}
2836
2837		.button.button-large {
2838			height: 30px;
2839			line-height: 28px;
2840			padding: 0 12px 2px;
2841		}
2842
2843		.button:hover,
2844		.button:focus {
2845			background: #fafafa;
2846			border-color: #999;
2847			color: #23282d;
2848		}
2849
2850		.button:focus  {
2851			border-color: #5b9dd9;
2852			-webkit-box-shadow: 0 0 3px rgba( 0, 115, 170, .8 );
2853			box-shadow: 0 0 3px rgba( 0, 115, 170, .8 );
2854			outline: none;
2855		}
2856
2857		.button:active {
2858			background: #eee;
2859			border-color: #999;
2860		 	-webkit-box-shadow: inset 0 2px 5px -3px rgba( 0, 0, 0, 0.5 );
2861		 	box-shadow: inset 0 2px 5px -3px rgba( 0, 0, 0, 0.5 );
2862		 	-webkit-transform: translateY(1px);
2863		 	-ms-transform: translateY(1px);
2864		 	transform: translateY(1px);
2865		}
2866
2867		<?php
2868		if ( 'rtl' == $text_direction ) {
2869			echo 'body { font-family: Tahoma, Arial; }';
2870		}
2871		?>
2872	</style>
2873</head>
2874<body id="error-page">
2875<?php endif; // ! did_action( 'admin_head' ) ?>
2876	<?php echo $message; ?>
2877</body>
2878</html>
2879<?php
2880	die();
2881}
2882
2883/**
2884 * Kill WordPress execution and display XML message with error message.
2885 *
2886 * This is the handler for wp_die when processing XMLRPC requests.
2887 *
2888 * @since 3.2.0
2889 * @access private
2890 *
2891 * @global wp_xmlrpc_server $wp_xmlrpc_server
2892 *
2893 * @param string       $message Error message.
2894 * @param string       $title   Optional. Error title. Default empty.
2895 * @param string|array $args    Optional. Arguments to control behavior. Default empty array.
2896 */
2897function _xmlrpc_wp_die_handler( $message, $title = '', $args = array() ) {
2898	global $wp_xmlrpc_server;
2899	$defaults = array( 'response' => 500 );
2900
2901	$r = wp_parse_args($args, $defaults);
2902
2903	if ( $wp_xmlrpc_server ) {
2904		$error = new IXR_Error( $r['response'] , $message);
2905		$wp_xmlrpc_server->output( $error->getXml() );
2906	}
2907	die();
2908}
2909
2910/**
2911 * Kill WordPress ajax execution.
2912 *
2913 * This is the handler for wp_die when processing Ajax requests.
2914 *
2915 * @since 3.4.0
2916 * @access private
2917 *
2918 * @param string       $message Error message.
2919 * @param string       $title   Optional. Error title (unused). Default empty.
2920 * @param string|array $args    Optional. Arguments to control behavior. Default empty array.
2921 */
2922function _ajax_wp_die_handler( $message, $title = '', $args = array() ) {
2923	$defaults = array(
2924		'response' => 200,
2925	);
2926	$r = wp_parse_args( $args, $defaults );
2927
2928	if ( ! headers_sent() && null !== $r['response'] ) {
2929		status_header( $r['response'] );
2930	}
2931
2932	if ( is_scalar( $message ) )
2933		die( (string) $message );
2934	die( '0' );
2935}
2936
2937/**
2938 * Kill WordPress execution.
2939 *
2940 * This is the handler for wp_die when processing APP requests.
2941 *
2942 * @since 3.4.0
2943 * @access private
2944 *
2945 * @param string $message Optional. Response to print. Default empty.
2946 */
2947function _scalar_wp_die_handler( $message = '' ) {
2948	if ( is_scalar( $message ) )
2949		die( (string) $message );
2950	die();
2951}
2952
2953/**
2954 * Encode a variable into JSON, with some sanity checks.
2955 *
2956 * @since 4.1.0
2957 *
2958 * @param mixed $data    Variable (usually an array or object) to encode as JSON.
2959 * @param int   $options Optional. Options to be passed to json_encode(). Default 0.
2960 * @param int   $depth   Optional. Maximum depth to walk through $data. Must be
2961 *                       greater than 0. Default 512.
2962 * @return string|false The JSON encoded string, or false if it cannot be encoded.
2963 */
2964function wp_json_encode( $data, $options = 0, $depth = 512 ) {
2965	/*
2966	 * json_encode() has had extra params added over the years.
2967	 * $options was added in 5.3, and $depth in 5.5.
2968	 * We need to make sure we call it with the correct arguments.
2969	 */
2970	if ( version_compare( PHP_VERSION, '5.5', '>=' ) ) {
2971		$args = array( $data, $options, $depth );
2972	} elseif ( version_compare( PHP_VERSION, '5.3', '>=' ) ) {
2973		$args = array( $data, $options );
2974	} else {
2975		$args = array( $data );
2976	}
2977
2978	// Prepare the data for JSON serialization.
2979	$args[0] = _wp_json_prepare_data( $data );
2980
2981	$json = @call_user_func_array( 'json_encode', $args );
2982
2983	// If json_encode() was successful, no need to do more sanity checking.
2984	// ... unless we're in an old version of PHP, and json_encode() returned
2985	// a string containing 'null'. Then we need to do more sanity checking.
2986	if ( false !== $json && ( version_compare( PHP_VERSION, '5.5', '>=' ) || false === strpos( $json, 'null' ) ) )  {
2987		return $json;
2988	}
2989
2990	try {
2991		$args[0] = _wp_json_sanity_check( $data, $depth );
2992	} catch ( Exception $e ) {
2993		return false;
2994	}
2995
2996	return call_user_func_array( 'json_encode', $args );
2997}
2998
2999/**
3000 * Perform sanity checks on data that shall be encoded to JSON.
3001 *
3002 * @ignore
3003 * @since 4.1.0
3004 * @access private
3005 *
3006 * @see wp_json_encode()
3007 *
3008 * @param mixed $data  Variable (usually an array or object) to encode as JSON.
3009 * @param int   $depth Maximum depth to walk through $data. Must be greater than 0.
3010 * @return mixed The sanitized data that shall be encoded to JSON.
3011 */
3012function _wp_json_sanity_check( $data, $depth ) {
3013	if ( $depth < 0 ) {
3014		throw new Exception( 'Reached depth limit' );
3015	}
3016
3017	if ( is_array( $data ) ) {
3018		$output = array();
3019		foreach ( $data as $id => $el ) {
3020			// Don't forget to sanitize the ID!
3021			if ( is_string( $id ) ) {
3022				$clean_id = _wp_json_convert_string( $id );
3023			} else {
3024				$clean_id = $id;
3025			}
3026
3027			// Check the element type, so that we're only recursing if we really have to.
3028			if ( is_array( $el ) || is_object( $el ) ) {
3029				$output[ $clean_id ] = _wp_json_sanity_check( $el, $depth - 1 );
3030			} elseif ( is_string( $el ) ) {
3031				$output[ $clean_id ] = _wp_json_convert_string( $el );
3032			} else {
3033				$output[ $clean_id ] = $el;
3034			}
3035		}
3036	} elseif ( is_object( $data ) ) {
3037		$output = new stdClass;
3038		foreach ( $data as $id => $el ) {
3039			if ( is_string( $id ) ) {
3040				$clean_id = _wp_json_convert_string( $id );
3041			} else {
3042				$clean_id = $id;
3043			}
3044
3045			if ( is_array( $el ) || is_object( $el ) ) {
3046				$output->$clean_id = _wp_json_sanity_check( $el, $depth - 1 );
3047			} elseif ( is_string( $el ) ) {
3048				$output->$clean_id = _wp_json_convert_string( $el );
3049			} else {
3050				$output->$clean_id = $el;
3051			}
3052		}
3053	} elseif ( is_string( $data ) ) {
3054		return _wp_json_convert_string( $data );
3055	} else {
3056		return $data;
3057	}
3058
3059	return $output;
3060}
3061
3062/**
3063 * Convert a string to UTF-8, so that it can be safely encoded to JSON.
3064 *
3065 * @ignore
3066 * @since 4.1.0
3067 * @access private
3068 *
3069 * @see _wp_json_sanity_check()
3070 *
3071 * @staticvar bool $use_mb
3072 *
3073 * @param string $string The string which is to be converted.
3074 * @return string The checked string.
3075 */
3076function _wp_json_convert_string( $string ) {
3077	static $use_mb = null;
3078	if ( is_null( $use_mb ) ) {
3079		$use_mb = function_exists( 'mb_convert_encoding' );
3080	}
3081
3082	if ( $use_mb ) {
3083		$encoding = mb_detect_encoding( $string, mb_detect_order(), true );
3084		if ( $encoding ) {
3085			return mb_convert_encoding( $string, 'UTF-8', $encoding );
3086		} else {
3087			return mb_convert_encoding( $string, 'UTF-8', 'UTF-8' );
3088		}
3089	} else {
3090		return wp_check_invalid_utf8( $string, true );
3091	}
3092}
3093
3094/**
3095 * Prepares response data to be serialized to JSON.
3096 *
3097 * This supports the JsonSerializable interface for PHP 5.2-5.3 as well.
3098 *
3099 * @ignore
3100 * @since 4.4.0
3101 * @access private
3102 *
3103 * @param mixed $data Native representation.
3104 * @return bool|int|float|null|string|array Data ready for `json_encode()`.
3105 */
3106function _wp_json_prepare_data( $data ) {
3107	if ( ! defined( 'WP_JSON_SERIALIZE_COMPATIBLE' ) || WP_JSON_SERIALIZE_COMPATIBLE === false ) {
3108		return $data;
3109	}
3110
3111	switch ( gettype( $data ) ) {
3112		case 'boolean':
3113		case 'integer':
3114		case 'double':
3115		case 'string':
3116		case 'NULL':
3117			// These values can be passed through.
3118			return $data;
3119
3120		case 'array':
3121			// Arrays must be mapped in case they also return objects.
3122			return array_map( '_wp_json_prepare_data', $data );
3123
3124		case 'object':
3125			// If this is an incomplete object (__PHP_Incomplete_Class), bail.
3126			if ( ! is_object( $data ) ) {
3127				return null;
3128			}
3129
3130			if ( $data instanceof JsonSerializable ) {
3131				$data = $data->jsonSerialize();
3132			} else {
3133				$data = get_object_vars( $data );
3134			}
3135
3136			// Now, pass the array (or whatever was returned from jsonSerialize through).
3137			return _wp_json_prepare_data( $data );
3138
3139		default:
3140			return null;
3141	}
3142}
3143
3144/**
3145 * Send a JSON response back to an Ajax request.
3146 *
3147 * @since 3.5.0
3148 * @since 4.7.0 The `$status_code` parameter was added.
3149 *
3150 * @param mixed $response    Variable (usually an array or object) to encode as JSON,
3151 *                           then print and die.
3152 * @param int   $status_code The HTTP status code to output.
3153 */
3154function wp_send_json( $response, $status_code = null ) {
3155	@header( 'Content-Type: application/json; charset=' . get_option( 'blog_charset' ) );
3156	if ( null !== $status_code ) {
3157		status_header( $status_code );
3158	}
3159	echo wp_json_encode( $response );
3160
3161	if ( wp_doing_ajax() ) {
3162		wp_die( '', '', array(
3163			'response' => null,
3164		) );
3165	} else {
3166		die;
3167	}
3168}
3169
3170/**
3171 * Send a JSON response back to an Ajax request, indicating success.
3172 *
3173 * @since 3.5.0
3174 * @since 4.7.0 The `$status_code` parameter was added.
3175 *
3176 * @param mixed $data        Data to encode as JSON, then print and die.
3177 * @param int   $status_code The HTTP status code to output.
3178 */
3179function wp_send_json_success( $data = null, $status_code = null ) {
3180	$response = array( 'success' => true );
3181
3182	if ( isset( $data ) )
3183		$response['data'] = $data;
3184
3185	wp_send_json( $response, $status_code );
3186}
3187
3188/**
3189 * Send a JSON response back to an Ajax request, indicating failure.
3190 *
3191 * If the `$data` parameter is a WP_Error object, the errors
3192 * within the object are processed and output as an array of error
3193 * codes and corresponding messages. All other types are output
3194 * without further processing.
3195 *
3196 * @since 3.5.0
3197 * @since 4.1.0 The `$data` parameter is now processed if a WP_Error object is passed in.
3198 * @since 4.7.0 The `$status_code` parameter was added.
3199 *
3200 * @param mixed $data        Data to encode as JSON, then print and die.
3201 * @param int   $status_code The HTTP status code to output.
3202 */
3203function wp_send_json_error( $data = null, $status_code = null ) {
3204	$response = array( 'success' => false );
3205
3206	if ( isset( $data ) ) {
3207		if ( is_wp_error( $data ) ) {
3208			$result = array();
3209			foreach ( $data->errors as $code => $messages ) {
3210				foreach ( $messages as $message ) {
3211					$result[] = array( 'code' => $code, 'message' => $message );
3212				}
3213			}
3214
3215			$response['data'] = $result;
3216		} else {
3217			$response['data'] = $data;
3218		}
3219	}
3220
3221	wp_send_json( $response, $status_code );
3222}
3223
3224/**
3225 * Checks that a JSONP callback is a valid JavaScript callback.
3226 *
3227 * Only allows alphanumeric characters and the dot character in callback
3228 * function names. This helps to mitigate XSS attacks caused by directly
3229 * outputting user input.
3230 *
3231 * @since 4.6.0
3232 *
3233 * @param string $callback Supplied JSONP callback function.
3234 * @return bool True if valid callback, otherwise false.
3235 */
3236function wp_check_jsonp_callback( $callback ) {
3237	if ( ! is_string( $callback ) ) {
3238		return false;
3239	}
3240
3241	preg_replace( '/[^\w\.]/', '', $callback, -1, $illegal_char_count );
3242
3243	return 0 === $illegal_char_count;
3244}
3245
3246/**
3247 * Retrieve the WordPress home page URL.
3248 *
3249 * If the constant named 'WP_HOME' exists, then it will be used and returned
3250 * by the function. This can be used to counter the redirection on your local
3251 * development environment.
3252 *
3253 * @since 2.2.0
3254 * @access private
3255 *
3256 * @see WP_HOME
3257 *
3258 * @param string $url URL for the home location.
3259 * @return string Homepage location.
3260 */
3261function _config_wp_home( $url = '' ) {
3262	if ( defined( 'WP_HOME' ) )
3263		return untrailingslashit( WP_HOME );
3264	return $url;
3265}
3266
3267/**
3268 * Retrieve the WordPress site URL.
3269 *
3270 * If the constant named 'WP_SITEURL' is defined, then the value in that
3271 * constant will always be returned. This can be used for debugging a site
3272 * on your localhost while not having to change the database to your URL.
3273 *
3274 * @since 2.2.0
3275 * @access private
3276 *
3277 * @see WP_SITEURL
3278 *
3279 * @param string $url URL to set the WordPress site location.
3280 * @return string The WordPress Site URL.
3281 */
3282function _config_wp_siteurl( $url = '' ) {
3283	if ( defined( 'WP_SITEURL' ) )
3284		return untrailingslashit( WP_SITEURL );
3285	return $url;
3286}
3287
3288/**
3289 * Delete the fresh site option.
3290 *
3291 * @since 4.7.0
3292 * @access private
3293 */
3294function _delete_option_fresh_site() {
3295	update_option( 'fresh_site', 0 );
3296}
3297
3298/**
3299 * Set the localized direction for MCE plugin.
3300 *
3301 * Will only set the direction to 'rtl', if the WordPress locale has
3302 * the text direction set to 'rtl'.
3303 *
3304 * Fills in the 'directionality' setting, enables the 'directionality'
3305 * plugin, and adds the 'ltr' button to 'toolbar1', formerly
3306 * 'theme_advanced_buttons1' array keys. These keys are then returned
3307 * in the $mce_init (TinyMCE settings) array.
3308 *
3309 * @since 2.1.0
3310 * @access private
3311 *
3312 * @param array $mce_init MCE settings array.
3313 * @return array Direction set for 'rtl', if needed by locale.
3314 */
3315function _mce_set_direction( $mce_init ) {
3316	if ( is_rtl() ) {
3317		$mce_init['directionality'] = 'rtl';
3318		$mce_init['rtl_ui'] = true;
3319
3320		if ( ! empty( $mce_init['plugins'] ) && strpos( $mce_init['plugins'], 'directionality' ) === false ) {
3321			$mce_init['plugins'] .= ',directionality';
3322		}
3323
3324		if ( ! empty( $mce_init['toolbar1'] ) && ! preg_match( '/\bltr\b/', $mce_init['toolbar1'] ) ) {
3325			$mce_init['toolbar1'] .= ',ltr';
3326		}
3327	}
3328
3329	return $mce_init;
3330}
3331
3332
3333/**
3334 * Convert smiley code to the icon graphic file equivalent.
3335 *
3336 * You can turn off smilies, by going to the write setting screen and unchecking
3337 * the box, or by setting 'use_smilies' option to false or removing the option.
3338 *
3339 * Plugins may override the default smiley list by setting the $wpsmiliestrans
3340 * to an array, with the key the code the blogger types in and the value the
3341 * image file.
3342 *
3343 * The $wp_smiliessearch global is for the regular expression and is set each
3344 * time the function is called.
3345 *
3346 * The full list of smilies can be found in the function and won't be listed in
3347 * the description. Probably should create a Codex page for it, so that it is
3348 * available.
3349 *
3350 * @global array $wpsmiliestrans
3351 * @global array $wp_smiliessearch
3352 *
3353 * @since 2.2.0
3354 */
3355function smilies_init() {
3356	global $wpsmiliestrans, $wp_smiliessearch;
3357
3358	// don't bother setting up smilies if they are disabled
3359	if ( !get_option( 'use_smilies' ) )
3360		return;
3361
3362	if ( !isset( $wpsmiliestrans ) ) {
3363		$wpsmiliestrans = array(
3364		':mrgreen:' => 'mrgreen.png',
3365		':neutral:' => "\xf0\x9f\x98\x90",
3366		':twisted:' => "\xf0\x9f\x98\x88",
3367		  ':arrow:' => "\xe2\x9e\xa1",
3368		  ':shock:' => "\xf0\x9f\x98\xaf",
3369		  ':smile:' => "\xf0\x9f\x99\x82",
3370		    ':???:' => "\xf0\x9f\x98\x95",
3371		   ':cool:' => "\xf0\x9f\x98\x8e",
3372		   ':evil:' => "\xf0\x9f\x91\xbf",
3373		   ':grin:' => "\xf0\x9f\x98\x80",
3374		   ':idea:' => "\xf0\x9f\x92\xa1",
3375		   ':oops:' => "\xf0\x9f\x98\xb3",
3376		   ':razz:' => "\xf0\x9f\x98\x9b",
3377		   ':roll:' => "\xf0\x9f\x99\x84",
3378		   ':wink:' => "\xf0\x9f\x98\x89",
3379		    ':cry:' => "\xf0\x9f\x98\xa5",
3380		    ':eek:' => "\xf0\x9f\x98\xae",
3381		    ':lol:' => "\xf0\x9f\x98\x86",
3382		    ':mad:' => "\xf0\x9f\x98\xa1",
3383		    ':sad:' => "\xf0\x9f\x99\x81",
3384		      '8-)' => "\xf0\x9f\x98\x8e",
3385		      '8-O' => "\xf0\x9f\x98\xaf",
3386		      ':-(' => "\xf0\x9f\x99\x81",
3387		      ':-)' => "\xf0\x9f\x99\x82",
3388		      ':-?' => "\xf0\x9f\x98\x95",
3389		      ':-D' => "\xf0\x9f\x98\x80",
3390		      ':-P' => "\xf0\x9f\x98\x9b",
3391		      ':-o' => "\xf0\x9f\x98\xae",
3392		      ':-x' => "\xf0\x9f\x98\xa1",
3393		      ':-|' => "\xf0\x9f\x98\x90",
3394		      ';-)' => "\xf0\x9f\x98\x89",
3395		// This one transformation breaks regular text with frequency.
3396		//     '8)' => "\xf0\x9f\x98\x8e",
3397		       '8O' => "\xf0\x9f\x98\xaf",
3398		       ':(' => "\xf0\x9f\x99\x81",
3399		       ':)' => "\xf0\x9f\x99\x82",
3400		       ':?' => "\xf0\x9f\x98\x95",
3401		       ':D' => "\xf0\x9f\x98\x80",
3402		       ':P' => "\xf0\x9f\x98\x9b",
3403		       ':o' => "\xf0\x9f\x98\xae",
3404		       ':x' => "\xf0\x9f\x98\xa1",
3405		       ':|' => "\xf0\x9f\x98\x90",
3406		       ';)' => "\xf0\x9f\x98\x89",
3407		      ':!:' => "\xe2\x9d\x97",
3408		      ':?:' => "\xe2\x9d\x93",
3409		);
3410	}
3411
3412	/**
3413	 * Filters all the smilies.
3414	 *
3415	 * This filter must be added before `smilies_init` is run, as
3416	 * it is normally only run once to setup the smilies regex.
3417	 *
3418	 * @since 4.7.0
3419	 *
3420	 * @param array $wpsmiliestrans List of the smilies.
3421	 */
3422	$wpsmiliestrans = apply_filters('smilies', $wpsmiliestrans);
3423
3424	if (count($wpsmiliestrans) == 0) {
3425		return;
3426	}
3427
3428	/*
3429	 * NOTE: we sort the smilies in reverse key order. This is to make sure
3430	 * we match the longest possible smilie (:???: vs :?) as the regular
3431	 * expression used below is first-match
3432	 */
3433	krsort($wpsmiliestrans);
3434
3435	$spaces = wp_spaces_regexp();
3436
3437	// Begin first "subpattern"
3438	$wp_smiliessearch = '/(?<=' . $spaces . '|^)';
3439
3440	$subchar = '';
3441	foreach ( (array) $wpsmiliestrans as $smiley => $img ) {
3442		$firstchar = substr($smiley, 0, 1);
3443		$rest = substr($smiley, 1);
3444
3445		// new subpattern?
3446		if ($firstchar != $subchar) {
3447			if ($subchar != '') {
3448				$wp_smiliessearch .= ')(?=' . $spaces . '|$)';  // End previous "subpattern"
3449				$wp_smiliessearch .= '|(?<=' . $spaces . '|^)'; // Begin another "subpattern"
3450			}
3451			$subchar = $firstchar;
3452			$wp_smiliessearch .= preg_quote($firstchar, '/') . '(?:';
3453		} else {
3454			$wp_smiliessearch .= '|';
3455		}
3456		$wp_smiliessearch .= preg_quote($rest, '/');
3457	}
3458
3459	$wp_smiliessearch .= ')(?=' . $spaces . '|$)/m';
3460
3461}
3462
3463/**
3464 * Merge user defined arguments into defaults array.
3465 *
3466 * This function is used throughout WordPress to allow for both string or array
3467 * to be merged into another array.
3468 *
3469 * @since 2.2.0
3470 * @since 2.3.0 `$args` can now also be an object.
3471 *
3472 * @param string|array|object $args     Value to merge with $defaults.
3473 * @param array               $defaults Optional. Array that serves as the defaults. Default empty.
3474 * @return array Merged user defined values with defaults.
3475 */
3476function wp_parse_args( $args, $defaults = '' ) {
3477	if ( is_object( $args ) )
3478		$r = get_object_vars( $args );
3479	elseif ( is_array( $args ) )
3480		$r =& $args;
3481	else
3482		wp_parse_str( $args, $r );
3483
3484	if ( is_array( $defaults ) )
3485		return array_merge( $defaults, $r );
3486	return $r;
3487}
3488
3489/**
3490 * Clean up an array, comma- or space-separated list of IDs.
3491 *
3492 * @since 3.0.0
3493 *
3494 * @param array|string $list List of ids.
3495 * @return array Sanitized array of IDs.
3496 */
3497function wp_parse_id_list( $list ) {
3498	if ( !is_array($list) )
3499		$list = preg_split('/[\s,]+/', $list);
3500
3501	return array_unique(array_map('absint', $list));
3502}
3503
3504/**
3505 * Clean up an array, comma- or space-separated list of slugs.
3506 *
3507 * @since 4.7.0
3508 *
3509 * @param  array|string $list List of slugs.
3510 * @return array Sanitized array of slugs.
3511 */
3512function wp_parse_slug_list( $list ) {
3513	if ( ! is_array( $list ) ) {
3514		$list = preg_split( '/[\s,]+/', $list );
3515	}
3516
3517	foreach ( $list as $key => $value ) {
3518		$list[ $key ] = sanitize_title( $value );
3519	}
3520
3521	return array_unique( $list );
3522}
3523
3524/**
3525 * Extract a slice of an array, given a list of keys.
3526 *
3527 * @since 3.1.0
3528 *
3529 * @param array $array The original array.
3530 * @param array $keys  The list of keys.
3531 * @return array The array slice.
3532 */
3533function wp_array_slice_assoc( $array, $keys ) {
3534	$slice = array();
3535	foreach ( $keys as $key )
3536		if ( isset( $array[ $key ] ) )
3537			$slice[ $key ] = $array[ $key ];
3538
3539	return $slice;
3540}
3541
3542/**
3543 * Determines if the variable is a numeric-indexed array.
3544 *
3545 * @since 4.4.0
3546 *
3547 * @param mixed $data Variable to check.
3548 * @return bool Whether the variable is a list.
3549 */
3550function wp_is_numeric_array( $data ) {
3551	if ( ! is_array( $data ) ) {
3552		return false;
3553	}
3554
3555	$keys = array_keys( $data );
3556	$string_keys = array_filter( $keys, 'is_string' );
3557	return count( $string_keys ) === 0;
3558}
3559
3560/**
3561 * Filters a list of objects, based on a set of key => value arguments.
3562 *
3563 * @since 3.0.0
3564 * @since 4.7.0 Uses WP_List_Util class.
3565 *
3566 * @param array       $list     An array of objects to filter
3567 * @param array       $args     Optional. An array of key => value arguments to match
3568 *                              against each object. Default empty array.
3569 * @param string      $operator Optional. The logical operation to perform. 'or' means
3570 *                              only one element from the array needs to match; 'and'
3571 *                              means all elements must match; 'not' means no elements may
3572 *                              match. Default 'and'.
3573 * @param bool|string $field    A field from the object to place instead of the entire object.
3574 *                              Default false.
3575 * @return array A list of objects or object fields.
3576 */
3577function wp_filter_object_list( $list, $args = array(), $operator = 'and', $field = false ) {
3578	if ( ! is_array( $list ) ) {
3579		return array();
3580	}
3581
3582	$util = new WP_List_Util( $list );
3583
3584	$util->filter( $args, $operator );
3585
3586	if ( $field ) {
3587		$util->pluck( $field );
3588	}
3589
3590	return $util->get_output();
3591}
3592
3593/**
3594 * Filters a list of objects, based on a set of key => value arguments.
3595 *
3596 * @since 3.1.0
3597 * @since 4.7.0 Uses WP_List_Util class.
3598 *
3599 * @param array  $list     An array of objects to filter.
3600 * @param array  $args     Optional. An array of key => value arguments to match
3601 *                         against each object. Default empty array.
3602 * @param string $operator Optional. The logical operation to perform. 'AND' means
3603 *                         all elements from the array must match. 'OR' means only
3604 *                         one element needs to match. 'NOT' means no elements may
3605 *                         match. Default 'AND'.
3606 * @return array Array of found values.
3607 */
3608function wp_list_filter( $list, $args = array(), $operator = 'AND' ) {
3609	if ( ! is_array( $list ) ) {
3610		return array();
3611	}
3612
3613	$util = new WP_List_Util( $list );
3614	return $util->filter( $args, $operator );
3615}
3616
3617/**
3618 * Pluck a certain field out of each object in a list.
3619 *
3620 * This has the same functionality and prototype of
3621 * array_column() (PHP 5.5) but also supports objects.
3622 *
3623 * @since 3.1.0
3624 * @since 4.0.0 $index_key parameter added.
3625 * @since 4.7.0 Uses WP_List_Util class.
3626 *
3627 * @param array      $list      List of objects or arrays
3628 * @param int|string $field     Field from the object to place instead of the entire object
3629 * @param int|string $index_key Optional. Field from the object to use as keys for the new array.
3630 *                              Default null.
3631 * @return array Array of found values. If `$index_key` is set, an array of found values with keys
3632 *               corresponding to `$index_key`. If `$index_key` is null, array keys from the original
3633 *               `$list` will be preserved in the results.
3634 */
3635function wp_list_pluck( $list, $field, $index_key = null ) {
3636	$util = new WP_List_Util( $list );
3637	return $util->pluck( $field, $index_key );