wp-includes/http.php

   1 <?php
   2 /**
   3  * Simple and uniform HTTP request API.
   4  *
   5  * Will eventually replace and standardize the WordPress HTTP requests made.
   6  *
   7  * @link http://trac.wordpress.org/ticket/4779 HTTP API Proposal
   8  *
   9  * @package WordPress
  10  * @subpackage HTTP
  11  * @since 2.7.0
  12  */
  13
  14 /**
  15  * Returns the initialized WP_Http Object
  16  *
  17  * @since 2.7.0
  18  * @access private
  19  *
  20  * @return WP_Http HTTP Transport object.
  21  */
  22 function _wp_http_get_object() {
  23         static $http;
  24
  25         if ( is_null($http) )
  26                 $http = new WP_Http();
  27
  28         return $http;
  29 }
  30
  31 /**
  32  * Retrieve the raw response from a safe HTTP request.
  33  *
  34  * This function is ideal when the HTTP request is being made to an arbitrary
  35  * URL. The URL is validated to avoid redirection and request forgery attacks.
  36  *
  37  * @see wp_remote_request() For more information on the response array format
  38  *      and default arguments.
  39  *
  40  * @since 3.6.0
  41  *
  42  * @param string $url Site URL to retrieve.
  43  * @param array $args Optional. Override the defaults.
  44  * @return WP_Error|array The response or WP_Error on failure.
  45  */
  46 function wp_safe_remote_request( $url, $args = array() ) {
  47         $args['reject_unsafe_urls'] = true;
  48         $http = _wp_http_get_object();
  49         return $http->request( $url, $args );
  50 }
  51
  52 /**
  53  * Retrieve the raw response from a safe HTTP request using the GET method.
  54  *
  55  * This function is ideal when the HTTP request is being made to an arbitrary
  56  * URL. The URL is validated to avoid redirection and request forgery attacks.
  57  *
  58  * @see wp_remote_request() For more information on the response array format
  59  *      and default arguments.
  60  *
  61  * @since 3.6.0
  62  *
  63  * @param string $url Site URL to retrieve.
  64  * @param array $args Optional. Override the defaults.
  65  * @return WP_Error|array The response or WP_Error on failure.
  66  */
  67 function wp_safe_remote_get( $url, $args = array() ) {
  68         $args['reject_unsafe_urls'] = true;
  69         $http = _wp_http_get_object();
  70         return $http->get( $url, $args );
  71 }
  72
  73 /**
  74  * Retrieve the raw response from a safe HTTP request using the POST method.
  75  *
  76  * This function is ideal when the HTTP request is being made to an arbitrary
  77  * URL. The URL is validated to avoid redirection and request forgery attacks.
  78  *
  79  * @see wp_remote_request() For more information on the response array format
  80  *      and default arguments.
  81  *
  82  * @since 3.6.0
  83  *
  84  * @param string $url Site URL to retrieve.
  85  * @param array $args Optional. Override the defaults.
  86  * @return WP_Error|array The response or WP_Error on failure.
  87  */
  88 function wp_safe_remote_post( $url, $args = array() ) {
  89         $args['reject_unsafe_urls'] = true;
  90         $http = _wp_http_get_object();
  91         return $http->post( $url, $args );
  92 }
  93
  94 /**
  95  * Retrieve the raw response from a safe HTTP request using the HEAD method.
  96  *
  97  * This function is ideal when the HTTP request is being made to an arbitrary
  98  * URL. The URL is validated to avoid redirection and request forgery attacks.
  99  *
 100  * @see wp_remote_request() For more information on the response array format
 101  *      and default arguments.
 102  *
 103  * @since 3.6.0
 104  *
 105  * @param string $url Site URL to retrieve.
 106  * @param array $args Optional. Override the defaults.
 107  * @return WP_Error|array The response or WP_Error on failure.
 108  */
 109 function wp_safe_remote_head( $url, $args = array() ) {
 110         $args['reject_unsafe_urls'] = true;
 111         $http = _wp_http_get_object();
 112         return $http->head( $url, $args );
 113 }
 114
 115 /**
 116  * Retrieve the raw response from the HTTP request.
 117  *
 118  * The array structure is a little complex.
 119  *
 120  * <code>
 121  * $res = array( 'headers' => array(), 'response' => array('code' => int, 'message' => string) );
 122  * </code>
 123  *
 124  * All of the headers in $res['headers'] are with the name as the key and the
 125  * value as the value. So to get the User-Agent, you would do the following.
 126  *
 127  * <code>
 128  * $user_agent = $res['headers']['user-agent'];
 129  * </code>
 130  *
 131  * The body is the raw response content and can be retrieved from $res['body'].
 132  *
 133  * This function is called first to make the request and there are other API
 134  * functions to abstract out the above convoluted setup.
 135  *
 136  * List of default arguments:
 137  * 'method'      => 'GET'
 138  *  - Default 'GET'  for wp_remote_get()
 139  *  - Default 'POST' for wp_remote_post()
 140  *  - Default 'HEAD' for wp_remote_head()
 141  * 'timeout'     => 5
 142  * 'redirection' => 5
 143  * 'httpversion' => '1.0'
 144  * 'user-agent'  => 'WordPress/' . $wp_version . '; ' . get_bloginfo( 'url' )
 145  * 'blocking'    => true
 146  * 'headers'     => array()
 147  * 'cookies'     => array()
 148  * 'body'        => null
 149  * 'compress'    => false,
 150  * 'decompress'  => true,
 151  * 'sslverify'   => true,
 152  * 'stream'      => false,
 153  * 'filename'    => null
 154  *
 155  * @since 2.7.0
 156  *
 157  * @param string $url Site URL to retrieve.
 158  * @param array $args Optional. Override the defaults.
 159  * @return WP_Error|array The response or WP_Error on failure.
 160  */
 161 function wp_remote_request($url, $args = array()) {
 162         $objFetchSite = _wp_http_get_object();
 163         return $objFetchSite->request($url, $args);
 164 }
 165
 166 /**
 167  * Retrieve the raw response from the HTTP request using the GET method.
 168  *
 169  * @see wp_remote_request() For more information on the response array format and default arguments.
 170  *
 171  * @since 2.7.0
 172  *
 173  * @param string $url Site URL to retrieve.
 174  * @param array $args Optional. Override the defaults.
 175  * @return WP_Error|array The response or WP_Error on failure.
 176  */
 177 function wp_remote_get($url, $args = array()) {
 178         $objFetchSite = _wp_http_get_object();
 179         return $objFetchSite->get($url, $args);
 180 }
 181
 182 /**
 183  * Retrieve the raw response from the HTTP request using the POST method.
 184  *
 185  * @see wp_remote_request() For more information on the response array format and default arguments.
 186  *
 187  * @since 2.7.0
 188  *
 189  * @param string $url Site URL to retrieve.
 190  * @param array $args Optional. Override the defaults.
 191  * @return WP_Error|array The response or WP_Error on failure.
 192  */
 193 function wp_remote_post($url, $args = array()) {
 194         $objFetchSite = _wp_http_get_object();
 195         return $objFetchSite->post($url, $args);
 196 }
 197
 198 /**
 199  * Retrieve the raw response from the HTTP request using the HEAD method.
 200  *
 201  * @see wp_remote_request() For more information on the response array format and default arguments.
 202  *
 203  * @since 2.7.0
 204  *
 205  * @param string $url Site URL to retrieve.
 206  * @param array $args Optional. Override the defaults.
 207  * @return WP_Error|array The response or WP_Error on failure.
 208  */
 209 function wp_remote_head($url, $args = array()) {
 210         $objFetchSite = _wp_http_get_object();
 211         return $objFetchSite->head($url, $args);
 212 }
 213
 214 /**
 215  * Retrieve only the headers from the raw response.
 216  *
 217  * @since 2.7.0
 218  *
 219  * @param array $response HTTP response.
 220  * @return array The headers of the response. Empty array if incorrect parameter given.
 221  */
 222 function wp_remote_retrieve_headers(&$response) {
 223         if ( is_wp_error($response) || ! isset($response['headers']) || ! is_array($response['headers']))
 224                 return array();
 225
 226         return $response['headers'];
 227 }
 228
 229 /**
 230  * Retrieve a single header by name from the raw response.
 231  *
 232  * @since 2.7.0
 233  *
 234  * @param array $response
 235  * @param string $header Header name to retrieve value from.
 236  * @return string The header value. Empty string on if incorrect parameter given, or if the header doesn't exist.
 237  */
 238 function wp_remote_retrieve_header(&$response, $header) {
 239         if ( is_wp_error($response) || ! isset($response['headers']) || ! is_array($response['headers']))
 240                 return '';
 241
 242         if ( array_key_exists($header, $response['headers']) )
 243                 return $response['headers'][$header];
 244
 245         return '';
 246 }
 247
 248 /**
 249  * Retrieve only the response code from the raw response.
 250  *
 251  * Will return an empty array if incorrect parameter value is given.
 252  *
 253  * @since 2.7.0
 254  *
 255  * @param array $response HTTP response.
 256  * @return string the response code. Empty string on incorrect parameter given.
 257  */
 258 function wp_remote_retrieve_response_code(&$response) {
 259         if ( is_wp_error($response) || ! isset($response['response']) || ! is_array($response['response']))
 260                 return '';
 261
 262         return $response['response']['code'];
 263 }
 264
 265 /**
 266  * Retrieve only the response message from the raw response.
 267  *
 268  * Will return an empty array if incorrect parameter value is given.
 269  *
 270  * @since 2.7.0
 271  *
 272  * @param array $response HTTP response.
 273  * @return string The response message. Empty string on incorrect parameter given.
 274  */
 275 function wp_remote_retrieve_response_message(&$response) {
 276         if ( is_wp_error($response) || ! isset($response['response']) || ! is_array($response['response']))
 277                 return '';
 278
 279         return $response['response']['message'];
 280 }
 281
 282 /**
 283  * Retrieve only the body from the raw response.
 284  *
 285  * @since 2.7.0
 286  *
 287  * @param array $response HTTP response.
 288  * @return string The body of the response. Empty string if no body or incorrect parameter given.
 289  */
 290 function wp_remote_retrieve_body(&$response) {
 291         if ( is_wp_error($response) || ! isset($response['body']) )
 292                 return '';
 293
 294         return $response['body'];
 295 }
 296
 297 /**
 298  * Determines if there is an HTTP Transport that can process this request.
 299  *
 300  * @since 3.2.0
 301  *
 302  * @param array  $capabilities Array of capabilities to test or a wp_remote_request() $args array.
 303  * @param string $url Optional. If given, will check if the URL requires SSL and adds that requirement to the capabilities array.
 304  *
 305  * @return bool
 306  */
 307 function wp_http_supports( $capabilities = array(), $url = null ) {
 308         $objFetchSite = _wp_http_get_object();
 309
 310         $capabilities = wp_parse_args( $capabilities );
 311
 312         $count = count( $capabilities );
 313
 314         // If we have a numeric $capabilities array, spoof a wp_remote_request() associative $args array
 315         if ( $count && count( array_filter( array_keys( $capabilities ), 'is_numeric' ) ) == $count ) {
 316                 $capabilities = array_combine( array_values( $capabilities ), array_fill( 0, $count, true ) );
 317         }
 318
 319         if ( $url && !isset( $capabilities['ssl'] ) ) {
 320                 $scheme = parse_url( $url, PHP_URL_SCHEME );
 321                 if ( 'https' == $scheme || 'ssl' == $scheme ) {
 322                         $capabilities['ssl'] = true;
 323                 }
 324         }
 325
 326         return (bool) $objFetchSite->_get_first_available_transport( $capabilities );
 327 }
 328
 329 /**
 330  * Get the HTTP Origin of the current request.
 331  *
 332  * @since 3.4.0
 333  *
 334  * @return string URL of the origin. Empty string if no origin.
 335  */
 336 function get_http_origin() {
 337         $origin = '';
 338         if ( ! empty ( $_SERVER[ 'HTTP_ORIGIN' ] ) )
 339                 $origin = $_SERVER[ 'HTTP_ORIGIN' ];
 340
 341         return apply_filters( 'http_origin', $origin );
 342 }
 343
 344 /**
 345  * Retrieve list of allowed http origins.
 346  *
 347  * @since 3.4.0
 348  *
 349  * @return array Array of origin URLs.
 350  */
 351 function get_allowed_http_origins() {
 352         $admin_origin = parse_url( admin_url() );
 353         $home_origin = parse_url( home_url() );
 354
 355         // @todo preserve port?
 356         $allowed_origins = array_unique( array(
 357                 'http://' . $admin_origin[ 'host' ],
 358                 'https://' . $admin_origin[ 'host' ],
 359                 'http://' . $home_origin[ 'host' ],
 360                 'https://' . $home_origin[ 'host' ],
 361         ) );
 362
 363         return apply_filters( 'allowed_http_origins' , $allowed_origins );
 364 }
 365
 366 /**
 367  * Determines if the http origin is an authorized one.
 368  *
 369  * @since 3.4.0
 370  *
 371  * @param string Origin URL. If not provided, the value of get_http_origin() is used.
 372  * @return bool True if the origin is allowed. False otherwise.
 373  */
 374 function is_allowed_http_origin( $origin = null ) {
 375         $origin_arg = $origin;
 376
 377         if ( null === $origin )
 378                 $origin = get_http_origin();
 379
 380         if ( $origin && ! in_array( $origin, get_allowed_http_origins() ) )
 381                 $origin = '';
 382
 383         return apply_filters( 'allowed_http_origin', $origin, $origin_arg );
 384 }
 385
 386 /**
 387  * Send Access-Control-Allow-Origin and related headers if the current request
 388  * is from an allowed origin.
 389  *
 390  * If the request is an OPTIONS request, the script exits with either access
 391  * control headers sent, or a 403 response if the origin is not allowed. For
 392  * other request methods, you will receive a return value.
 393  *
 394  * @since 3.4.0
 395  *
 396  * @return bool|string Returns the origin URL if headers are sent. Returns false
 397  * if headers are not sent.
 398  */
 399 function send_origin_headers() {
 400         $origin = get_http_origin();
 401
 402         if ( is_allowed_http_origin( $origin ) ) {
 403                 @header( 'Access-Control-Allow-Origin: ' .  $origin );
 404                 @header( 'Access-Control-Allow-Credentials: true' );
 405                 if ( 'OPTIONS' === $_SERVER['REQUEST_METHOD'] )
 406                         exit;
 407                 return $origin;
 408         }
 409
 410         if ( 'OPTIONS' === $_SERVER['REQUEST_METHOD'] ) {
 411                 status_header( 403 );
 412                 exit;
 413         }
 414
 415         return false;
 416 }
 417
 418 /**
 419  * Validate a URL for safe use in the HTTP API.
 420  *
 421  * @since 3.5.2
 422  *
 423  * @return mixed URL or false on failure.
 424  */
 425 function wp_http_validate_url( $url ) {
 426         $url = wp_kses_bad_protocol( $url, array( 'http', 'https' ) );
 427         if ( ! $url )
 428                 return false;
 429
 430         $parsed_url = @parse_url( $url );
 431         if ( ! $parsed_url || empty( $parsed_url['host'] ) )
 432                 return false;
 433
 434         if ( isset( $parsed_url['user'] ) || isset( $parsed_url['pass'] ) )
 435                 return false;
 436
 437         if ( false !== strpos( $parsed_url['host'], ':' ) )
 438                 return false;
 439
 440         $parsed_home = @parse_url( get_option( 'home' ) );
 441
 442         $same_host = strtolower( $parsed_home['host'] ) === strtolower( $parsed_url['host'] );
 443
 444         if ( ! $same_host ) {
 445                 $host = trim( $parsed_url['host'], '.' );
 446                 if ( preg_match( '#^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$#', $host ) ) {
 447                         $ip = $host;
 448                 } else {
 449                         $ip = gethostbyname( $host );
 450                         if ( $ip === $host ) // Error condition for gethostbyname()
 451                                 $ip = false;
 452                 }
 453                 if ( $ip ) {
 454                         $parts = array_map( 'intval', explode( '.', $ip ) );
 455                         if ( '127.0.0.1' === $ip
 456                                 || ( 10 === $parts[0] )
 457                                 || ( 172 === $parts[0] && 16 <= $parts[1] && 31 >= $parts[1] )
 458                                 || ( 192 === $parts[0] && 168 === $parts[1] )
 459                         ) {
 460                                 // If host appears local, reject unless specifically allowed.
 461                                 if ( ! apply_filters( 'http_request_host_is_external', false, $host, $url ) )
 462                                         return false;
 463                         }
 464                 }
 465         }
 466
 467         if ( empty( $parsed_url['port'] ) )
 468                 return $url;
 469
 470         $port = $parsed_url['port'];
 471         if ( 80 === $port || 443 === $port || 8080 === $port )
 472                 return $url;
 473
 474         if ( $parsed_home && $same_host && $parsed_home['port'] === $port )
 475                 return $url;
 476
 477         return false;
 478 }
 479
 480 /**
 481  * Whitelists allowed redirect hosts for safe HTTP requests as well.
 482  *
 483  * Attached to the http_request_host_is_external filter.
 484  *
 485  * @since 3.6.0
 486  *
 487  * @param bool $is_external
 488  * @param string $host
 489  * @return bool
 490  */
 491 function allowed_http_request_hosts( $is_external, $host ) {
 492         if ( ! $is_external && wp_validate_redirect( 'http://' . $host ) )
 493                 $is_external = true;
 494         return $is_external;
 495 }
 496
 497 /**
 498  * Whitelists any domain in a multisite installation for safe HTTP requests.
 499  *
 500  * Attached to the http_request_host_is_external filter.
 501  *
 502  * @since 3.6.0
 503  *
 504  * @param bool $is_external
 505  * @param string $host
 506  * @return bool
 507  */
 508 function ms_allowed_http_request_hosts( $is_external, $host ) {
 509         global $wpdb, $current_site;
 510         static $queried = array();
 511         if ( $is_external )
 512                 return $is_external;
 513         if ( $host === $current_site->domain )
 514                 return true;
 515         if ( isset( $queried[ $host ] ) )
 516                 return $queried[ $host ];
 517         $queried[ $host ] = (bool) $wpdb->get_var( $wpdb->prepare( "SELECT domain FROM $wpdb->blogs WHERE domain = %s LIMIT 1", $host ) );
 518         return $queried[ $host ];
 519 }