WordPress.org

Make WordPress Core

Ticket #4011: 4011.6.diff

File 4011.6.diff, 23.7 KB (added by DD32, 9 years ago)
  • wp-includes/http.php

     
    118118                        }
    119119                }
    120120
    121                 if( has_filter('http_transport_get_debug') )
     121                if ( has_filter('http_transport_get_debug') )
    122122                        do_action('http_transport_get_debug', $working_transport, $blocking_transport, $nonblocking_transport);
    123123
    124124                if ( isset($args['blocking']) && !$args['blocking'] )
     
    166166                        }
    167167                }
    168168
    169                 if( has_filter('http_transport_post_debug') )
     169                if ( has_filter('http_transport_post_debug') )
    170170                        do_action('http_transport_post_debug', $working_transport, $blocking_transport, $nonblocking_transport);
    171171
    172172                if ( isset($args['blocking']) && !$args['blocking'] )
     
    243243
    244244                // Determine if this is a https call and pass that on to the transport functions
    245245                // so that we can blacklist the transports that do not support ssl verification
    246                 if ( $arrURL['scheme'] == 'https' || $arrURL['scheme'] == 'ssl' )
    247                         $r['ssl'] = true;
    248                 else
    249                         $r['ssl'] = false;
     246                $r['ssl'] = $arrURL['scheme'] == 'https' || $arrURL['scheme'] == 'ssl';
    250247
    251                 // Determine if this request is to OUR install of WordPress
    252                 if ( stristr(get_bloginfo('url'), $arrURL['host']) )
    253                         $r['local'] = true;
    254                 else
    255                         $r['local'] = false;
     248                // Determine if this request is to OUR install of WordPress
     249                $homeURL = parse_url(get_bloginfo('url'));
     250                $r['local'] = $homeURL['host'] == $arrURL['host'] || 'localhost' == $arrURL['host'];
     251                unset($homeURL);
    256252
    257253                if ( is_null( $r['headers'] ) )
    258254                        $r['headers'] = array();
     
    275271                // Construct Cookie: header if any cookies are set
    276272                WP_Http::buildCookieHeader( $r );
    277273
    278                 if( WP_Http_Encoding::is_available() )
     274                if ( WP_Http_Encoding::is_available() )
    279275                        $r['headers']['Accept-Encoding'] = WP_Http_Encoding::accept_encoding();
    280276
    281277                if ( is_null($r['body']) ) {
     
    296292                        $transports = WP_Http::_postTransport($r);
    297293                }
    298294
    299                 if( has_action('http_api_debug') )
     295                if ( has_action('http_api_debug') )
    300296                        do_action('http_api_debug', $transports, 'transports_list');
    301297
    302298                $response = array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() );
    303                 foreach( (array) $transports as $transport ) {
     299                foreach ( (array) $transports as $transport ) {
    304300                        $response = $transport->request($url, $r);
    305301
    306                         if( has_action('http_api_debug') )
     302                        if ( has_action('http_api_debug') )
    307303                                do_action( 'http_api_debug', $response, 'response', get_class($transport) );
    308304
    309                         if( ! is_wp_error($response) )
     305                        if ( ! is_wp_error($response) )
    310306                                return $response;
    311307                }
    312308
     
    419415
    420416                        if ( !empty( $value ) ) {
    421417                                $key = strtolower( $key );
    422                                 if ( isset( $newheaders[$key] ) ) {
     418
     419                                if ( isset( $newheaders[$key] ) )
    423420                                        $newheaders[$key] = array( $newheaders[$key], trim( $value ) );
    424                                 } else {
     421                                else
    425422                                        $newheaders[$key] = trim( $value );
    426                                 }
     423
    427424                                if ( 'set-cookie' == strtolower( $key ) )
    428425                                        $cookies[] = new WP_Http_Cookie( $value );
    429426                        }
     
    448445        function buildCookieHeader( &$r ) {
    449446                if ( ! empty($r['cookies']) ) {
    450447                        $cookies_header = '';
    451                         foreach ( (array) $r['cookies'] as $cookie ) {
     448                        foreach ( (array) $r['cookies'] as $cookie )
    452449                                $cookies_header .= $cookie->getHeaderValue() . '; ';
    453                         }
    454450                        $cookies_header = substr( $cookies_header, 0, -2 );
    455451                        $r['headers']['cookie'] = $cookies_header;
    456452                }
     
    494490
    495491                                $body = ltrim(str_replace(array($match[0], $strBody), '', $body), "\n");
    496492
    497                                 if( "0" == trim($body) )
     493                                if ( "0" == trim($body) )
    498494                                        return $parsedBody; // Ignore footer headers.
    499495                        } else {
    500496                                return $body;
     
    510506         *
    511507         * You block external URL requests by defining WP_HTTP_BLOCK_EXTERNAL in your wp-config.php file
    512508         * and this will only allow localhost and your blog to make requests. The constant
    513          * WP_ACCESSABLE_HOSTS will allow additional hosts to go through for requests.
     509         * WP_ACCESSABLE_HOSTS will allow additional hosts to go through for requests. The format of the
     510         * WP_ACCESSABLE_HOSTS constant is a comma separated list of hostnames to allow.
    514511         *
    515512         * @since 2.8.0
    516513         * @link http://core.trac.wordpress.org/ticket/8927 Allow preventing external requests.
     
    537534                if ( $check === false )
    538535                        return false;
    539536
    540                 $home = parse_url( get_bloginfo('site_url') );
     537                $home = parse_url( get_option('siteurl') );
    541538
    542539                // Don't block requests back to ourselves by default
    543                 if ( $uri == 'localhost' || $uri == $home['host'] )
     540                if ( $check['host'] == 'localhost' || $check['host'] == $home['host'] )
    544541                        return apply_filters('block_local_requests', false);
    545542
    546                 if ( defined('WP_ACCESSABLE_HOSTS') && is_array( WP_ACCESSABLE_HOSTS ) && in_array( $check['host'], WP_ACCESSABLE_HOSTS ) ) {
    547                                 return false;
    548                 }
     543                if ( !defined('WP_ACCESSABLE_HOSTS') )
     544                        return true;
    549545
    550                 return true;
     546                static $accessable_hosts;
     547                if ( null == $accessable_hosts )
     548                        $accessable_hosts = preg_split('|,\s*|', WP_ACCESSABLE_HOSTS);
     549
     550                return !in_array( $check['host'], $accessable_hosts ); //Inverse logic, If its in the array, then we can't access it.
    551551        }
    552552}
    553553
     
    606606                if ( ! isset($arrURL['port']) ) {
    607607                        if ( ($arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https') && extension_loaded('openssl') ) {
    608608                                $arrURL['host'] = 'ssl://' . $arrURL['host'];
    609                                 $arrURL['port'] = apply_filters('http_request_port', 443);
     609                                $arrURL['port'] = 443;
    610610                                $secure_transport = true;
    611611                        } else {
    612                                 $arrURL['port'] = apply_filters('http_request_default_port', 80);
     612                                $arrURL['port'] = 80;
    613613                        }
    614                 } else {
    615                         $arrURL['port'] = apply_filters('http_request_port', $arrURL['port'], $arrURL['host']);
    616614                }
    617615
    618616                // There are issues with the HTTPS and SSL protocols that cause errors that can be safely
     
    625623                $proxy = new WP_HTTP_Proxy();
    626624
    627625                if ( !defined('WP_DEBUG') || ( defined('WP_DEBUG') && false === WP_DEBUG ) ) {
    628                         if( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
     626                        if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
    629627                                $handle = @fsockopen($proxy->host(), $proxy->port(), $iError, $strError, $r['timeout'] );
    630628                        else
    631629                                $handle = @fsockopen($arrURL['host'], $arrURL['port'], $iError, $strError, $r['timeout'] );
    632                 }
    633                 else {
    634                         if( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
     630                } else {
     631                        if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
    635632                                $handle = fsockopen($proxy->host(), $proxy->port(), $iError, $strError, $r['timeout'] );
    636633                        else
    637634                                $handle = fsockopen($arrURL['host'], $arrURL['port'], $iError, $strError, $r['timeout'] );
     
    648645                if ( false === $handle )
    649646                        return new WP_Error('http_request_failed', $iError . ': ' . $strError);
    650647
    651                 // WordPress supports PHP 4.3, which has this function. Removed sanity checking for
    652                 // performance reasons.
    653648                stream_set_timeout($handle, $r['timeout'] );
    654649
    655                 $requestPath = $arrURL['path'] . ( isset($arrURL['query']) ? '?' . $arrURL['query'] : '' );
    656                 $requestPath = empty($requestPath) ? '/' : $requestPath;
     650                if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) //Some proxies require full URL in this field.
     651                        $requestPath = $url;
     652                else
     653                        $requestPath = $arrURL['path'] . ( isset($arrURL['query']) ? '?' . $arrURL['query'] : '' );
    657654
    658                 $strHeaders = '';
    659                 $strHeaders .= strtoupper($r['method']) . ' ' . $requestPath . ' HTTP/' . $r['httpversion'] . "\r\n";
     655                if ( empty($requestPath) )
     656                        $requestPath .= '/';
    660657
    661                 if( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
    662                         $strHeaders .= 'Host: ' . $arrURL['host'] .':'. $arrURL['port'] . "\r\n";
     658                $strHeaders = strtoupper($r['method']) . ' ' . $requestPath . ' HTTP/' . $r['httpversion'] . "\r\n";
     659
     660                if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
     661                        $strHeaders .= 'Host: ' . $arrURL['host'] . ':' . $arrURL['port'] . "\r\n";
    663662                else
    664663                        $strHeaders .= 'Host: ' . $arrURL['host'] . "\r\n";
    665664
    666                 if( isset($r['user-agent']) )
     665                if ( isset($r['user-agent']) )
    667666                        $strHeaders .= 'User-agent: ' . $r['user-agent'] . "\r\n";
    668667
    669668                if ( is_array($r['headers']) ) {
     
    673672                        $strHeaders .= $r['headers'];
    674673                }
    675674
    676                 if ( $proxy->use_authentication() ) {
     675                if ( $proxy->use_authentication() )
    677676                        $strHeaders .= $proxy->authentication_header() . "\r\n";
    678                 }
    679677
    680678                $strHeaders .= "\r\n";
    681679
     
    731729         * @static
    732730         * @return boolean False means this class can not be used, true means it can.
    733731         */
    734         function test($args = array()) {
     732        function test( $args = array() ) {
    735733                if ( false !== ($option = get_option( 'disable_fsockopen' )) && time()-$option < 43200 ) // 12 hours
    736734                        return false;
    737735
    738                 if ( function_exists( 'fsockopen' ) && ( isset($args['ssl']) && !$args['ssl'] ) )
    739                         return apply_filters('use_fsockopen_transport', true);
     736                $is_ssl = isset($args['ssl']) && $args['ssl'];
    740737
    741                 return false;
     738                if ( ! $is_ssl && function_exists( 'fsockopen' ) )
     739                        $use = true;
     740                elseif ( $is_ssl && extension_loaded('openssl') && function_exists( 'fsockopen' ) )
     741                        $use = true;
     742                else
     743                        $use = false;
     744
     745                return apply_filters('use_fsockopen_transport', $use, $args);
    742746        }
    743747}
    744748
     
    772776         * @return array 'headers', 'body', 'cookies' and 'response' keys.
    773777         */
    774778        function request($url, $args = array()) {
    775                 global $http_response_header;
    776 
    777779                $defaults = array(
    778780                        'method' => 'GET', 'timeout' => 5,
    779781                        'redirection' => 5, 'httpversion' => '1.0',
     
    799801                if (! $handle)
    800802                        return new WP_Error('http_request_failed', sprintf(__('Could not open handle for fopen() to %s'), $url));
    801803
    802                 // WordPress supports PHP 4.3, which has this function. Removed sanity
    803                 // checking for performance reasons.
    804804                stream_set_timeout($handle, $r['timeout'] );
    805805
    806806                if ( ! $r['blocking'] ) {
     
    812812                while ( ! feof($handle) )
    813813                        $strResponse .= fread($handle, 4096);
    814814
    815                 $theHeaders = '';
    816815                if ( function_exists('stream_get_meta_data') ) {
    817816                        $meta = stream_get_meta_data($handle);
    818817                        $theHeaders = $meta['wrapper_data'];
    819                         if( isset( $meta['wrapper_data']['headers'] ) )
     818                        if ( isset( $meta['wrapper_data']['headers'] ) )
    820819                                $theHeaders = $meta['wrapper_data']['headers'];
    821820                } else {
    822                         if( ! isset( $http_response_header ) )
    823                                 global $http_response_header;
     821                        //$http_response_header is a PHP reserved variable which is set in the current-scope when using the HTTP Wrapper
     822                        //see http://php.oregonstate.edu/manual/en/reserved.variables.httpresponseheader.php
    824823                        $theHeaders = $http_response_header;
    825824                }
    826825
     
    844843         * @static
    845844         * @return boolean False means this class can not be used, true means it can.
    846845         */
    847         function test() {
     846        function test($args = array()) {
    848847                if ( ! function_exists('fopen') || (function_exists('ini_get') && true != ini_get('allow_url_fopen')) )
    849848                        return false;
    850849
    851                         if (
    852                                 ( isset($args['ssl']) && !$args['ssl'] ) ||
    853                                 ( isset($args['local']) && $args['local'] == true && apply_filters('https_local_ssl_verify', true) != true ) ||
    854                                 ( isset($args['local']) && $args['local'] == false && apply_filters('https_ssl_verify', true) != true ) ||
    855                                 ( isset($args['sslverify']) && !$args['sslverify'] )
    856                         )
    857                                 return apply_filters('use_fopen_transport', true);
     850                $use = true;
    858851
    859                 return false;
     852                //PHP does not verify SSL certs, We can only make a request via this transports if SSL Verification is turned off.
     853                $is_ssl = isset($args['ssl']) && $args['ssl'];
     854                if ( $is_ssl ) {
     855                        $is_local = isset($args['local']) && $args['local'];
     856                        $ssl_verify = isset($args['sslverify']) && $args['sslverify'];
     857                        if ( $is_local && true != apply_filters('https_local_ssl_verify', true) )
     858                                $use = true;
     859                        elseif ( !$is_local && true != apply_filters('https_ssl_verify', true) )
     860                                $use = true;
     861                        elseif ( !$ssl_verify )
     862                                $use = true;
     863                        else
     864                                $use = false;
     865                }
     866
     867                return apply_filters('use_fopen_transport', $use, $args);
    860868        }
    861869}
    862870
     
    910918                        return new WP_Error('http_request_failed', sprintf(__('Malformed URL: %s'), $url));
    911919
    912920                if ( 'http' != $arrURL['scheme'] && 'https' != $arrURL['scheme'] )
    913                         $url = str_replace($arrURL['scheme'], 'http', $url);
     921                        $url = preg_replace('|^' . preg_quote($arrURL['scheme'], '|') . '|', 'http', $url);
    914922
    915923                // Convert Header array to string.
    916924                $strHeaders = '';
    917925                if ( is_array( $r['headers'] ) )
    918                         foreach( $r['headers'] as $name => $value )
     926                        foreach ( $r['headers'] as $name => $value )
    919927                                $strHeaders .= "{$name}: $value\r\n";
    920928                else if ( is_string( $r['headers'] ) )
    921929                        $strHeaders = $r['headers'];
    922930
     931                $is_local = isset($args['local']) && $args['local'];
     932                $ssl_verify = isset($args['sslverify']) && $args['sslverify'];
     933                if ( $is_local )
     934                        $ssl_verify = apply_filters('https_local_ssl_verify', $ssl_verify);
     935                elseif ( ! $is_local )
     936                        $ssl_verify = apply_filters('https_ssl_verify', $ssl_verify);
     937
    923938                $arrContext = array('http' =>
    924939                        array(
    925940                                'method' => strtoupper($r['method']),
     
    929944                                'header' => $strHeaders,
    930945                                'timeout' => $r['timeout'],
    931946                                'ssl' => array(
    932                                                 'verify_peer' => apply_filters('https_ssl_verify', $r['sslverify']),
    933                                                 'verify_host' => apply_filters('https_ssl_verify', $r['sslverify'])
     947                                                'verify_peer' => $ssl_verify,
     948                                                'verify_host' => $ssl_verify
    934949                                )
    935950                        )
    936951                );
     
    938953                $proxy = new WP_HTTP_Proxy();
    939954
    940955                if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) {
    941                         $arrContext['http']['proxy'] = 'tcp://'.$proxy->host().':'.$proxy->port();
     956                        $arrContext['http']['proxy'] = 'tcp://' . $proxy->host() . ':' . $proxy->port();
     957                        $arrContext['http']['request_fulluri'] = true;
    942958
    943959                        // We only support Basic authentication so this will only work if that is what your proxy supports.
    944                         if ( $proxy->use_authentication() ) {
     960                        if ( $proxy->use_authentication() )
    945961                                $arrContext['http']['header'] .= $proxy->authentication_header() . "\r\n";
    946                         }
    947962                }
    948963
    949964                if ( ! is_null($r['body']) && ! empty($r['body'] ) )
     
    975990                fclose($handle);
    976991
    977992                $processedHeaders = array();
    978                 if( isset( $meta['wrapper_data']['headers'] ) )
     993                if ( isset( $meta['wrapper_data']['headers'] ) )
    979994                        $processedHeaders = WP_Http::processHeaders($meta['wrapper_data']['headers']);
    980995                else
    981996                        $processedHeaders = WP_Http::processHeaders($meta['wrapper_data']);
     
    10051020                if ( version_compare(PHP_VERSION, '5.0', '<') )
    10061021                        return false;
    10071022
    1008                 return apply_filters('use_streams_transport', true);
     1023                //HTTPS via Proxy was added in 5.1.0
     1024                $is_ssl = isset($args['ssl']) && $args['ssl'];
     1025                if ( $is_ssl && version_compare(PHP_VERSION, '5.1.0', '<') ) {
     1026                        $proxy = new WP_HTTP_Proxy();
     1027                        /**
     1028                         * No URL check, as its not currently passed to the ::test() function
     1029                         * In the case where a Proxy is in use, Just bypass this transport for HTTPS.
     1030                         */
     1031                        if ( $proxy->is_enabled() )
     1032                                return false;
     1033                }
     1034
     1035                return apply_filters('use_streams_transport', true, $args);
    10091036        }
    10101037}
    10111038
     
    10691096                $arrURL = parse_url($url);
    10701097
    10711098                if ( 'http' != $arrURL['scheme'] || 'https' != $arrURL['scheme'] )
    1072                         $url = str_replace($arrURL['scheme'], 'http', $url);
     1099                        $url = preg_replace('|^' . preg_quote($arrURL['scheme'], '|') . '|', 'http', $url);
    10731100
     1101                $is_local = isset($args['local']) && $args['local'];
     1102                $ssl_verify = isset($args['sslverify']) && $args['sslverify'];
     1103                if ( $is_local )
     1104                        $ssl_verify = apply_filters('https_local_ssl_verify', $ssl_verify);
     1105                elseif ( ! $is_local )
     1106                        $ssl_verify = apply_filters('https_ssl_verify', $ssl_verify);
     1107
    10741108                $options = array(
    10751109                        'timeout' => $r['timeout'],
    10761110                        'connecttimeout' => $r['timeout'],
     
    10781112                        'useragent' => $r['user-agent'],
    10791113                        'headers' => $r['headers'],
    10801114                        'ssl' => array(
    1081                                 'verifypeer' => apply_filters('https_ssl_verify', $r['sslverify']),
    1082                                 'verifyhost' => apply_filters('https_ssl_verify', $r['sslverify'])
     1115                                'verifypeer' => $ssl_verify,
     1116                                'verifyhost' => $ssl_verify
    10831117                        )
    10841118                );
    10851119
     
    11391173         * @return boolean False means this class can not be used, true means it can.
    11401174         */
    11411175        function test($args = array()) {
    1142                 if ( function_exists('http_request') )
    1143                         return apply_filters('use_http_extension_transport', true);
    1144 
    1145                 return false;
     1176                return apply_filters('use_http_extension_transport', function_exists('http_request'), $args );
    11461177        }
    11471178}
    11481179
     
    11991230                $proxy = new WP_HTTP_Proxy();
    12001231
    12011232                if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) {
    1202                         curl_setopt( $handle, CURLOPT_HTTPPROXYTUNNEL, true );
    12031233
    12041234                        $isPHP5 = version_compare(PHP_VERSION, '5.0.0', '>=');
    12051235
     
    12181248                                curl_setopt( $handle, CURLOPT_PROXYUSERPWD, $proxy->authentication() );
    12191249                        }
    12201250                }
     1251               
     1252                $is_local = isset($args['local']) && $args['local'];
     1253                $ssl_verify = isset($args['sslverify']) && $args['sslverify'];
     1254                if ( $is_local )
     1255                        $ssl_verify = apply_filters('https_local_ssl_verify', $ssl_verify);
     1256                elseif ( ! $is_local )
     1257                        $ssl_verify = apply_filters('https_ssl_verify', $ssl_verify);
    12211258
    12221259                curl_setopt( $handle, CURLOPT_URL, $url);
    12231260                curl_setopt( $handle, CURLOPT_RETURNTRANSFER, true );
    1224                 curl_setopt( $handle, CURLOPT_SSL_VERIFYHOST, apply_filters('https_ssl_verify', $r['sslverify']) );
    1225                 curl_setopt( $handle, CURLOPT_SSL_VERIFYPEER, apply_filters('https_ssl_verify', $r['sslverify']) );
     1261                curl_setopt( $handle, CURLOPT_SSL_VERIFYHOST, $ssl_verify );
     1262                curl_setopt( $handle, CURLOPT_SSL_VERIFYPEER, $ssl_verify );
    12261263                curl_setopt( $handle, CURLOPT_USERAGENT, $r['user-agent'] );
    12271264                curl_setopt( $handle, CURLOPT_CONNECTTIMEOUT, $r['timeout'] );
    12281265                curl_setopt( $handle, CURLOPT_TIMEOUT, $r['timeout'] );
     
    12501287                if ( !empty( $r['headers'] ) ) {
    12511288                        // cURL expects full header strings in each element
    12521289                        $headers = array();
    1253                         foreach ( $r['headers'] as $name => $value ) {
     1290                        foreach ( $r['headers'] as $name => $value )
    12541291                                $headers[] = "{$name}: $value";
    1255                         }
    12561292                        curl_setopt( $handle, CURLOPT_HTTPHEADER, $headers );
    12571293                }
    12581294
     
    13171353         */
    13181354        function test($args = array()) {
    13191355                if ( function_exists('curl_init') && function_exists('curl_exec') )
    1320                         return  apply_filters('use_curl_transport', true);
     1356                        return apply_filters('use_curl_transport', true, $args);
    13211357
    13221358                return false;
    13231359        }
     
    13381374 * <li>WP_PROXY_PASSWORD - Proxy password, if it requires authentication.</li>
    13391375 * <li>WP_PROXY_BYPASS_HOSTS - Will prevent the hosts in this list from going through the proxy.
    13401376 * You do not need to have localhost and the blog host in this list, because they will not be passed
    1341  * through the proxy.</li>
     1377 * through the proxy. The list should be presented in a comma separated list</li>
    13421378 * </ol>
    13431379 *
    13441380 * An example can be as seen below.
    13451381 * <code>
    13461382 * define('WP_PROXY_HOST', '192.168.84.101');
    13471383 * define('WP_PROXY_PORT', '8080');
    1348  * define('WP_PROXY_BYPASS_HOSTS', array('localhost', 'www.example.com'));
     1384 * define('WP_PROXY_BYPASS_HOSTS', 'localhost, www.example.com');
    13491385 * </code>
    13501386 *
    13511387 * @link http://core.trac.wordpress.org/ticket/4011 Proxy support ticket in WordPress.
     
    13531389 */
    13541390class WP_HTTP_Proxy {
    13551391
    1356         function WP_HTTP_Proxy() {
    1357                 $this->__construct();
    1358         }
    1359 
    1360         function __construct() {
    1361 
    1362         }
    1363 
    13641392        /**
    13651393         * Whether proxy connection should be used.
    13661394         *
     
    13711399         * @return bool
    13721400         */
    13731401        function is_enabled() {
    1374                 return ( defined('WP_PROXY_HOST') && defined('WP_PROXY_PORT') );
     1402                return defined('WP_PROXY_HOST') && defined('WP_PROXY_PORT');
    13751403        }
    13761404
    13771405        /**
     
    13841412         * @return bool
    13851413         */
    13861414        function use_authentication() {
    1387                 return ( defined('WP_PROXY_USERNAME') && defined('WP_PROXY_PASSWORD') );
     1415                return defined('WP_PROXY_USERNAME') && defined('WP_PROXY_PASSWORD');
    13881416        }
    13891417
    13901418        /**
     
    13951423         * @return string
    13961424         */
    13971425        function host() {
    1398                 if( defined('WP_PROXY_HOST') )
     1426                if ( defined('WP_PROXY_HOST') )
    13991427                        return WP_PROXY_HOST;
    14001428
    14011429                return '';
     
    14091437         * @return string
    14101438         */
    14111439        function port() {
    1412                 if( defined('WP_PROXY_PORT') )
     1440                if ( defined('WP_PROXY_PORT') )
    14131441                        return WP_PROXY_PORT;
    14141442
    14151443                return '';
     
    14231451         * @return string
    14241452         */
    14251453        function username() {
    1426                 if( defined('WP_PROXY_USERNAME') )
     1454                if ( defined('WP_PROXY_USERNAME') )
    14271455                        return WP_PROXY_USERNAME;
    14281456
    14291457                return '';
     
    14371465         * @return string
    14381466         */
    14391467        function password() {
    1440                 if( defined('WP_PROXY_PASSWORD') )
     1468                if ( defined('WP_PROXY_PASSWORD') )
    14411469                        return WP_PROXY_PASSWORD;
    14421470
    14431471                return '';
     
    14511479         * @return string
    14521480         */
    14531481        function authentication() {
    1454                 return $this->username() .':'. $this->password();
     1482                return $this->username() . ':' . $this->password();
    14551483        }
    14561484
    14571485        /**
     
    14621490         * @return string
    14631491         */
    14641492        function authentication_header() {
    1465                 return 'Proxy-Authentication: Basic '. base64_encode( $this->authentication() );
     1493                return 'Proxy-Authentication: Basic ' . base64_encode( $this->authentication() );
    14661494        }
    14671495
    14681496        /**
     
    14841512                $check = @parse_url($uri);
    14851513
    14861514                // Malformed URL, can not process, but this could mean ssl, so let through anyway.
    1487                 if( $check === false )
     1515                if ( $check === false )
    14881516                        return true;
    14891517
    1490                 $home = parse_url( get_bloginfo('site_url') );
     1518                $home = parse_url( get_option('siteurl') );
    14911519
    1492                 if ( $uri == 'localhost' || $uri == $home['host'] )
     1520                if ( $check['host'] == 'localhost' || $check['host'] == $home['host'] )
    14931521                        return false;
    14941522
    1495                 if ( defined('WP_PROXY_BYPASS_HOSTS') && is_array( WP_PROXY_BYPASS_HOSTS ) && in_array( $check['host'], WP_PROXY_BYPASS_HOSTS ) ) {
    1496                         return false;
    1497                 }
    1498 
    1499                 return true;
     1523                if ( !defined('WP_PROXY_BYPASS_HOSTS') )
     1524                        return true;
     1525               
     1526                static $bypass_hosts;
     1527                if ( null == $bypass_hosts )
     1528                        $bypass_hosts = preg_split('|,\s*|', WP_PROXY_BYPASS_HOSTS);
     1529               
     1530                return !in_array( $check['host'], $bypass_hosts );
    15001531        }
    15011532}
    1502 
    1503 
    15041533/**
    15051534 * Internal representation of a single cookie.
    15061535 *
     
    17441773        function decompress( $compressed, $length = null ) {
    17451774                $decompressed = gzinflate( $compressed );
    17461775
    1747                 if( false !== $decompressed )
     1776                if ( false !== $decompressed )
    17481777                        return $decompressed;
    17491778
    17501779                $decompressed = gzuncompress( $compressed );
    17511780
    1752                 if( false !== $decompressed )
     1781                if ( false !== $decompressed )
    17531782                        return $decompressed;
    17541783
    17551784                $decompressed = gzdecode( $compressed );
    17561785
    1757                 if( false !== $decompressed )
     1786                if ( false !== $decompressed )
    17581787                        return $decompressed;
    17591788
    17601789                return $compressed;
     
    17691798         */
    17701799        function accept_encoding() {
    17711800                $type = array();
    1772                 if( function_exists( 'gzinflate' ) )
     1801                if ( function_exists( 'gzinflate' ) )
    17731802                        $type[] = 'deflate;q=1.0';
    17741803
    1775                 if( function_exists( 'gzuncompress' ) )
     1804                if ( function_exists( 'gzuncompress' ) )
    17761805                        $type[] = 'compress;q=0.5';
    17771806
    1778                 if( function_exists( 'gzdecode' ) )
     1807                if ( function_exists( 'gzdecode' ) )
    17791808                        $type[] = 'gzip;q=0.5';
    17801809
    17811810                return implode(', ', $type);
     
    18011830         * @return bool
    18021831         */
    18031832        function should_decode($headers) {
    1804                 if( is_array( $headers ) ) {
    1805                         if( array_key_exists('content-encoding', $headers) && ! empty( $headers['content-encoding'] ) )
     1833                if ( is_array( $headers ) ) {
     1834                        if ( array_key_exists('content-encoding', $headers) && ! empty( $headers['content-encoding'] ) )
    18061835                                return true;
    18071836                } else if( is_string( $headers ) ) {
    18081837                        return ( stripos($headers, 'content-encoding:') !== false );
     
    18231852         * @return bool
    18241853         */
    18251854        function is_available() {
    1826                 return ( function_exists('gzuncompress') || function_exists('gzdeflate') ||
    1827                                  function_exists('gzinflate') );
     1855                return ( function_exists('gzuncompress') || function_exists('gzdeflate') || function_exists('gzinflate') );
    18281856        }
    18291857}
    18301858
     
    18901918 */
    18911919function wp_remote_get($url, $args = array()) {
    18921920        $objFetchSite = _wp_http_get_object();
    1893 
    18941921        return $objFetchSite->get($url, $args);
    18951922}
    18961923