wp-includes/functions.php

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