wp-includes/class-http.php

   1 <?php
   2 /**
   3  * Simple and uniform HTTP request API.
   4  *
   5  * Standardizes the HTTP requests for WordPress. Handles cookies, gzip encoding and decoding, chunk
   6  * decoding, if HTTP 1.1 and various other difficult HTTP protocol implementations.
   7  *
   8  * @link http://trac.wordpress.org/ticket/4779 HTTP API Proposal
   9  *
  10  * @package WordPress
  11  * @subpackage HTTP
  12  * @since 2.7.0
  13  */
  14
  15 /**
  16  * WordPress HTTP Class for managing HTTP Transports and making HTTP requests.
  17  *
  18  * This class is used to consistently make outgoing HTTP requests easy for developers
  19  * while still being compatible with the many PHP configurations under which
  20  * WordPress runs.
  21  *
  22  * Debugging includes several actions, which pass different variables for debugging the HTTP API.
  23  *
  24  * @package WordPress
  25  * @subpackage HTTP
  26  * @since 2.7.0
  27  */
  28 class WP_Http {
  29
  30         /**
  31          * Send an HTTP request to a URI.
  32          *
  33          * Please note: The only URI that are supported in the HTTP Transport implementation
  34          * are the HTTP and HTTPS protocols.
  35          *
  36          * @access public
  37          * @since 2.7.0
  38          *
  39          * @param string       $url  The request URL.
  40          * @param string|array $args {
  41          *     Optional. Array or string of HTTP request arguments.
  42          *
  43          *     @type string       $method              Request method. Accepts 'GET', 'POST', 'HEAD', or 'PUT'.
  44          *                                             Some transports technically allow others, but should not be
  45          *                                             assumed. Default 'GET'.
  46          *     @type int          $timeout             How long the connection should stay open in seconds. Default 5.
  47          *     @type int          $redirection         Number of allowed redirects. Not supported by all transports
  48          *                                             Default 5.
  49          *     @type string       $httpversion         Version of the HTTP protocol to use. Accepts '1.0' and '1.1'.
  50          *                                             Default '1.0'.
  51          *     @type string       $user-agent          User-agent value sent.
  52          *                                             Default WordPress/' . $wp_version . '; ' . get_bloginfo( 'url' ).
  53          *     @type bool         $reject_unsafe_urls  Whether to pass URLs through {@see wp_http_validate_url()}.
  54          *                                             Default false.
  55          *     @type bool         $blocking            Whether the calling code requires the result of the request.
  56          *                                             If set to false, the request will be sent to the remote server,
  57          *                                             and processing returned to the calling code immediately, the caller
  58          *                                             will know if the request succeeded or failed, but will not receive
  59          *                                             any response from the remote server. Default true.
  60          *     @type string|array $headers             Array or string of headers to send with the request.
  61          *                                             Default empty array.
  62          *     @type array        $cookies             List of cookies to send with the request. Default empty array.
  63          *     @type string|array $body                Body to send with the request. Default null.
  64          *     @type bool         $compress            Whether to compress the $body when sending the request.
  65          *                                             Default false.
  66          *     @type bool         $decompress          Whether to decompress a compressed response. If set to false and
  67          *                                             compressed content is returned in the response anyway, it will
  68          *                                             need to be separately decompressed. Default true.
  69          *     @type bool         $sslverify           Whether to verify SSL for the request. Default true.
  70          *     @type string       sslcertificates      Absolute path to an SSL certificate .crt file.
  71          *                                             Default ABSPATH . WPINC . '/certificates/ca-bundle.crt'.
  72          *     @type bool         $stream              Whether to stream to a file. If set to true and no filename was
  73          *                                             given, it will be droped it in the WP temp dir and its name will
  74          *                                             be set using the basename of the URL. Default false.
  75          *     @type string       $filename            Filename of the file to write to when streaming. $stream must be
  76          *                                             set to true. Default null.
  77          *     @type int          $limit_response_size Size in bytes to limit the response to. Default null.
  78          *
  79          * }
  80          * @return array|WP_Error Array containing 'headers', 'body', 'response', 'cookies', 'filename'.
  81          *                        A WP_Error instance upon error.
  82          */
  83         public function request( $url, $args = array() ) {
  84                 global $wp_version;
  85
  86                 $defaults = array(
  87                         'method' => 'GET',
  88                         /**
  89                          * Filter the timeout value for an HTTP request.
  90                          *
  91                          * @since 2.7.0
  92                          *
  93                          * @param int $timeout_value Time in seconds until a request times out.
  94                          *                           Default 5.
  95                          */
  96                         'timeout' => apply_filters( 'http_request_timeout', 5 ),
  97                         /**
  98                          * Filter the number of redirects allowed during an HTTP request.
  99                          *
 100                          * @since 2.7.0
 101                          *
 102                          * @param int $redirect_count Number of redirects allowed. Default 5.
 103                          */
 104                         'redirection' => apply_filters( 'http_request_redirection_count', 5 ),
 105                         /**
 106                          * Filter the version of the HTTP protocol used in a request.
 107                          *
 108                          * @since 2.7.0
 109                          *
 110                          * @param string $version Version of HTTP used. Accepts '1.0' and '1.1'.
 111                          *                        Default '1.0'.
 112                          */
 113                         'httpversion' => apply_filters( 'http_request_version', '1.0' ),
 114                         /**
 115                          * Filter the user agent value sent with an HTTP request.
 116                          *
 117                          * @since 2.7.0
 118                          *
 119                          * @param string $user_agent WordPress user agent string.
 120                          */
 121                         'user-agent' => apply_filters( 'http_headers_useragent', 'WordPress/' . $wp_version . '; ' . get_bloginfo( 'url' ) ),
 122                         /**
 123                          * Filter whether to pass URLs through wp_http_validate_url() in an HTTP request.
 124                          *
 125                          * @since 3.6.0
 126                          *
 127                          * @param bool $pass_url Whether to pass URLs through wp_http_validate_url().
 128                          *                       Default false.
 129                          */
 130                         'reject_unsafe_urls' => apply_filters( 'http_request_reject_unsafe_urls', false ),
 131                         'blocking' => true,
 132                         'headers' => array(),
 133                         'cookies' => array(),
 134                         'body' => null,
 135                         'compress' => false,
 136                         'decompress' => true,
 137                         'sslverify' => true,
 138                         'sslcertificates' => ABSPATH . WPINC . '/certificates/ca-bundle.crt',
 139                         'stream' => false,
 140                         'filename' => null,
 141                         'limit_response_size' => null,
 142                 );
 143
 144                 // Pre-parse for the HEAD checks.
 145                 $args = wp_parse_args( $args );
 146
 147                 // By default, Head requests do not cause redirections.
 148                 if ( isset($args['method']) && 'HEAD' == $args['method'] )
 149                         $defaults['redirection'] = 0;
 150
 151                 $r = wp_parse_args( $args, $defaults );
 152                 /**
 153                  * Filter the arguments used in an HTTP request.
 154                  *
 155                  * @since 2.7.0
 156                  *
 157                  * @param array  $r   An array of HTTP request arguments.
 158                  * @param string $url The request URL.
 159                  */
 160                 $r = apply_filters( 'http_request_args', $r, $url );
 161
 162                 // The transports decrement this, store a copy of the original value for loop purposes.
 163                 if ( ! isset( $r['_redirection'] ) )
 164                         $r['_redirection'] = $r['redirection'];
 165
 166                 /**
 167                  * Filter whether to preempt an HTTP request's return.
 168                  *
 169                  * Returning a truthy value to the filter will short-circuit
 170                  * the HTTP request and return early with that value.
 171                  *
 172                  * @since 2.9.0
 173                  *
 174                  * @param bool   $preempt Whether to preempt an HTTP request return. Default false.
 175                  * @param array  $r       HTTP request arguments.
 176                  * @param string $url     The request URL.
 177                  */
 178                 $pre = apply_filters( 'pre_http_request', false, $r, $url );
 179                 if ( false !== $pre )
 180                         return $pre;
 181
 182                 if ( function_exists( 'wp_kses_bad_protocol' ) ) {
 183                         if ( $r['reject_unsafe_urls'] )
 184                                 $url = wp_http_validate_url( $url );
 185                         $url = wp_kses_bad_protocol( $url, array( 'http', 'https', 'ssl' ) );
 186                 }
 187
 188                 $arrURL = @parse_url( $url );
 189
 190                 if ( empty( $url ) || empty( $arrURL['scheme'] ) )
 191                         return new WP_Error('http_request_failed', __('A valid URL was not provided.'));
 192
 193                 if ( $this->block_request( $url ) )
 194                         return new WP_Error( 'http_request_failed', __( 'User has blocked requests through HTTP.' ) );
 195
 196                 /*
 197                  * Determine if this is a https call and pass that on to the transport functions
 198                  * so that we can blacklist the transports that do not support ssl verification
 199                  */
 200                 $r['ssl'] = $arrURL['scheme'] == 'https' || $arrURL['scheme'] == 'ssl';
 201
 202                 // Determine if this request is to OUR install of WordPress.
 203                 $homeURL = parse_url( get_bloginfo( 'url' ) );
 204                 $r['local'] = 'localhost' == $arrURL['host'] || ( isset( $homeURL['host'] ) && $homeURL['host'] == $arrURL['host'] );
 205                 unset( $homeURL );
 206
 207                 /*
 208                  * If we are streaming to a file but no filename was given drop it in the WP temp dir
 209                  * and pick its name using the basename of the $url.
 210                  */
 211                 if ( $r['stream']  && empty( $r['filename'] ) )
 212                         $r['filename'] = get_temp_dir() . basename( $url );
 213
 214                 /*
 215                  * Force some settings if we are streaming to a file and check for existence and perms
 216                  * of destination directory.
 217                  */
 218                 if ( $r['stream'] ) {
 219                         $r['blocking'] = true;
 220                         if ( ! wp_is_writable( dirname( $r['filename'] ) ) )
 221                                 return new WP_Error( 'http_request_failed', __( 'Destination directory for file streaming does not exist or is not writable.' ) );
 222                 }
 223
 224                 if ( is_null( $r['headers'] ) )
 225                         $r['headers'] = array();
 226
 227                 if ( ! is_array( $r['headers'] ) ) {
 228                         $processedHeaders = WP_Http::processHeaders( $r['headers'], $url );
 229                         $r['headers'] = $processedHeaders['headers'];
 230                 }
 231
 232                 if ( isset( $r['headers']['User-Agent'] ) ) {
 233                         $r['user-agent'] = $r['headers']['User-Agent'];
 234                         unset( $r['headers']['User-Agent'] );
 235                 }
 236
 237                 if ( isset( $r['headers']['user-agent'] ) ) {
 238                         $r['user-agent'] = $r['headers']['user-agent'];
 239                         unset( $r['headers']['user-agent'] );
 240                 }
 241
 242                 if ( '1.1' == $r['httpversion'] && !isset( $r['headers']['connection'] ) ) {
 243                         $r['headers']['connection'] = 'close';
 244                 }
 245
 246                 // Construct Cookie: header if any cookies are set.
 247                 WP_Http::buildCookieHeader( $r );
 248
 249                 // Avoid issues where mbstring.func_overload is enabled.
 250                 mbstring_binary_safe_encoding();
 251
 252                 if ( ! isset( $r['headers']['Accept-Encoding'] ) ) {
 253                         if ( $encoding = WP_Http_Encoding::accept_encoding( $url, $r ) )
 254                                 $r['headers']['Accept-Encoding'] = $encoding;
 255                 }
 256
 257                 if ( ( ! is_null( $r['body'] ) && '' != $r['body'] ) || 'POST' == $r['method'] || 'PUT' == $r['method'] ) {
 258                         if ( is_array( $r['body'] ) || is_object( $r['body'] ) ) {
 259                                 $r['body'] = http_build_query( $r['body'], null, '&' );
 260
 261                                 if ( ! isset( $r['headers']['Content-Type'] ) )
 262                                         $r['headers']['Content-Type'] = 'application/x-www-form-urlencoded; charset=' . get_option( 'blog_charset' );
 263                         }
 264
 265                         if ( '' === $r['body'] )
 266                                 $r['body'] = null;
 267
 268                         if ( ! isset( $r['headers']['Content-Length'] ) && ! isset( $r['headers']['content-length'] ) )
 269                                 $r['headers']['Content-Length'] = strlen( $r['body'] );
 270                 }
 271
 272                 $response = $this->_dispatch_request( $url, $r );
 273
 274                 reset_mbstring_encoding();
 275
 276                 if ( is_wp_error( $response ) )
 277                         return $response;
 278
 279                 // Append cookies that were used in this request to the response
 280                 if ( ! empty( $r['cookies'] ) ) {
 281                         $cookies_set = wp_list_pluck( $response['cookies'], 'name' );
 282                         foreach ( $r['cookies'] as $cookie ) {
 283                                 if ( ! in_array( $cookie->name, $cookies_set ) && $cookie->test( $url ) ) {
 284                                         $response['cookies'][] = $cookie;
 285                                 }
 286                         }
 287                 }
 288
 289                 return $response;
 290         }
 291
 292         /**
 293          * Tests which transports are capable of supporting the request.
 294          *
 295          * @since 3.2.0
 296          * @access private
 297          *
 298          * @param array $args Request arguments
 299          * @param string $url URL to Request
 300          *
 301          * @return string|bool Class name for the first transport that claims to support the request. False if no transport claims to support the request.
 302          */
 303         public function _get_first_available_transport( $args, $url = null ) {
 304                 /**
 305                  * Filter which HTTP transports are available and in what order.
 306                  *
 307                  * @since 3.7.0
 308                  *
 309                  * @param array  $value Array of HTTP transports to check. Default array contains
 310                  *                      'curl', and 'streams', in that order.
 311                  * @param array  $args  HTTP request arguments.
 312                  * @param string $url   The URL to request.
 313                  */
 314                 $request_order = apply_filters( 'http_api_transports', array( 'curl', 'streams' ), $args, $url );
 315
 316                 // Loop over each transport on each HTTP request looking for one which will serve this request's needs.
 317                 foreach ( $request_order as $transport ) {
 318                         $class = 'WP_HTTP_' . $transport;
 319
 320                         // Check to see if this transport is a possibility, calls the transport statically.
 321                         if ( !call_user_func( array( $class, 'test' ), $args, $url ) )
 322                                 continue;
 323
 324                         return $class;
 325                 }
 326
 327                 return false;
 328         }
 329
 330         /**
 331          * Dispatches a HTTP request to a supporting transport.
 332          *
 333          * Tests each transport in order to find a transport which matches the request arguments.
 334          * Also caches the transport instance to be used later.
 335          *
 336          * The order for requests is cURL, and then PHP Streams.
 337          *
 338          * @since 3.2.0
 339          * @access private
 340          *
 341          * @param string $url URL to Request
 342          * @param array $args Request arguments
 343          * @return array|WP_Error Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error
 344          */
 345         private function _dispatch_request( $url, $args ) {
 346                 static $transports = array();
 347
 348                 $class = $this->_get_first_available_transport( $args, $url );
 349                 if ( !$class )
 350                         return new WP_Error( 'http_failure', __( 'There are no HTTP transports available which can complete the requested request.' ) );
 351
 352                 // Transport claims to support request, instantiate it and give it a whirl.
 353                 if ( empty( $transports[$class] ) )
 354                         $transports[$class] = new $class;
 355
 356                 $response = $transports[$class]->request( $url, $args );
 357
 358                 /**
 359                  * Fires after an HTTP API response is received and before the response is returned.
 360                  *
 361                  * @since 2.8.0
 362                  *
 363                  * @param array|WP_Error $response HTTP response or WP_Error object.
 364                  * @param string         $context  Context under which the hook is fired.
 365                  * @param string         $class    HTTP transport used.
 366                  * @param array          $args     HTTP request arguments.
 367                  * @param string         $url      The request URL.
 368                  */
 369                 do_action( 'http_api_debug', $response, 'response', $class, $args, $url );
 370
 371                 if ( is_wp_error( $response ) )
 372                         return $response;
 373
 374                 /**
 375                  * Filter the HTTP API response immediately before the response is returned.
 376                  *
 377                  * @since 2.9.0
 378                  *
 379                  * @param array  $response HTTP response.
 380                  * @param array  $args     HTTP request arguments.
 381                  * @param string $url      The request URL.
 382                  */
 383                 return apply_filters( 'http_response', $response, $args, $url );
 384         }
 385
 386         /**
 387          * Uses the POST HTTP method.
 388          *
 389          * Used for sending data that is expected to be in the body.
 390          *
 391          * @access public
 392          * @since 2.7.0
 393          *
 394          * @param string       $url  The request URL.
 395          * @param string|array $args Optional. Override the defaults.
 396          * @return array|WP_Error Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error
 397          */
 398         public function post($url, $args = array()) {
 399                 $defaults = array('method' => 'POST');
 400                 $r = wp_parse_args( $args, $defaults );
 401                 return $this->request($url, $r);
 402         }
 403
 404         /**
 405          * Uses the GET HTTP method.
 406          *
 407          * Used for sending data that is expected to be in the body.
 408          *
 409          * @access public
 410          * @since 2.7.0
 411          *
 412          * @param string $url The request URL.
 413          * @param string|array $args Optional. Override the defaults.
 414          * @return array|WP_Error Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error
 415          */
 416         public function get($url, $args = array()) {
 417                 $defaults = array('method' => 'GET');
 418                 $r = wp_parse_args( $args, $defaults );
 419                 return $this->request($url, $r);
 420         }
 421
 422         /**
 423          * Uses the HEAD HTTP method.
 424          *
 425          * Used for sending data that is expected to be in the body.
 426          *
 427          * @access public
 428          * @since 2.7.0
 429          *
 430          * @param string $url The request URL.
 431          * @param string|array $args Optional. Override the defaults.
 432          * @return array|WP_Error Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error
 433          */
 434         public function head($url, $args = array()) {
 435                 $defaults = array('method' => 'HEAD');
 436                 $r = wp_parse_args( $args, $defaults );
 437                 return $this->request($url, $r);
 438         }
 439
 440         /**
 441          * Parses the responses and splits the parts into headers and body.
 442          *
 443          * @access public
 444          * @static
 445          * @since 2.7.0
 446          *
 447          * @param string $strResponse The full response string
 448          * @return array Array with 'headers' and 'body' keys.
 449          */
 450         public static function processResponse($strResponse) {
 451                 $res = explode("\r\n\r\n", $strResponse, 2);
 452
 453                 return array('headers' => $res[0], 'body' => isset($res[1]) ? $res[1] : '');
 454         }
 455
 456         /**
 457          * Transform header string into an array.
 458          *
 459          * If an array is given then it is assumed to be raw header data with numeric keys with the
 460          * headers as the values. No headers must be passed that were already processed.
 461          *
 462          * @access public
 463          * @static
 464          * @since 2.7.0
 465          *
 466          * @param string|array $headers
 467          * @param string $url The URL that was requested
 468          * @return array Processed string headers. If duplicate headers are encountered,
 469          *                                      Then a numbered array is returned as the value of that header-key.
 470          */
 471         public static function processHeaders( $headers, $url = '' ) {
 472                 // Split headers, one per array element.
 473                 if ( is_string($headers) ) {
 474                         // Tolerate line terminator: CRLF = LF (RFC 2616 19.3).
 475                         $headers = str_replace("\r\n", "\n", $headers);
 476                         /*
 477                          * Unfold folded header fields. LWS = [CRLF] 1*( SP | HT ) <US-ASCII SP, space (32)>,
 478                          * <US-ASCII HT, horizontal-tab (9)> (RFC 2616 2.2).
 479                          */
 480                         $headers = preg_replace('/\n[ \t]/', ' ', $headers);
 481                         // Create the headers array.
 482                         $headers = explode("\n", $headers);
 483                 }
 484
 485                 $response = array('code' => 0, 'message' => '');
 486
 487                 /*
 488                  * If a redirection has taken place, The headers for each page request may have been passed.
 489                  * In this case, determine the final HTTP header and parse from there.
 490                  */
 491                 for ( $i = count($headers)-1; $i >= 0; $i-- ) {
 492                         if ( !empty($headers[$i]) && false === strpos($headers[$i], ':') ) {
 493                                 $headers = array_splice($headers, $i);
 494                                 break;
 495                         }
 496                 }
 497
 498                 $cookies = array();
 499                 $newheaders = array();
 500                 foreach ( (array) $headers as $tempheader ) {
 501                         if ( empty($tempheader) )
 502                                 continue;
 503
 504                         if ( false === strpos($tempheader, ':') ) {
 505                                 $stack = explode(' ', $tempheader, 3);
 506                                 $stack[] = '';
 507                                 list( , $response['code'], $response['message']) = $stack;
 508                                 continue;
 509                         }
 510
 511                         list($key, $value) = explode(':', $tempheader, 2);
 512
 513                         $key = strtolower( $key );
 514                         $value = trim( $value );
 515
 516                         if ( isset( $newheaders[ $key ] ) ) {
 517                                 if ( ! is_array( $newheaders[ $key ] ) )
 518                                         $newheaders[$key] = array( $newheaders[ $key ] );
 519                                 $newheaders[ $key ][] = $value;
 520                         } else {
 521                                 $newheaders[ $key ] = $value;
 522                         }
 523                         if ( 'set-cookie' == $key )
 524                                 $cookies[] = new WP_Http_Cookie( $value, $url );
 525                 }
 526
 527                 return array('response' => $response, 'headers' => $newheaders, 'cookies' => $cookies);
 528         }
 529
 530         /**
 531          * Takes the arguments for a ::request() and checks for the cookie array.
 532          *
 533          * If it's found, then it upgrades any basic name => value pairs to WP_Http_Cookie instances,
 534          * which are each parsed into strings and added to the Cookie: header (within the arguments array).
 535          * Edits the array by reference.
 536          *
 537          * @access public
 538          * @version 2.8.0
 539          * @static
 540          *
 541          * @param array $r Full array of args passed into ::request()
 542          */
 543         public static function buildCookieHeader( &$r ) {
 544                 if ( ! empty($r['cookies']) ) {
 545                         // Upgrade any name => value cookie pairs to WP_HTTP_Cookie instances.
 546                         foreach ( $r['cookies'] as $name => $value ) {
 547                                 if ( ! is_object( $value ) )
 548                                         $r['cookies'][ $name ] = new WP_HTTP_Cookie( array( 'name' => $name, 'value' => $value ) );
 549                         }
 550
 551                         $cookies_header = '';
 552                         foreach ( (array) $r['cookies'] as $cookie ) {
 553                                 $cookies_header .= $cookie->getHeaderValue() . '; ';
 554                         }
 555
 556                         $cookies_header = substr( $cookies_header, 0, -2 );
 557                         $r['headers']['cookie'] = $cookies_header;
 558                 }
 559         }
 560
 561         /**
 562          * Decodes chunk transfer-encoding, based off the HTTP 1.1 specification.
 563          *
 564          * Based off the HTTP http_encoding_dechunk function.
 565          *
 566          * @link http://tools.ietf.org/html/rfc2616#section-19.4.6 Process for chunked decoding.
 567          *
 568          * @access public
 569          * @since 2.7.0
 570          * @static
 571          *
 572          * @param string $body Body content
 573          * @return string Chunked decoded body on success or raw body on failure.
 574          */
 575         public static function chunkTransferDecode( $body ) {
 576                 // The body is not chunked encoded or is malformed.
 577                 if ( ! preg_match( '/^([0-9a-f]+)[^\r\n]*\r\n/i', trim( $body ) ) )
 578                         return $body;
 579
 580                 $parsed_body = '';
 581
 582                 // We'll be altering $body, so need a backup in case of error.
 583                 $body_original = $body;
 584
 585                 while ( true ) {
 586                         $has_chunk = (bool) preg_match( '/^([0-9a-f]+)[^\r\n]*\r\n/i', $body, $match );
 587                         if ( ! $has_chunk || empty( $match[1] ) )
 588                                 return $body_original;
 589
 590                         $length = hexdec( $match[1] );
 591                         $chunk_length = strlen( $match[0] );
 592
 593                         // Parse out the chunk of data.
 594                         $parsed_body .= substr( $body, $chunk_length, $length );
 595
 596                         // Remove the chunk from the raw data.
 597                         $body = substr( $body, $length + $chunk_length );
 598
 599                         // End of the document.
 600                         if ( '0' === trim( $body ) )
 601                                 return $parsed_body;
 602                 }
 603         }
 604
 605         /**
 606          * Block requests through the proxy.
 607          *
 608          * Those who are behind a proxy and want to prevent access to certain hosts may do so. This will
 609          * prevent plugins from working and core functionality, if you don't include api.wordpress.org.
 610          *
 611          * You block external URL requests by defining WP_HTTP_BLOCK_EXTERNAL as true in your wp-config.php
 612          * file and this will only allow localhost and your blog to make requests. The constant
 613          * WP_ACCESSIBLE_HOSTS will allow additional hosts to go through for requests. The format of the
 614          * WP_ACCESSIBLE_HOSTS constant is a comma separated list of hostnames to allow, wildcard domains
 615          * are supported, eg *.wordpress.org will allow for all subdomains of wordpress.org to be contacted.
 616          *
 617          * @since 2.8.0
 618          * @link http://core.trac.wordpress.org/ticket/8927 Allow preventing external requests.
 619          * @link http://core.trac.wordpress.org/ticket/14636 Allow wildcard domains in WP_ACCESSIBLE_HOSTS
 620          *
 621          * @param string $uri URI of url.
 622          * @return bool True to block, false to allow.
 623          */
 624         public function block_request($uri) {
 625                 // We don't need to block requests, because nothing is blocked.
 626                 if ( ! defined( 'WP_HTTP_BLOCK_EXTERNAL' ) || ! WP_HTTP_BLOCK_EXTERNAL )
 627                         return false;
 628
 629                 $check = parse_url($uri);
 630                 if ( ! $check )
 631                         return true;
 632
 633                 $home = parse_url( get_option('siteurl') );
 634
 635                 // Don't block requests back to ourselves by default.
 636                 if ( 'localhost' == $check['host'] || ( isset( $home['host'] ) && $home['host'] == $check['host'] ) ) {
 637                         /**
 638                          * Filter whether to block local requests through the proxy.
 639                          *
 640                          * @since 2.8.0
 641                          *
 642                          * @param bool $block Whether to block local requests through proxy.
 643                          *                    Default false.
 644                          */
 645                         return apply_filters( 'block_local_requests', false );
 646                 }
 647
 648                 if ( !defined('WP_ACCESSIBLE_HOSTS') )
 649                         return true;
 650
 651                 static $accessible_hosts;
 652                 static $wildcard_regex = false;
 653                 if ( null == $accessible_hosts ) {
 654                         $accessible_hosts = preg_split('|,\s*|', WP_ACCESSIBLE_HOSTS);
 655
 656                         if ( false !== strpos(WP_ACCESSIBLE_HOSTS, '*') ) {
 657                                 $wildcard_regex = array();
 658                                 foreach ( $accessible_hosts as $host )
 659                                         $wildcard_regex[] = str_replace( '\*', '.+', preg_quote( $host, '/' ) );
 660                                 $wildcard_regex = '/^(' . implode('|', $wildcard_regex) . ')$/i';
 661                         }
 662                 }
 663
 664                 if ( !empty($wildcard_regex) )
 665                         return !preg_match($wildcard_regex, $check['host']);
 666                 else
 667                         return !in_array( $check['host'], $accessible_hosts ); //Inverse logic, If it's in the array, then we can't access it.
 668
 669         }
 670
 671         public static function make_absolute_url( $maybe_relative_path, $url ) {
 672                 if ( empty( $url ) )
 673                         return $maybe_relative_path;
 674
 675                 // Check for a scheme.
 676                 if ( false !== strpos( $maybe_relative_path, '://' ) )
 677                         return $maybe_relative_path;
 678
 679                 if ( ! $url_parts = @parse_url( $url ) )
 680                         return $maybe_relative_path;
 681
 682                 if ( ! $relative_url_parts = @parse_url( $maybe_relative_path ) )
 683                         return $maybe_relative_path;
 684
 685                 $absolute_path = $url_parts['scheme'] . '://' . $url_parts['host'];
 686                 if ( isset( $url_parts['port'] ) )
 687                         $absolute_path .= ':' . $url_parts['port'];
 688
 689                 // Start off with the Absolute URL path.
 690                 $path = ! empty( $url_parts['path'] ) ? $url_parts['path'] : '/';
 691
 692                 // If it's a root-relative path, then great.
 693                 if ( ! empty( $relative_url_parts['path'] ) && '/' == $relative_url_parts['path'][0] ) {
 694                         $path = $relative_url_parts['path'];
 695
 696                 // Else it's a relative path.
 697                 } elseif ( ! empty( $relative_url_parts['path'] ) ) {
 698                         // Strip off any file components from the absolute path.
 699                         $path = substr( $path, 0, strrpos( $path, '/' ) + 1 );
 700
 701                         // Build the new path.
 702                         $path .= $relative_url_parts['path'];
 703
 704                         // Strip all /path/../ out of the path.
 705                         while ( strpos( $path, '../' ) > 1 ) {
 706                                 $path = preg_replace( '![^/]+/\.\./!', '', $path );
 707                         }
 708
 709                         // Strip any final leading ../ from the path.
 710                         $path = preg_replace( '!^/(\.\./)+!', '', $path );
 711                 }
 712
 713                 // Add the Query string.
 714                 if ( ! empty( $relative_url_parts['query'] ) )
 715                         $path .= '?' . $relative_url_parts['query'];
 716
 717                 return $absolute_path . '/' . ltrim( $path, '/' );
 718         }
 719
 720         /**
 721          * Handles HTTP Redirects and follows them if appropriate.
 722          *
 723          * @since 3.7.0
 724          *
 725          * @param string $url The URL which was requested.
 726          * @param array $args The Arguments which were used to make the request.
 727          * @param array $response The Response of the HTTP request.
 728          * @return false|object False if no redirect is present, a WP_HTTP or WP_Error result otherwise.
 729          */
 730         public static function handle_redirects( $url, $args, $response ) {
 731                 // If no redirects are present, or, redirects were not requested, perform no action.
 732                 if ( ! isset( $response['headers']['location'] ) || 0 === $args['_redirection'] )
 733                         return false;
 734
 735                 // Only perform redirections on redirection http codes.
 736                 if ( $response['response']['code'] > 399 || $response['response']['code'] < 300 )
 737                         return false;
 738
 739                 // Don't redirect if we've run out of redirects.
 740                 if ( $args['redirection']-- <= 0 )
 741                         return new WP_Error( 'http_request_failed', __('Too many redirects.') );
 742
 743                 $redirect_location = $response['headers']['location'];
 744
 745                 // If there were multiple Location headers, use the last header specified.
 746                 if ( is_array( $redirect_location ) )
 747                         $redirect_location = array_pop( $redirect_location );
 748
 749                 $redirect_location = WP_HTTP::make_absolute_url( $redirect_location, $url );
 750
 751                 // POST requests should not POST to a redirected location.
 752                 if ( 'POST' == $args['method'] ) {
 753                         if ( in_array( $response['response']['code'], array( 302, 303 ) ) )
 754                                 $args['method'] = 'GET';
 755                 }
 756
 757                 // Include valid cookies in the redirect process.
 758                 if ( ! empty( $response['cookies'] ) ) {
 759                         foreach ( $response['cookies'] as $cookie ) {
 760                                 if ( $cookie->test( $redirect_location ) )
 761                                         $args['cookies'][] = $cookie;
 762                         }
 763                 }
 764
 765                 return wp_remote_request( $redirect_location, $args );
 766         }
 767
 768         /**
 769          * Determines if a specified string represents an IP address or not.
 770          *
 771          * This function also detects the type of the IP address, returning either
 772          * '4' or '6' to represent a IPv4 and IPv6 address respectively.
 773          * This does not verify if the IP is a valid IP, only that it appears to be
 774          * an IP address.
 775          *
 776          * @see http://home.deds.nl/~aeron/regex/ for IPv6 regex
 777          *
 778          * @since 3.7.0
 779          * @static
 780          *
 781          * @param string $maybe_ip A suspected IP address
 782          * @return integer|bool Upon success, '4' or '6' to represent a IPv4 or IPv6 address, false upon failure
 783          */
 784         public static function is_ip_address( $maybe_ip ) {
 785                 if ( preg_match( '/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/', $maybe_ip ) )
 786                         return 4;
 787
 788                 if ( false !== strpos( $maybe_ip, ':' ) && preg_match( '/^(((?=.*(::))(?!.*\3.+\3))\3?|([\dA-F]{1,4}(\3|:\b|$)|\2))(?4){5}((?4){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i', trim( $maybe_ip, ' []' ) ) )
 789                         return 6;
 790
 791                 return false;
 792         }
 793
 794 }
 795
 796 /**
 797  * HTTP request method uses PHP Streams to retrieve the url.
 798  *
 799  * @since 2.7.0
 800  * @since 3.7.0 Combined with the fsockopen transport and switched to stream_socket_client().
 801  */
 802 class WP_Http_Streams {
 803         /**
 804          * Send a HTTP request to a URI using PHP Streams.
 805          *
 806          * @see WP_Http::request For default options descriptions.
 807          *
 808          * @since 2.7.0
 809          * @since 3.7.0 Combined with the fsockopen transport and switched to stream_socket_client().
 810          *
 811          * @access public
 812          * @param string $url The request URL.
 813          * @param string|array $args Optional. Override the defaults.
 814          * @return array|WP_Error Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error
 815          */
 816         public function request($url, $args = array()) {
 817                 $defaults = array(
 818                         'method' => 'GET', 'timeout' => 5,
 819                         'redirection' => 5, 'httpversion' => '1.0',
 820                         'blocking' => true,
 821                         'headers' => array(), 'body' => null, 'cookies' => array()
 822                 );
 823
 824                 $r = wp_parse_args( $args, $defaults );
 825
 826                 if ( isset($r['headers']['User-Agent']) ) {
 827                         $r['user-agent'] = $r['headers']['User-Agent'];
 828                         unset($r['headers']['User-Agent']);
 829                 } else if ( isset($r['headers']['user-agent']) ) {
 830                         $r['user-agent'] = $r['headers']['user-agent'];
 831                         unset($r['headers']['user-agent']);
 832                 }
 833
 834                 // Construct Cookie: header if any cookies are set.
 835                 WP_Http::buildCookieHeader( $r );
 836
 837                 $arrURL = parse_url($url);
 838
 839                 $connect_host = $arrURL['host'];
 840
 841                 $secure_transport = ( $arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https' );
 842                 if ( ! isset( $arrURL['port'] ) ) {
 843                         if ( $arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https' ) {
 844                                 $arrURL['port'] = 443;
 845                                 $secure_transport = true;
 846                         } else {
 847                                 $arrURL['port'] = 80;
 848                         }
 849                 }
 850
 851                 if ( isset( $r['headers']['Host'] ) || isset( $r['headers']['host'] ) ) {
 852                         if ( isset( $r['headers']['Host'] ) )
 853                                 $arrURL['host'] = $r['headers']['Host'];
 854                         else
 855                                 $arrURL['host'] = $r['headers']['host'];
 856                         unset( $r['headers']['Host'], $r['headers']['host'] );
 857                 }
 858
 859                 /*
 860                  * Certain versions of PHP have issues with 'localhost' and IPv6, It attempts to connect
 861                  * to ::1, which fails when the server is not set up for it. For compatibility, always
 862                  * connect to the IPv4 address.
 863                  */
 864                 if ( 'localhost' == strtolower( $connect_host ) )
 865                         $connect_host = '127.0.0.1';
 866
 867                 $connect_host = $secure_transport ? 'ssl://' . $connect_host : 'tcp://' . $connect_host;
 868
 869                 $is_local = isset( $r['local'] ) && $r['local'];
 870                 $ssl_verify = isset( $r['sslverify'] ) && $r['sslverify'];
 871                 if ( $is_local ) {
 872                         /**
 873                          * Filter whether SSL should be verified for local requests.
 874                          *
 875                          * @since 2.8.0
 876                          *
 877                          * @param bool $ssl_verify Whether to verify the SSL connection. Default true.
 878                          */
 879                         $ssl_verify = apply_filters( 'https_local_ssl_verify', $ssl_verify );
 880                 } elseif ( ! $is_local ) {
 881                         /**
 882                          * Filter whether SSL should be verified for non-local requests.
 883                          *
 884                          * @since 2.8.0
 885                          *
 886                          * @param bool $ssl_verify Whether to verify the SSL connection. Default true.
 887                          */
 888                         $ssl_verify = apply_filters( 'https_ssl_verify', $ssl_verify );
 889                 }
 890
 891                 $proxy = new WP_HTTP_Proxy();
 892
 893                 $context = stream_context_create( array(
 894                         'ssl' => array(
 895                                 'verify_peer' => $ssl_verify,
 896                                 //'CN_match' => $arrURL['host'], // This is handled by self::verify_ssl_certificate()
 897                                 'capture_peer_cert' => $ssl_verify,
 898                                 'SNI_enabled' => true,
 899                                 'cafile' => $r['sslcertificates'],
 900                                 'allow_self_signed' => ! $ssl_verify,
 901                         )
 902                 ) );
 903
 904                 $timeout = (int) floor( $r['timeout'] );
 905                 $utimeout = $timeout == $r['timeout'] ? 0 : 1000000 * $r['timeout'] % 1000000;
 906                 $connect_timeout = max( $timeout, 1 );
 907
 908                 // Store error number.
 909                 $connection_error = null;
 910
 911                 // Store error string.
 912                 $connection_error_str = null;
 913
 914                 if ( !WP_DEBUG ) {
 915                         // In the event that the SSL connection fails, silence the many PHP Warnings.
 916                         if ( $secure_transport )
 917                                 $error_reporting = error_reporting(0);
 918
 919                         if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
 920                                 $handle = @stream_socket_client( 'tcp://' . $proxy->host() . ':' . $proxy->port(), $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );
 921                         else
 922                                 $handle = @stream_socket_client( $connect_host . ':' . $arrURL['port'], $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );
 923
 924                         if ( $secure_transport )
 925                                 error_reporting( $error_reporting );
 926
 927                 } else {
 928                         if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
 929                                 $handle = stream_socket_client( 'tcp://' . $proxy->host() . ':' . $proxy->port(), $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );
 930                         else
 931                                 $handle = stream_socket_client( $connect_host . ':' . $arrURL['port'], $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );
 932                 }
 933
 934                 if ( false === $handle ) {
 935                         // SSL connection failed due to expired/invalid cert, or, OpenSSL configuration is broken.
 936                         if ( $secure_transport && 0 === $connection_error && '' === $connection_error_str )
 937                                 return new WP_Error( 'http_request_failed', __( 'The SSL certificate for the host could not be verified.' ) );
 938
 939                         return new WP_Error('http_request_failed', $connection_error . ': ' . $connection_error_str );
 940                 }
 941
 942                 // Verify that the SSL certificate is valid for this request.
 943                 if ( $secure_transport && $ssl_verify && ! $proxy->is_enabled() ) {
 944                         if ( ! self::verify_ssl_certificate( $handle, $arrURL['host'] ) )
 945                                 return new WP_Error( 'http_request_failed', __( 'The SSL certificate for the host could not be verified.' ) );
 946                 }
 947
 948                 stream_set_timeout( $handle, $timeout, $utimeout );
 949
 950                 if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) //Some proxies require full URL in this field.
 951                         $requestPath = $url;
 952                 else
 953                         $requestPath = $arrURL['path'] . ( isset($arrURL['query']) ? '?' . $arrURL['query'] : '' );
 954
 955                 if ( empty($requestPath) )
 956                         $requestPath .= '/';
 957
 958                 $strHeaders = strtoupper($r['method']) . ' ' . $requestPath . ' HTTP/' . $r['httpversion'] . "\r\n";
 959
 960                 if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
 961                         $strHeaders .= 'Host: ' . $arrURL['host'] . ':' . $arrURL['port'] . "\r\n";
 962                 else
 963                         $strHeaders .= 'Host: ' . $arrURL['host'] . "\r\n";
 964
 965                 if ( isset($r['user-agent']) )
 966                         $strHeaders .= 'User-agent: ' . $r['user-agent'] . "\r\n";
 967
 968                 if ( is_array($r['headers']) ) {
 969                         foreach ( (array) $r['headers'] as $header => $headerValue )
 970                                 $strHeaders .= $header . ': ' . $headerValue . "\r\n";
 971                 } else {
 972                         $strHeaders .= $r['headers'];
 973                 }
 974
 975                 if ( $proxy->use_authentication() )
 976                         $strHeaders .= $proxy->authentication_header() . "\r\n";
 977
 978                 $strHeaders .= "\r\n";
 979
 980                 if ( ! is_null($r['body']) )
 981                         $strHeaders .= $r['body'];
 982
 983                 fwrite($handle, $strHeaders);
 984
 985                 if ( ! $r['blocking'] ) {
 986                         stream_set_blocking( $handle, 0 );
 987                         fclose( $handle );
 988                         return array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() );
 989                 }
 990
 991                 $strResponse = '';
 992                 $bodyStarted = false;
 993                 $keep_reading = true;
 994                 $block_size = 4096;
 995                 if ( isset( $r['limit_response_size'] ) )
 996                         $block_size = min( $block_size, $r['limit_response_size'] );
 997
 998                 // If streaming to a file setup the file handle.
 999                 if ( $r['stream'] ) {
1000                         if ( ! WP_DEBUG )
1001                                 $stream_handle = @fopen( $r['filename'], 'w+' );
1002                         else
1003                                 $stream_handle = fopen( $r['filename'], 'w+' );
1004                         if ( ! $stream_handle )
1005                                 return new WP_Error( 'http_request_failed', sprintf( __( 'Could not open handle for fopen() to %s' ), $r['filename'] ) );
1006
1007                         $bytes_written = 0;
1008                         while ( ! feof($handle) && $keep_reading ) {
1009                                 $block = fread( $handle, $block_size );
1010                                 if ( ! $bodyStarted ) {
1011                                         $strResponse .= $block;
1012                                         if ( strpos( $strResponse, "\r\n\r\n" ) ) {
1013                                                 $process = WP_Http::processResponse( $strResponse );
1014                                                 $bodyStarted = true;
1015                                                 $block = $process['body'];
1016                                                 unset( $strResponse );
1017                                                 $process['body'] = '';
1018                                         }
1019                                 }
1020
1021                                 $this_block_size = strlen( $block );
1022
1023                                 if ( isset( $r['limit_response_size'] ) && ( $bytes_written + $this_block_size ) > $r['limit_response_size'] )
1024                                         $block = substr( $block, 0, ( $r['limit_response_size'] - $bytes_written ) );
1025
1026                                 $bytes_written_to_file = fwrite( $stream_handle, $block );
1027
1028                                 if ( $bytes_written_to_file != $this_block_size ) {
1029                                         fclose( $handle );
1030                                         fclose( $stream_handle );
1031                                         return new WP_Error( 'http_request_failed', __( 'Failed to write request to temporary file.' ) );
1032                                 }
1033
1034                                 $bytes_written += $bytes_written_to_file;
1035
1036                                 $keep_reading = !isset( $r['limit_response_size'] ) || $bytes_written < $r['limit_response_size'];
1037                         }
1038
1039                         fclose( $stream_handle );
1040
1041                 } else {
1042                         $header_length = 0;
1043                         while ( ! feof( $handle ) && $keep_reading ) {
1044                                 $block = fread( $handle, $block_size );
1045                                 $strResponse .= $block;
1046                                 if ( ! $bodyStarted && strpos( $strResponse, "\r\n\r\n" ) ) {
1047                                         $header_length = strpos( $strResponse, "\r\n\r\n" ) + 4;
1048                                         $bodyStarted = true;
1049                                 }
1050                                 $keep_reading = ( ! $bodyStarted || !isset( $r['limit_response_size'] ) || strlen( $strResponse ) < ( $header_length + $r['limit_response_size'] ) );
1051                         }
1052
1053                         $process = WP_Http::processResponse( $strResponse );
1054                         unset( $strResponse );
1055
1056                 }
1057
1058                 fclose( $handle );
1059
1060                 $arrHeaders = WP_Http::processHeaders( $process['headers'], $url );
1061
1062                 $response = array(
1063                         'headers' => $arrHeaders['headers'],
1064                         // Not yet processed.
1065                         'body' => null,
1066                         'response' => $arrHeaders['response'],
1067                         'cookies' => $arrHeaders['cookies'],
1068                         'filename' => $r['filename']
1069                 );
1070
1071                 // Handle redirects.
1072                 if ( false !== ( $redirect_response = WP_HTTP::handle_redirects( $url, $r, $response ) ) )
1073                         return $redirect_response;
1074
1075                 // If the body was chunk encoded, then decode it.
1076                 if ( ! empty( $process['body'] ) && isset( $arrHeaders['headers']['transfer-encoding'] ) && 'chunked' == $arrHeaders['headers']['transfer-encoding'] )
1077                         $process['body'] = WP_Http::chunkTransferDecode($process['body']);
1078
1079                 if ( true === $r['decompress'] && true === WP_Http_Encoding::should_decode($arrHeaders['headers']) )
1080                         $process['body'] = WP_Http_Encoding::decompress( $process['body'] );
1081
1082                 if ( isset( $r['limit_response_size'] ) && strlen( $process['body'] ) > $r['limit_response_size'] )
1083                         $process['body'] = substr( $process['body'], 0, $r['limit_response_size'] );
1084
1085                 $response['body'] = $process['body'];
1086
1087                 return $response;
1088         }
1089
1090         /**
1091          * Verifies the received SSL certificate against it's Common Names and subjectAltName fields
1092          *
1093          * PHP's SSL verifications only verify that it's a valid Certificate, it doesn't verify if
1094          * the certificate is valid for the hostname which was requested.
1095          * This function verifies the requested hostname against certificate's subjectAltName field,
1096          * if that is empty, or contains no DNS entries, a fallback to the Common Name field is used.
1097          *
1098          * IP Address support is included if the request is being made to an IP address.
1099          *
1100          * @since 3.7.0
1101          * @static
1102          *
1103          * @param stream $stream The PHP Stream which the SSL request is being made over
1104          * @param string $host The hostname being requested
1105          * @return bool If the cerficiate presented in $stream is valid for $host
1106          */
1107         public static function verify_ssl_certificate( $stream, $host ) {
1108                 $context_options = stream_context_get_options( $stream );
1109
1110                 if ( empty( $context_options['ssl']['peer_certificate'] ) )
1111                         return false;
1112
1113                 $cert = openssl_x509_parse( $context_options['ssl']['peer_certificate'] );
1114                 if ( ! $cert )
1115                         return false;
1116
1117                 /*
1118                  * If the request is being made to an IP address, we'll validate against IP fields
1119                  * in the cert (if they exist)
1120                  */
1121                 $host_type = ( WP_HTTP::is_ip_address( $host ) ? 'ip' : 'dns' );
1122
1123                 $certificate_hostnames = array();
1124                 if ( ! empty( $cert['extensions']['subjectAltName'] ) ) {
1125                         $match_against = preg_split( '/,\s*/', $cert['extensions']['subjectAltName'] );
1126                         foreach ( $match_against as $match ) {
1127                                 list( $match_type, $match_host ) = explode( ':', $match );
1128                                 if ( $host_type == strtolower( trim( $match_type ) ) ) // IP: or DNS:
1129                                         $certificate_hostnames[] = strtolower( trim( $match_host ) );
1130                         }
1131                 } elseif ( !empty( $cert['subject']['CN'] ) ) {
1132                         // Only use the CN when the certificate includes no subjectAltName extension.
1133                         $certificate_hostnames[] = strtolower( $cert['subject']['CN'] );
1134                 }
1135
1136                 // Exact hostname/IP matches.
1137                 if ( in_array( strtolower( $host ), $certificate_hostnames ) )
1138                         return true;
1139
1140                 // IP's can't be wildcards, Stop processing.
1141                 if ( 'ip' == $host_type )
1142                         return false;
1143
1144                 // Test to see if the domain is at least 2 deep for wildcard support.
1145                 if ( substr_count( $host, '.' ) < 2 )
1146                         return false;
1147
1148                 // Wildcard subdomains certs (*.example.com) are valid for a.example.com but not a.b.example.com.
1149                 $wildcard_host = preg_replace( '/^[^.]+\./', '*.', $host );
1150
1151                 return in_array( strtolower( $wildcard_host ), $certificate_hostnames );
1152         }
1153
1154         /**
1155          * Whether this class can be used for retrieving a URL.
1156          *
1157          * @static
1158          * @access public
1159          * @since 2.7.0
1160          * @since 3.7.0 Combined with the fsockopen transport and switched to stream_socket_client().
1161          *
1162          * @return boolean False means this class can not be used, true means it can.
1163          */
1164         public static function test( $args = array() ) {
1165                 if ( ! function_exists( 'stream_socket_client' ) )
1166                         return false;
1167
1168                 $is_ssl = isset( $args['ssl'] ) && $args['ssl'];
1169
1170                 if ( $is_ssl ) {
1171                         if ( ! extension_loaded( 'openssl' ) )
1172                                 return false;
1173                         if ( ! function_exists( 'openssl_x509_parse' ) )
1174                                 return false;
1175                 }
1176
1177                 /**
1178                  * Filter whether streams can be used as a transport for retrieving a URL.
1179                  *
1180                  * @since 2.7.0
1181                  *
1182                  * @param bool  $use_class Whether the class can be used. Default true.
1183                  * @param array $args      Request arguments.
1184                  */
1185                 return apply_filters( 'use_streams_transport', true, $args );
1186         }
1187 }
1188
1189 /**
1190  * Deprecated HTTP Transport method which used fsockopen.
1191  *
1192  * This class is not used, and is included for backwards compatibility only.
1193  * All code should make use of WP_HTTP directly through it's API.
1194  *
1195  * @see WP_HTTP::request
1196  *
1197  * @since 2.7.0
1198  * @deprecated 3.7.0 Please use WP_HTTP::request() directly
1199  */
1200 class WP_HTTP_Fsockopen extends WP_HTTP_Streams {
1201         // For backwards compatibility for users who are using the class directly.
1202 }
1203
1204 /**
1205  * HTTP request method uses Curl extension to retrieve the url.
1206  *
1207  * Requires the Curl extension to be installed.
1208  *
1209  * @package WordPress
1210  * @subpackage HTTP
1211  * @since 2.7.0
1212  */
1213 class WP_Http_Curl {
1214
1215         /**
1216          * Temporary header storage for during requests.
1217          *
1218          * @since 3.2.0
1219          * @access private
1220          * @var string
1221          */
1222         private $headers = '';
1223
1224         /**
1225          * Temporary body storage for during requests.
1226          *
1227          * @since 3.6.0
1228          * @access private
1229          * @var string
1230          */
1231         private $body = '';
1232
1233         /**
1234          * The maximum amount of data to receive from the remote server.
1235          *
1236          * @since 3.6.0
1237          * @access private
1238          * @var int
1239          */
1240         private $max_body_length = false;
1241
1242         /**
1243          * The file resource used for streaming to file.
1244          *
1245          * @since 3.6.0
1246          * @access private
1247          * @var resource
1248          */
1249         private $stream_handle = false;
1250
1251         /**
1252          * Send a HTTP request to a URI using cURL extension.
1253          *
1254          * @access public
1255          * @since 2.7.0
1256          *
1257          * @param string $url The request URL.
1258          * @param string|array $args Optional. Override the defaults.
1259          * @return array|WP_Error Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error
1260          */
1261         public function request($url, $args = array()) {
1262                 $defaults = array(
1263                         'method' => 'GET', 'timeout' => 5,
1264                         'redirection' => 5, 'httpversion' => '1.0',
1265                         'blocking' => true,
1266                         'headers' => array(), 'body' => null, 'cookies' => array()
1267                 );
1268
1269                 $r = wp_parse_args( $args, $defaults );
1270
1271                 if ( isset($r['headers']['User-Agent']) ) {
1272                         $r['user-agent'] = $r['headers']['User-Agent'];
1273                         unset($r['headers']['User-Agent']);
1274                 } else if ( isset($r['headers']['user-agent']) ) {
1275                         $r['user-agent'] = $r['headers']['user-agent'];
1276                         unset($r['headers']['user-agent']);
1277                 }
1278
1279                 // Construct Cookie: header if any cookies are set.
1280                 WP_Http::buildCookieHeader( $r );
1281
1282                 $handle = curl_init();
1283
1284                 // cURL offers really easy proxy support.
1285                 $proxy = new WP_HTTP_Proxy();
1286
1287                 if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) {
1288
1289                         curl_setopt( $handle, CURLOPT_PROXYTYPE, CURLPROXY_HTTP );
1290                         curl_setopt( $handle, CURLOPT_PROXY, $proxy->host() );
1291                         curl_setopt( $handle, CURLOPT_PROXYPORT, $proxy->port() );
1292
1293                         if ( $proxy->use_authentication() ) {
1294                                 curl_setopt( $handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY );
1295                                 curl_setopt( $handle, CURLOPT_PROXYUSERPWD, $proxy->authentication() );
1296                         }
1297                 }
1298
1299                 $is_local = isset($r['local']) && $r['local'];
1300                 $ssl_verify = isset($r['sslverify']) && $r['sslverify'];
1301                 if ( $is_local ) {
1302                         /** This filter is documented in wp-includes/class-http.php */
1303                         $ssl_verify = apply_filters( 'https_local_ssl_verify', $ssl_verify );
1304                 } elseif ( ! $is_local ) {
1305                         /** This filter is documented in wp-includes/class-http.php */
1306                         $ssl_verify = apply_filters( 'https_ssl_verify', $ssl_verify );
1307                 }
1308
1309                 /*
1310                  * CURLOPT_TIMEOUT and CURLOPT_CONNECTTIMEOUT expect integers. Have to use ceil since.
1311                  * a value of 0 will allow an unlimited timeout.
1312                  */
1313                 $timeout = (int) ceil( $r['timeout'] );
1314                 curl_setopt( $handle, CURLOPT_CONNECTTIMEOUT, $timeout );
1315                 curl_setopt( $handle, CURLOPT_TIMEOUT, $timeout );
1316
1317                 curl_setopt( $handle, CURLOPT_URL, $url);
1318                 curl_setopt( $handle, CURLOPT_RETURNTRANSFER, true );
1319                 curl_setopt( $handle, CURLOPT_SSL_VERIFYHOST, ( $ssl_verify === true ) ? 2 : false );
1320                 curl_setopt( $handle, CURLOPT_SSL_VERIFYPEER, $ssl_verify );
1321                 curl_setopt( $handle, CURLOPT_CAINFO, $r['sslcertificates'] );
1322                 curl_setopt( $handle, CURLOPT_USERAGENT, $r['user-agent'] );
1323
1324                 /*
1325                  * The option doesn't work with safe mode or when open_basedir is set, and there's
1326                  * a bug #17490 with redirected POST requests, so handle redirections outside Curl.
1327                  */
1328                 curl_setopt( $handle, CURLOPT_FOLLOWLOCATION, false );
1329                 if ( defined( 'CURLOPT_PROTOCOLS' ) ) // PHP 5.2.10 / cURL 7.19.4
1330                         curl_setopt( $handle, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS );
1331
1332                 switch ( $r['method'] ) {
1333                         case 'HEAD':
1334                                 curl_setopt( $handle, CURLOPT_NOBODY, true );
1335                                 break;
1336                         case 'POST':
1337                                 curl_setopt( $handle, CURLOPT_POST, true );
1338                                 curl_setopt( $handle, CURLOPT_POSTFIELDS, $r['body'] );
1339                                 break;
1340                         case 'PUT':
1341                                 curl_setopt( $handle, CURLOPT_CUSTOMREQUEST, 'PUT' );
1342                                 curl_setopt( $handle, CURLOPT_POSTFIELDS, $r['body'] );
1343                                 break;
1344                         default:
1345                                 curl_setopt( $handle, CURLOPT_CUSTOMREQUEST, $r['method'] );
1346                                 if ( ! is_null( $r['body'] ) )
1347                                         curl_setopt( $handle, CURLOPT_POSTFIELDS, $r['body'] );
1348                                 break;
1349                 }
1350
1351                 if ( true === $r['blocking'] ) {
1352                         curl_setopt( $handle, CURLOPT_HEADERFUNCTION, array( $this, 'stream_headers' ) );
1353                         curl_setopt( $handle, CURLOPT_WRITEFUNCTION, array( $this, 'stream_body' ) );
1354                 }
1355
1356                 curl_setopt( $handle, CURLOPT_HEADER, false );
1357
1358                 if ( isset( $r['limit_response_size'] ) )
1359                         $this->max_body_length = intval( $r['limit_response_size'] );
1360                 else
1361                         $this->max_body_length = false;
1362
1363                 // If streaming to a file open a file handle, and setup our curl streaming handler.
1364                 if ( $r['stream'] ) {
1365                         if ( ! WP_DEBUG )
1366                                 $this->stream_handle = @fopen( $r['filename'], 'w+' );
1367                         else
1368                                 $this->stream_handle = fopen( $r['filename'], 'w+' );
1369                         if ( ! $this->stream_handle )
1370                                 return new WP_Error( 'http_request_failed', sprintf( __( 'Could not open handle for fopen() to %s' ), $r['filename'] ) );
1371                 } else {
1372                         $this->stream_handle = false;
1373                 }
1374
1375                 if ( !empty( $r['headers'] ) ) {
1376                         // cURL expects full header strings in each element.
1377                         $headers = array();
1378                         foreach ( $r['headers'] as $name => $value ) {
1379                                 $headers[] = "{$name}: $value";
1380                         }
1381                         curl_setopt( $handle, CURLOPT_HTTPHEADER, $headers );
1382                 }
1383
1384                 if ( $r['httpversion'] == '1.0' )
1385                         curl_setopt( $handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0 );
1386                 else
1387                         curl_setopt( $handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1 );
1388
1389                 /**
1390                  * Fires before the cURL request is executed.
1391                  *
1392                  * Cookies are not currently handled by the HTTP API. This action allows
1393                  * plugins to handle cookies themselves.
1394                  *
1395                  * @since 2.8.0
1396                  *
1397                  * @param resource &$handle The cURL handle returned by curl_init().
1398                  * @param array    $r       The HTTP request arguments.
1399                  * @param string   $url     The request URL.
1400                  */
1401                 do_action_ref_array( 'http_api_curl', array( &$handle, $r, $url ) );
1402
1403                 // We don't need to return the body, so don't. Just execute request and return.
1404                 if ( ! $r['blocking'] ) {
1405                         curl_exec( $handle );
1406
1407                         if ( $curl_error = curl_error( $handle ) ) {
1408                                 curl_close( $handle );
1409                                 return new WP_Error( 'http_request_failed', $curl_error );
1410                         }
1411                         if ( in_array( curl_getinfo( $handle, CURLINFO_HTTP_CODE ), array( 301, 302 ) ) ) {
1412                                 curl_close( $handle );
1413                                 return new WP_Error( 'http_request_failed', __( 'Too many redirects.' ) );
1414                         }
1415
1416                         curl_close( $handle );
1417                         return array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() );
1418                 }
1419
1420                 curl_exec( $handle );
1421                 $theHeaders = WP_Http::processHeaders( $this->headers, $url );
1422                 $theBody = $this->body;
1423
1424                 $this->headers = '';
1425                 $this->body = '';
1426
1427                 $curl_error = curl_errno( $handle );
1428
1429                 // If an error occurred, or, no response.
1430                 if ( $curl_error || ( 0 == strlen( $theBody ) && empty( $theHeaders['headers'] ) ) ) {
1431                         if ( CURLE_WRITE_ERROR /* 23 */ == $curl_error &&  $r['stream'] ) {
1432                                 fclose( $this->stream_handle );
1433                                 return new WP_Error( 'http_request_failed', __( 'Failed to write request to temporary file.' ) );
1434                         }
1435                         if ( $curl_error = curl_error( $handle ) ) {
1436                                 curl_close( $handle );
1437                                 return new WP_Error( 'http_request_failed', $curl_error );
1438                         }
1439                         if ( in_array( curl_getinfo( $handle, CURLINFO_HTTP_CODE ), array( 301, 302 ) ) ) {
1440                                 curl_close( $handle );
1441                                 return new WP_Error( 'http_request_failed', __( 'Too many redirects.' ) );
1442                         }
1443                 }
1444
1445                 $response = array();
1446                 $response['code'] = curl_getinfo( $handle, CURLINFO_HTTP_CODE );
1447                 $response['message'] = get_status_header_desc($response['code']);
1448
1449                 curl_close( $handle );
1450
1451                 if ( $r['stream'] )
1452                         fclose( $this->stream_handle );
1453
1454                 $response = array(
1455                         'headers' => $theHeaders['headers'],
1456                         'body' => null,
1457                         'response' => $response,
1458                         'cookies' => $theHeaders['cookies'],
1459                         'filename' => $r['filename']
1460                 );
1461
1462                 // Handle redirects.
1463                 if ( false !== ( $redirect_response = WP_HTTP::handle_redirects( $url, $r, $response ) ) )
1464                         return $redirect_response;
1465
1466                 if ( true === $r['decompress'] && true === WP_Http_Encoding::should_decode($theHeaders['headers']) )
1467                         $theBody = WP_Http_Encoding::decompress( $theBody );
1468
1469                 $response['body'] = $theBody;
1470
1471                 return $response;
1472         }
1473
1474         /**
1475          * Grab the headers of the cURL request
1476          *
1477          * Each header is sent individually to this callback, so we append to the $header property for temporary storage
1478          *
1479          * @since 3.2.0
1480          * @access private
1481          * @return int
1482          */
1483         private function stream_headers( $handle, $headers ) {
1484                 $this->headers .= $headers;
1485                 return strlen( $headers );
1486         }
1487
1488         /**
1489          * Grab the body of the cURL request
1490          *
1491          * The contents of the document are passed in chunks, so we append to the $body property for temporary storage.
1492          * Returning a length shorter than the length of $data passed in will cause cURL to abort the request as "completed"
1493          *
1494          * @since 3.6.0
1495          * @access private
1496          * @return int
1497          */
1498         private function stream_body( $handle, $data ) {
1499                 $data_length = strlen( $data );
1500
1501                 if ( $this->max_body_length && ( strlen( $this->body ) + $data_length ) > $this->max_body_length )
1502                         $data = substr( $data, 0, ( $this->max_body_length - $data_length ) );
1503
1504                 if ( $this->stream_handle ) {
1505                         $bytes_written = fwrite( $this->stream_handle, $data );
1506                 } else {
1507                         $this->body .= $data;
1508                         $bytes_written = $data_length;
1509                 }
1510
1511                 // Upon event of this function returning less than strlen( $data ) curl will error with CURLE_WRITE_ERROR.
1512                 return $bytes_written;
1513         }
1514
1515         /**
1516          * Whether this class can be used for retrieving an URL.
1517          *
1518          * @static
1519          * @since 2.7.0
1520          *
1521          * @return boolean False means this class can not be used, true means it can.
1522          */
1523         public static function test( $args = array() ) {
1524                 if ( ! function_exists( 'curl_init' ) || ! function_exists( 'curl_exec' ) )
1525                         return false;
1526
1527                 $is_ssl = isset( $args['ssl'] ) && $args['ssl'];
1528
1529                 if ( $is_ssl ) {
1530                         $curl_version = curl_version();
1531                         // Check whether this cURL version support SSL requests.
1532                         if ( ! (CURL_VERSION_SSL & $curl_version['features']) )
1533                                 return false;
1534                 }
1535
1536                 /**
1537                  * Filter whether cURL can be used as a transport for retrieving a URL.
1538                  *
1539                  * @since 2.7.0
1540                  *
1541                  * @param bool  $use_class Whether the class can be used. Default true.
1542                  * @param array $args      An array of request arguments.
1543                  */
1544                 return apply_filters( 'use_curl_transport', true, $args );
1545         }
1546 }
1547
1548 /**
1549  * Adds Proxy support to the WordPress HTTP API.
1550  *
1551  * There are caveats to proxy support. It requires that defines be made in the wp-config.php file to
1552  * enable proxy support. There are also a few filters that plugins can hook into for some of the
1553  * constants.
1554  *
1555  * Please note that only BASIC authentication is supported by most transports.
1556  * cURL MAY support more methods (such as NTLM authentication) depending on your environment.
1557  *
1558  * The constants are as follows:
1559  * <ol>
1560  * <li>WP_PROXY_HOST - Enable proxy support and host for connecting.</li>
1561  * <li>WP_PROXY_PORT - Proxy port for connection. No default, must be defined.</li>
1562  * <li>WP_PROXY_USERNAME - Proxy username, if it requires authentication.</li>
1563  * <li>WP_PROXY_PASSWORD - Proxy password, if it requires authentication.</li>
1564  * <li>WP_PROXY_BYPASS_HOSTS - Will prevent the hosts in this list from going through the proxy.
1565  * You do not need to have localhost and the blog host in this list, because they will not be passed
1566  * through the proxy. The list should be presented in a comma separated list, wildcards using * are supported, eg. *.wordpress.org</li>
1567  * </ol>
1568  *
1569  * An example can be as seen below.
1570  * <code>
1571  * define('WP_PROXY_HOST', '192.168.84.101');
1572  * define('WP_PROXY_PORT', '8080');
1573  * define('WP_PROXY_BYPASS_HOSTS', 'localhost, www.example.com, *.wordpress.org');
1574  * </code>
1575  *
1576  * @link http://core.trac.wordpress.org/ticket/4011 Proxy support ticket in WordPress.
1577  * @link http://core.trac.wordpress.org/ticket/14636 Allow wildcard domains in WP_PROXY_BYPASS_HOSTS
1578  * @since 2.8.0
1579  */
1580 class WP_HTTP_Proxy {
1581
1582         /**
1583          * Whether proxy connection should be used.
1584          *
1585          * @since 2.8.0
1586          *
1587          * @use WP_PROXY_HOST
1588          * @use WP_PROXY_PORT
1589          *
1590          * @return bool
1591          */
1592         public function is_enabled() {
1593                 return defined('WP_PROXY_HOST') && defined('WP_PROXY_PORT');
1594         }
1595
1596         /**
1597          * Whether authentication should be used.
1598          *
1599          * @since 2.8.0
1600          *
1601          * @use WP_PROXY_USERNAME
1602          * @use WP_PROXY_PASSWORD
1603          *
1604          * @return bool
1605          */
1606         public function use_authentication() {
1607                 return defined('WP_PROXY_USERNAME') && defined('WP_PROXY_PASSWORD');
1608         }
1609
1610         /**
1611          * Retrieve the host for the proxy server.
1612          *
1613          * @since 2.8.0
1614          *
1615          * @return string
1616          */
1617         public function host() {
1618                 if ( defined('WP_PROXY_HOST') )
1619                         return WP_PROXY_HOST;
1620
1621                 return '';
1622         }
1623
1624         /**
1625          * Retrieve the port for the proxy server.
1626          *
1627          * @since 2.8.0
1628          *
1629          * @return string
1630          */
1631         public function port() {
1632                 if ( defined('WP_PROXY_PORT') )
1633                         return WP_PROXY_PORT;
1634
1635                 return '';
1636         }
1637
1638         /**
1639          * Retrieve the username for proxy authentication.
1640          *
1641          * @since 2.8.0
1642          *
1643          * @return string
1644          */
1645         public function username() {
1646                 if ( defined('WP_PROXY_USERNAME') )
1647                         return WP_PROXY_USERNAME;
1648
1649                 return '';
1650         }
1651
1652         /**
1653          * Retrieve the password for proxy authentication.
1654          *
1655          * @since 2.8.0
1656          *
1657          * @return string
1658          */
1659         public function password() {
1660                 if ( defined('WP_PROXY_PASSWORD') )
1661                         return WP_PROXY_PASSWORD;
1662
1663                 return '';
1664         }
1665
1666         /**
1667          * Retrieve authentication string for proxy authentication.
1668          *
1669          * @since 2.8.0
1670          *
1671          * @return string
1672          */
1673         public function authentication() {
1674                 return $this->username() . ':' . $this->password();
1675         }
1676
1677         /**
1678          * Retrieve header string for proxy authentication.
1679          *
1680          * @since 2.8.0
1681          *
1682          * @return string
1683          */
1684         public function authentication_header() {
1685                 return 'Proxy-Authorization: Basic ' . base64_encode( $this->authentication() );
1686         }
1687
1688         /**
1689          * Whether URL should be sent through the proxy server.
1690          *
1691          * We want to keep localhost and the blog URL from being sent through the proxy server, because
1692          * some proxies can not handle this. We also have the constant available for defining other
1693          * hosts that won't be sent through the proxy.
1694          *
1695          * @uses WP_PROXY_BYPASS_HOSTS
1696          * @since 2.8.0
1697          *
1698          * @param string $uri URI to check.
1699          * @return bool True, to send through the proxy and false if, the proxy should not be used.
1700          */
1701         public function send_through_proxy( $uri ) {
1702                 /*
1703                  * parse_url() only handles http, https type URLs, and will emit E_WARNING on failure.
1704                  * This will be displayed on blogs, which is not reasonable.
1705                  */
1706                 $check = @parse_url($uri);
1707
1708                 // Malformed URL, can not process, but this could mean ssl, so let through anyway.
1709                 if ( $check === false )
1710                         return true;
1711
1712                 $home = parse_url( get_option('siteurl') );
1713
1714                 /**
1715                  * Filter whether to preempt sending the request through the proxy server.
1716                  *
1717                  * Returning false will bypass the proxy; returning true will send
1718                  * the request through the proxy. Returning null bypasses the filter.
1719                  *
1720                  * @since 3.5.0
1721                  *
1722                  * @param null   $override Whether to override the request result. Default null.
1723                  * @param string $uri      URL to check.
1724                  * @param array  $check    Associative array result of parsing the URI.
1725                  * @param array  $home     Associative array result of parsing the site URL.
1726                  */
1727                 $result = apply_filters( 'pre_http_send_through_proxy', null, $uri, $check, $home );
1728                 if ( ! is_null( $result ) )
1729                         return $result;
1730
1731                 if ( 'localhost' == $check['host'] || ( isset( $home['host'] ) && $home['host'] == $check['host'] ) )
1732                         return false;
1733
1734                 if ( !defined('WP_PROXY_BYPASS_HOSTS') )
1735                         return true;
1736
1737                 static $bypass_hosts;
1738                 static $wildcard_regex = false;
1739                 if ( null == $bypass_hosts ) {
1740                         $bypass_hosts = preg_split('|,\s*|', WP_PROXY_BYPASS_HOSTS);
1741
1742                         if ( false !== strpos(WP_PROXY_BYPASS_HOSTS, '*') ) {
1743                                 $wildcard_regex = array();
1744                                 foreach ( $bypass_hosts as $host )
1745                                         $wildcard_regex[] = str_replace( '\*', '.+', preg_quote( $host, '/' ) );
1746                                 $wildcard_regex = '/^(' . implode('|', $wildcard_regex) . ')$/i';
1747                         }
1748                 }
1749
1750                 if ( !empty($wildcard_regex) )
1751                         return !preg_match($wildcard_regex, $check['host']);
1752                 else
1753                         return !in_array( $check['host'], $bypass_hosts );
1754         }
1755 }
1756 /**
1757  * Internal representation of a single cookie.
1758  *
1759  * Returned cookies are represented using this class, and when cookies are set, if they are not
1760  * already a WP_Http_Cookie() object, then they are turned into one.
1761  *
1762  * @todo The WordPress convention is to use underscores instead of camelCase for function and method
1763  * names. Need to switch to use underscores instead for the methods.
1764  *
1765  * @package WordPress
1766  * @subpackage HTTP
1767  * @since 2.8.0
1768  */
1769 class WP_Http_Cookie {
1770
1771         /**
1772          * Cookie name.
1773          *
1774          * @since 2.8.0
1775          * @var string
1776          */
1777         public $name;
1778
1779         /**
1780          * Cookie value.
1781          *
1782          * @since 2.8.0
1783          * @var string
1784          */
1785         public $value;
1786
1787         /**
1788          * When the cookie expires.
1789          *
1790          * @since 2.8.0
1791          * @var string
1792          */
1793         public $expires;
1794
1795         /**
1796          * Cookie URL path.
1797          *
1798          * @since 2.8.0
1799          * @var string
1800          */
1801         public $path;
1802
1803         /**
1804          * Cookie Domain.
1805          *
1806          * @since 2.8.0
1807          * @var string
1808          */
1809         public $domain;
1810
1811         /**
1812          * Sets up this cookie object.
1813          *
1814          * The parameter $data should be either an associative array containing the indices names below
1815          * or a header string detailing it.
1816          *
1817          * @since 2.8.0
1818          * @access public
1819          *
1820          * @param string|array $data {
1821          *     Raw cookie data as header string or data array.
1822          *
1823          *     @type string     $name    Cookie name.
1824          *     @type mixed      $value   Value. Should NOT already be urlencoded.
1825          *     @type string|int $expires Optional. Unix timestamp or formatted date. Default null.
1826          *     @type string     $path    Optional. Path. Default '/'.
1827          *     @type string     $domain  Optional. Domain. Default host of parsed $requested_url.
1828          *     @type int        $port    Optional. Port. Default null.
1829          * }
1830          * @param string       $requested_url The URL which the cookie was set on, used for default $domain
1831          *                                    and $port values.
1832          */
1833         public function __construct( $data, $requested_url = '' ) {
1834                 if ( $requested_url )
1835                         $arrURL = @parse_url( $requested_url );
1836                 if ( isset( $arrURL['host'] ) )
1837                         $this->domain = $arrURL['host'];
1838                 $this->path = isset( $arrURL['path'] ) ? $arrURL['path'] : '/';
1839                 if (  '/' != substr( $this->path, -1 ) )
1840                         $this->path = dirname( $this->path ) . '/';
1841
1842                 if ( is_string( $data ) ) {
1843                         // Assume it's a header string direct from a previous request.
1844                         $pairs = explode( ';', $data );
1845
1846                         // Special handling for first pair; name=value. Also be careful of "=" in value.
1847                         $name  = trim( substr( $pairs[0], 0, strpos( $pairs[0], '=' ) ) );
1848                         $value = substr( $pairs[0], strpos( $pairs[0], '=' ) + 1 );
1849                         $this->name  = $name;
1850                         $this->value = urldecode( $value );
1851
1852                         // Removes name=value from items.
1853                         array_shift( $pairs );
1854
1855                         // Set everything else as a property.
1856                         foreach ( $pairs as $pair ) {
1857                                 $pair = rtrim($pair);
1858
1859                                 // Handle the cookie ending in ; which results in a empty final pair.
1860                                 if ( empty($pair) )
1861                                         continue;
1862
1863                                 list( $key, $val ) = strpos( $pair, '=' ) ? explode( '=', $pair ) : array( $pair, '' );
1864                                 $key = strtolower( trim( $key ) );
1865                                 if ( 'expires' == $key )
1866                                         $val = strtotime( $val );
1867                                 $this->$key = $val;
1868                         }
1869                 } else {
1870                         if ( !isset( $data['name'] ) )
1871                                 return false;
1872
1873                         // Set properties based directly on parameters.
1874                         foreach ( array( 'name', 'value', 'path', 'domain', 'port' ) as $field ) {
1875                                 if ( isset( $data[ $field ] ) )
1876                                         $this->$field = $data[ $field ];
1877                         }
1878
1879                         if ( isset( $data['expires'] ) )
1880                                 $this->expires = is_int( $data['expires'] ) ? $data['expires'] : strtotime( $data['expires'] );
1881                         else
1882                                 $this->expires = null;
1883                 }
1884         }
1885
1886         /**
1887          * Confirms that it's OK to send this cookie to the URL checked against.
1888          *
1889          * Decision is based on RFC 2109/2965, so look there for details on validity.
1890          *
1891          * @access public
1892          * @since 2.8.0
1893          *
1894          * @param string $url URL you intend to send this cookie to
1895          * @return boolean true if allowed, false otherwise.
1896          */
1897         public function test( $url ) {
1898                 if ( is_null( $this->name ) )
1899                         return false;
1900
1901                 // Expires - if expired then nothing else matters.
1902                 if ( isset( $this->expires ) && time() > $this->expires )
1903                         return false;
1904
1905                 // Get details on the URL we're thinking about sending to.
1906                 $url = parse_url( $url );
1907                 $url['port'] = isset( $url['port'] ) ? $url['port'] : ( 'https' == $url['scheme'] ? 443 : 80 );
1908                 $url['path'] = isset( $url['path'] ) ? $url['path'] : '/';
1909
1910                 // Values to use for comparison against the URL.
1911                 $path   = isset( $this->path )   ? $this->path   : '/';
1912                 $port   = isset( $this->port )   ? $this->port   : null;
1913                 $domain = isset( $this->domain ) ? strtolower( $this->domain ) : strtolower( $url['host'] );
1914                 if ( false === stripos( $domain, '.' ) )
1915                         $domain .= '.local';
1916
1917                 // Host - very basic check that the request URL ends with the domain restriction (minus leading dot).
1918                 $domain = substr( $domain, 0, 1 ) == '.' ? substr( $domain, 1 ) : $domain;
1919                 if ( substr( $url['host'], -strlen( $domain ) ) != $domain )
1920                         return false;
1921
1922                 // Port - supports "port-lists" in the format: "80,8000,8080".
1923                 if ( !empty( $port ) && !in_array( $url['port'], explode( ',', $port) ) )
1924                         return false;
1925
1926                 // Path - request path must start with path restriction.
1927                 if ( substr( $url['path'], 0, strlen( $path ) ) != $path )
1928                         return false;
1929
1930                 return true;
1931         }
1932
1933         /**
1934          * Convert cookie name and value back to header string.
1935          *
1936          * @access public
1937          * @since 2.8.0
1938          *
1939          * @return string Header encoded cookie name and value.
1940          */
1941         public function getHeaderValue() {
1942                 if ( ! isset( $this->name ) || ! isset( $this->value ) )
1943                         return '';
1944
1945                 /**
1946                  * Filter the header-encoded cookie value.
1947                  *
1948                  * @since 3.4.0
1949                  *
1950                  * @param string $value The cookie value.
1951                  * @param string $name  The cookie name.
1952                  */
1953                 return $this->name . '=' . apply_filters( 'wp_http_cookie_value', $this->value, $this->name );
1954         }
1955
1956         /**
1957          * Retrieve cookie header for usage in the rest of the WordPress HTTP API.
1958          *
1959          * @access public
1960          * @since 2.8.0
1961          *
1962          * @return string
1963          */
1964         public function getFullHeader() {
1965                 return 'Cookie: ' . $this->getHeaderValue();
1966         }
1967 }
1968
1969 /**
1970  * Implementation for deflate and gzip transfer encodings.
1971  *
1972  * Includes RFC 1950, RFC 1951, and RFC 1952.
1973  *
1974  * @since 2.8.0
1975  * @package WordPress
1976  * @subpackage HTTP
1977  */
1978 class WP_Http_Encoding {
1979
1980         /**
1981          * Compress raw string using the deflate format.
1982          *
1983          * Supports the RFC 1951 standard.
1984          *
1985          * @since 2.8.0
1986          *
1987          * @param string $raw String to compress.
1988          * @param int $level Optional, default is 9. Compression level, 9 is highest.
1989          * @param string $supports Optional, not used. When implemented it will choose the right compression based on what the server supports.
1990          * @return string|bool False on failure.
1991          */
1992         public static function compress( $raw, $level = 9, $supports = null ) {
1993                 return gzdeflate( $raw, $level );
1994         }
1995
1996         /**
1997          * Decompression of deflated string.
1998          *
1999          * Will attempt to decompress using the RFC 1950 standard, and if that fails
2000          * then the RFC 1951 standard deflate will be attempted. Finally, the RFC
2001          * 1952 standard gzip decode will be attempted. If all fail, then the
2002          * original compressed string will be returned.
2003          *
2004          * @since 2.8.0
2005          *
2006          * @param string $compressed String to decompress.
2007          * @param int $length The optional length of the compressed data.
2008          * @return string|bool False on failure.
2009          */
2010         public static function decompress( $compressed, $length = null ) {
2011
2012                 if ( empty($compressed) )
2013                         return $compressed;
2014
2015                 if ( false !== ( $decompressed = @gzinflate( $compressed ) ) )
2016                         return $decompressed;
2017
2018                 if ( false !== ( $decompressed = WP_Http_Encoding::compatible_gzinflate( $compressed ) ) )
2019                         return $decompressed;
2020
2021                 if ( false !== ( $decompressed = @gzuncompress( $compressed ) ) )
2022                         return $decompressed;
2023
2024                 if ( function_exists('gzdecode') ) {
2025                         $decompressed = @gzdecode( $compressed );
2026
2027                         if ( false !== $decompressed )
2028                                 return $decompressed;
2029                 }
2030
2031                 return $compressed;
2032         }
2033
2034         /**
2035          * Decompression of deflated string while staying compatible with the majority of servers.
2036          *
2037          * Certain Servers will return deflated data with headers which PHP's gzinflate()
2038          * function cannot handle out of the box. The following function has been created from
2039          * various snippets on the gzinflate() PHP documentation.
2040          *
2041          * Warning: Magic numbers within. Due to the potential different formats that the compressed
2042          * data may be returned in, some "magic offsets" are needed to ensure proper decompression
2043          * takes place. For a simple progmatic way to determine the magic offset in use, see:
2044          * http://core.trac.wordpress.org/ticket/18273
2045          *
2046          * @since 2.8.1
2047          * @link http://core.trac.wordpress.org/ticket/18273
2048          * @link http://au2.php.net/manual/en/function.gzinflate.php#70875
2049          * @link http://au2.php.net/manual/en/function.gzinflate.php#77336
2050          *
2051          * @param string $gzData String to decompress.
2052          * @return string|bool False on failure.
2053          */
2054         public static function compatible_gzinflate($gzData) {
2055
2056                 // Compressed data might contain a full header, if so strip it for gzinflate().
2057                 if ( substr($gzData, 0, 3) == "\x1f\x8b\x08" ) {
2058                         $i = 10;
2059                         $flg = ord( substr($gzData, 3, 1) );
2060                         if ( $flg > 0 ) {
2061                                 if ( $flg & 4 ) {
2062                                         list($xlen) = unpack('v', substr($gzData, $i, 2) );
2063                                         $i = $i + 2 + $xlen;
2064                                 }
2065                                 if ( $flg & 8 )
2066                                         $i = strpos($gzData, "\0", $i) + 1;
2067                                 if ( $flg & 16 )
2068                                         $i = strpos($gzData, "\0", $i) + 1;
2069                                 if ( $flg & 2 )
2070                                         $i = $i + 2;
2071                         }
2072                         $decompressed = @gzinflate( substr($gzData, $i, -8) );
2073                         if ( false !== $decompressed )
2074                                 return $decompressed;
2075                 }
2076
2077                 // Compressed data from java.util.zip.Deflater amongst others.
2078                 $decompressed = @gzinflate( substr($gzData, 2) );
2079                 if ( false !== $decompressed )
2080                         return $decompressed;
2081
2082                 return false;
2083         }
2084
2085         /**
2086          * What encoding types to accept and their priority values.
2087          *
2088          * @since 2.8.0
2089          *
2090          * @return string Types of encoding to accept.
2091          */
2092         public static function accept_encoding( $url, $args ) {
2093                 $type = array();
2094                 $compression_enabled = WP_Http_Encoding::is_available();
2095
2096                 if ( ! $args['decompress'] ) // Decompression specifically disabled.
2097                         $compression_enabled = false;
2098                 elseif ( $args['stream'] ) // Disable when streaming to file.
2099                         $compression_enabled = false;
2100                 elseif ( isset( $args['limit_response_size'] ) ) // If only partial content is being requested, we won't be able to decompress it.
2101                         $compression_enabled = false;
2102
2103                 if ( $compression_enabled ) {
2104                         if ( function_exists( 'gzinflate' ) )
2105                                 $type[] = 'deflate;q=1.0';
2106
2107                         if ( function_exists( 'gzuncompress' ) )
2108                                 $type[] = 'compress;q=0.5';
2109
2110                         if ( function_exists( 'gzdecode' ) )
2111                                 $type[] = 'gzip;q=0.5';
2112                 }
2113
2114                 /**
2115                  * Filter the allowed encoding types.
2116                  *
2117                  * @since 3.6.0
2118                  *
2119                  * @param array  $type Encoding types allowed. Accepts 'gzinflate',
2120                  *                     'gzuncompress', 'gzdecode'.
2121                  * @param string $url  URL of the HTTP request.
2122                  * @param array  $args HTTP request arguments.
2123                  */
2124                 $type = apply_filters( 'wp_http_accept_encoding', $type, $url, $args );
2125
2126                 return implode(', ', $type);
2127         }
2128
2129         /**
2130          * What encoding the content used when it was compressed to send in the headers.
2131          *
2132          * @since 2.8.0
2133          *
2134          * @return string Content-Encoding string to send in the header.
2135          */
2136         public static function content_encoding() {
2137                 return 'deflate';
2138         }
2139
2140         /**
2141          * Whether the content be decoded based on the headers.
2142          *
2143          * @since 2.8.0
2144          *
2145          * @param array|string $headers All of the available headers.
2146          * @return bool
2147          */
2148         public static function should_decode($headers) {
2149                 if ( is_array( $headers ) ) {
2150                         if ( array_key_exists('content-encoding', $headers) && ! empty( $headers['content-encoding'] ) )
2151                                 return true;
2152                 } else if ( is_string( $headers ) ) {
2153                         return ( stripos($headers, 'content-encoding:') !== false );
2154                 }
2155
2156                 return false;
2157         }
2158
2159         /**
2160          * Whether decompression and compression are supported by the PHP version.
2161          *
2162          * Each function is tested instead of checking for the zlib extension, to
2163          * ensure that the functions all exist in the PHP version and aren't
2164          * disabled.
2165          *
2166          * @since 2.8.0
2167          *
2168          * @return bool
2169          */
2170         public static function is_available() {
2171                 return ( function_exists('gzuncompress') || function_exists('gzdeflate') || function_exists('gzinflate') );
2172         }
2173 }