WordPress.org

Make WordPress Core

Ticket #4011: 4011.4.diff

File 4011.4.diff, 25.3 KB (added by DD32, 7 years ago)
  • wp-includes/http.php

     
    9898                        if ( true === WP_Http_ExtHttp::test($args) ) { 
    9999                                $working_transport['exthttp'] = new WP_Http_ExtHttp(); 
    100100                                $blocking_transport[] = &$working_transport['exthttp']; 
    101                         } else if ( true === WP_Http_Curl::test($args) ) { 
     101                        } elseif ( true === WP_Http_Curl::test($args) ) { 
    102102                                $working_transport['curl'] = new WP_Http_Curl(); 
    103103                                $blocking_transport[] = &$working_transport['curl']; 
    104                         } else if ( true === WP_Http_Streams::test($args) ) { 
     104                        } elseif ( true === WP_Http_Streams::test($args) ) { 
    105105                                $working_transport['streams'] = new WP_Http_Streams(); 
    106106                                $blocking_transport[] = &$working_transport['streams']; 
    107                         } else if ( true === WP_Http_Fopen::test($args) ) { 
     107                        } elseif ( true === WP_Http_Fopen::test($args) ) { 
    108108                                $working_transport['fopen'] = new WP_Http_Fopen(); 
    109109                                $blocking_transport[] = &$working_transport['fopen']; 
    110                         } else if ( true === WP_Http_Fsockopen::test($args) ) { 
     110                        } elseif ( true === WP_Http_Fsockopen::test($args) ) { 
    111111                                $working_transport['fsockopen'] = new WP_Http_Fsockopen(); 
    112112                                $blocking_transport[] = &$working_transport['fsockopen']; 
    113113                        } 
     
    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'] ) 
     
    149149                        if ( true === WP_Http_ExtHttp::test($args) ) { 
    150150                                $working_transport['exthttp'] = new WP_Http_ExtHttp(); 
    151151                                $blocking_transport[] = &$working_transport['exthttp']; 
    152                         } else if ( true === WP_Http_Curl::test($args) ) { 
     152                        } elseif ( true === WP_Http_Curl::test($args) ) { 
    153153                                $working_transport['curl'] = new WP_Http_Curl(); 
    154154                                $blocking_transport[] = &$working_transport['curl']; 
    155                         } else if ( true === WP_Http_Streams::test($args) ) { 
     155                        } elseif ( true === WP_Http_Streams::test($args) ) { 
    156156                                $working_transport['streams'] = new WP_Http_Streams(); 
    157157                                $blocking_transport[] = &$working_transport['streams']; 
    158                         } else if ( true === WP_Http_Fsockopen::test($args) ) { 
     158                        } elseif ( true === WP_Http_Fsockopen::test($args) ) { 
    159159                                $working_transport['fsockopen'] = new WP_Http_Fsockopen(); 
    160160                                $blocking_transport[] = &$working_transport['fsockopen']; 
    161161                        } 
     
    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; 
     
    543539                if ( $uri == 'localhost' || $uri == $home['host'] ) 
    544540                        return apply_filters('block_local_requests', false); 
    545541 
    546                 if ( defined('WP_ACCESSABLE_HOSTS') && is_array( WP_ACCESSABLE_HOSTS ) && in_array( $check['host'], WP_ACCESSABLE_HOSTS ) ) { 
    547                                 return false; 
    548                 } 
     542                if ( defined('WP_ACCESSABLE_HOSTS') && is_array( WP_ACCESSABLE_HOSTS ) && in_array( $check['host'], WP_ACCESSABLE_HOSTS ) ) 
     543                        return false; 
    549544 
    550545                return true; 
    551546        } 
     
    588583                if ( isset($r['headers']['User-Agent']) ) { 
    589584                        $r['user-agent'] = $r['headers']['User-Agent']; 
    590585                        unset($r['headers']['User-Agent']); 
    591                 } else if( isset($r['headers']['user-agent']) ) { 
     586                } elseif ( isset($r['headers']['user-agent']) ) { 
    592587                        $r['user-agent'] = $r['headers']['user-agent']; 
    593588                        unset($r['headers']['user-agent']); 
    594589                } 
     
    606601                if ( ! isset($arrURL['port']) ) { 
    607602                        if ( ($arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https') && extension_loaded('openssl') ) { 
    608603                                $arrURL['host'] = 'ssl://' . $arrURL['host']; 
    609                                 $arrURL['port'] = apply_filters('http_request_port', 443); 
     604                                $arrURL['port'] = 443; 
    610605                                $secure_transport = true; 
    611606                        } else { 
    612                                 $arrURL['port'] = apply_filters('http_request_default_port', 80); 
     607                                $arrURL['port'] = 80; 
    613608                        } 
    614                 } else { 
    615                         $arrURL['port'] = apply_filters('http_request_port', $arrURL['port'], $arrURL['host']); 
    616609                } 
    617610 
    618611                // There are issues with the HTTPS and SSL protocols that cause errors that can be safely 
     
    625618                $proxy = new WP_HTTP_Proxy(); 
    626619 
    627620                if ( !defined('WP_DEBUG') || ( defined('WP_DEBUG') && false === WP_DEBUG ) ) { 
    628                         if( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) 
     621                        if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) 
    629622                                $handle = @fsockopen($proxy->host(), $proxy->port(), $iError, $strError, $r['timeout'] ); 
    630623                        else 
    631624                                $handle = @fsockopen($arrURL['host'], $arrURL['port'], $iError, $strError, $r['timeout'] ); 
    632                 } 
    633                 else { 
    634                         if( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) 
     625                } else { 
     626                        if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) 
    635627                                $handle = fsockopen($proxy->host(), $proxy->port(), $iError, $strError, $r['timeout'] ); 
    636628                        else 
    637629                                $handle = fsockopen($arrURL['host'], $arrURL['port'], $iError, $strError, $r['timeout'] ); 
     
    648640                if ( false === $handle ) 
    649641                        return new WP_Error('http_request_failed', $iError . ': ' . $strError); 
    650642 
    651                 // WordPress supports PHP 4.3, which has this function. Removed sanity checking for 
    652                 // performance reasons. 
    653643                stream_set_timeout($handle, $r['timeout'] ); 
    654644 
    655                 $requestPath = $arrURL['path'] . ( isset($arrURL['query']) ? '?' . $arrURL['query'] : '' ); 
    656                 $requestPath = empty($requestPath) ? '/' : $requestPath; 
     645                if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) //Some proxies require full URL in this field. 
     646                        $requestPath = $url; 
     647                else 
     648                        $requestPath = $arrURL['path'] . ( isset($arrURL['query']) ? '?' . $arrURL['query'] : '' ); 
    657649 
    658                 $strHeaders = ''; 
    659                 $strHeaders .= strtoupper($r['method']) . ' ' . $requestPath . ' HTTP/' . $r['httpversion'] . "\r\n"; 
     650                if ( empty($requestPath) ) 
     651                        $requestPath .= '/'; 
    660652 
    661                 if( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) 
    662                         $strHeaders .= 'Host: ' . $arrURL['host'] .':'. $arrURL['port'] . "\r\n"; 
     653                $strHeaders = strtoupper($r['method']) . ' ' . $requestPath . ' HTTP/' . $r['httpversion'] . "\r\n"; 
     654 
     655                if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) 
     656                        $strHeaders .= 'Host: ' . $arrURL['host'] . ':' . $arrURL['port'] . "\r\n"; 
    663657                else 
    664658                        $strHeaders .= 'Host: ' . $arrURL['host'] . "\r\n"; 
    665659 
    666                 if( isset($r['user-agent']) ) 
     660                if ( isset($r['user-agent']) ) 
    667661                        $strHeaders .= 'User-agent: ' . $r['user-agent'] . "\r\n"; 
    668662 
    669663                if ( is_array($r['headers']) ) { 
     
    673667                        $strHeaders .= $r['headers']; 
    674668                } 
    675669 
    676                 if ( $proxy->use_authentication() ) { 
     670                if ( $proxy->use_authentication() ) 
    677671                        $strHeaders .= $proxy->authentication_header() . "\r\n"; 
    678                 } 
    679672 
    680673                $strHeaders .= "\r\n"; 
    681674 
     
    731724         * @static 
    732725         * @return boolean False means this class can not be used, true means it can. 
    733726         */ 
    734         function test($args = array()) { 
     727        function test( $args = array() ) { 
    735728                if ( false !== ($option = get_option( 'disable_fsockopen' )) && time()-$option < 43200 ) // 12 hours 
    736729                        return false; 
    737730 
    738                 if ( function_exists( 'fsockopen' ) && ( isset($args['ssl']) && !$args['ssl'] ) ) 
    739                         return apply_filters('use_fsockopen_transport', true); 
     731                $is_ssl = isset($args['ssl']) && $args['ssl']; 
    740732 
    741                 return false; 
     733                if ( ! $is_ssl && function_exists( 'fsockopen' ) ) 
     734                        $use = true; 
     735                elseif ( $is_ssl && extension_loaded('openssl') && function_exists( 'fsockopen' ) ) 
     736                        $use = true; 
     737                else 
     738                        $use = false; 
     739 
     740                return apply_filters('use_fsockopen_transport', $use, $args); 
    742741        } 
    743742} 
    744743 
     
    772771         * @return array 'headers', 'body', 'cookies' and 'response' keys. 
    773772         */ 
    774773        function request($url, $args = array()) { 
    775                 global $http_response_header; 
    776  
    777774                $defaults = array( 
    778775                        'method' => 'GET', 'timeout' => 5, 
    779776                        'redirection' => 5, 'httpversion' => '1.0', 
     
    799796                if (! $handle) 
    800797                        return new WP_Error('http_request_failed', sprintf(__('Could not open handle for fopen() to %s'), $url)); 
    801798 
    802                 // WordPress supports PHP 4.3, which has this function. Removed sanity 
    803                 // checking for performance reasons. 
    804799                stream_set_timeout($handle, $r['timeout'] ); 
    805800 
    806801                if ( ! $r['blocking'] ) { 
     
    812807                while ( ! feof($handle) ) 
    813808                        $strResponse .= fread($handle, 4096); 
    814809 
    815                 $theHeaders = ''; 
    816810                if ( function_exists('stream_get_meta_data') ) { 
    817811                        $meta = stream_get_meta_data($handle); 
    818812                        $theHeaders = $meta['wrapper_data']; 
    819                         if( isset( $meta['wrapper_data']['headers'] ) ) 
     813                        if ( isset( $meta['wrapper_data']['headers'] ) ) 
    820814                                $theHeaders = $meta['wrapper_data']['headers']; 
    821815                } else { 
    822                         if( ! isset( $http_response_header ) ) 
    823                                 global $http_response_header; 
     816                        //$http_response_header is a PHP reserved variable which is set in the current-scope when using the HTTP Wrapper 
     817                        //see http://php.oregonstate.edu/manual/en/reserved.variables.httpresponseheader.php 
    824818                        $theHeaders = $http_response_header; 
    825819                } 
    826820 
     
    844838         * @static 
    845839         * @return boolean False means this class can not be used, true means it can. 
    846840         */ 
    847         function test() { 
     841        function test($args = array()) { 
    848842                if ( ! function_exists('fopen') || (function_exists('ini_get') && true != ini_get('allow_url_fopen')) ) 
    849843                        return false; 
    850844 
    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); 
     845                $use = true; 
    858846 
    859                 return false; 
     847                //PHP does not verify SSL certs, We can only make a request via this transports if SSL Verification is turned off. 
     848                $is_ssl = isset($args['ssl']) && $args['ssl']; 
     849                if ( $is_ssl ) { 
     850                        $is_local = isset($args['local']) && $args['local']; 
     851                        $ssl_verify = isset($args['sslverify']) && $args['sslverify']; 
     852                        if ( $is_local && true != apply_filters('https_local_ssl_verify', true) ) 
     853                                $use = true; 
     854                        elseif ( !$is_local && true != apply_filters('https_ssl_verify', true) ) 
     855                                $use = true; 
     856                        elseif ( !$ssl_verify ) 
     857                                $use = true; 
     858                        else 
     859                                $use = false; 
     860                } 
     861 
     862                return apply_filters('use_fopen_transport', $use, $args); 
    860863        } 
    861864} 
    862865 
     
    896899                if ( isset($r['headers']['User-Agent']) ) { 
    897900                        $r['user-agent'] = $r['headers']['User-Agent']; 
    898901                        unset($r['headers']['User-Agent']); 
    899                 } else if( isset($r['headers']['user-agent']) ) { 
     902                } elseif ( isset($r['headers']['user-agent']) ) { 
    900903                        $r['user-agent'] = $r['headers']['user-agent']; 
    901904                        unset($r['headers']['user-agent']); 
    902905                } 
     
    910913                        return new WP_Error('http_request_failed', sprintf(__('Malformed URL: %s'), $url)); 
    911914 
    912915                if ( 'http' != $arrURL['scheme'] && 'https' != $arrURL['scheme'] ) 
    913                         $url = str_replace($arrURL['scheme'], 'http', $url); 
     916                        $url = preg_replace('|^' . preg_quote($arrURL['scheme'], '|') . '|', 'http', $url); 
    914917 
    915918                // Convert Header array to string. 
    916919                $strHeaders = ''; 
    917920                if ( is_array( $r['headers'] ) ) 
    918                         foreach( $r['headers'] as $name => $value ) 
     921                        foreach ( $r['headers'] as $name => $value ) 
    919922                                $strHeaders .= "{$name}: $value\r\n"; 
    920                 else if ( is_string( $r['headers'] ) ) 
     923                elseif ( is_string( $r['headers'] ) ) 
    921924                        $strHeaders = $r['headers']; 
    922925 
     926                $is_local = isset($args['local']) && $args['local']; 
     927                $ssl_verify = isset($args['sslverify']) && $args['sslverify']; 
     928                if ( $is_local ) 
     929                        $ssl_verify = apply_filters('https_local_ssl_verify', $ssl_verify); 
     930                elseif ( ! $is_local ) 
     931                        $ssl_verify = apply_filters('https_ssl_verify', $ssl_verify); 
     932 
    923933                $arrContext = array('http' => 
    924934                        array( 
    925935                                'method' => strtoupper($r['method']), 
     
    929939                                'header' => $strHeaders, 
    930940                                'timeout' => $r['timeout'], 
    931941                                'ssl' => array( 
    932                                                 'verify_peer' => apply_filters('https_ssl_verify', $r['sslverify']), 
    933                                                 'verify_host' => apply_filters('https_ssl_verify', $r['sslverify']) 
     942                                                'verify_peer' => $ssl_verify, 
     943                                                'verify_host' => $ssl_verify 
    934944                                ) 
    935945                        ) 
    936946                ); 
    937947 
    938948                $proxy = new WP_HTTP_Proxy(); 
    939949 
    940                 if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) {  
    941                         $arrContext['http']['proxy'] = 'tcp://'.$proxy->host().':'.$proxy->port(); 
     950                if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) { 
     951                        $arrContext['http']['proxy'] = 'tcp://' . $proxy->host() . ':' . $proxy->port(); 
     952                        $arrContext['http']['request_fulluri'] = true; 
    942953 
    943954                        // We only support Basic authentication so this will only work if that is what your proxy supports. 
    944                         if ( $proxy->use_authentication() ) { 
     955                        if ( $proxy->use_authentication() ) 
    945956                                $arrContext['http']['header'] .= $proxy->authentication_header() . "\r\n"; 
    946                         } 
    947957                } 
    948958 
    949959                if ( ! is_null($r['body']) && ! empty($r['body'] ) ) 
     
    975985                fclose($handle); 
    976986 
    977987                $processedHeaders = array(); 
    978                 if( isset( $meta['wrapper_data']['headers'] ) ) 
     988                if ( isset( $meta['wrapper_data']['headers'] ) ) 
    979989                        $processedHeaders = WP_Http::processHeaders($meta['wrapper_data']['headers']); 
    980990                else 
    981991                        $processedHeaders = WP_Http::processHeaders($meta['wrapper_data']); 
     
    10051015                if ( version_compare(PHP_VERSION, '5.0', '<') ) 
    10061016                        return false; 
    10071017 
    1008                 return apply_filters('use_streams_transport', true); 
     1018                //HTTPS via Proxy was added in 5.1.0 
     1019                $is_ssl = isset($args['ssl']) && $args['ssl']; 
     1020                if ( $is_ssl && version_compare(PHP_VERSION, '5.1.0', '<') ) { 
     1021                        $proxy = new WP_HTTP_Proxy(); 
     1022                        /** 
     1023                         * No URL check, as its not currently passed to the ::test() function 
     1024                         * In the case where a Proxy is in use, Just bypass this transport for HTTPS. 
     1025                         */ 
     1026                        if ( $proxy->is_enabled() ) 
     1027                                return false; 
     1028                } 
     1029 
     1030                return apply_filters('use_streams_transport', true, $args); 
    10091031        } 
    10101032} 
    10111033 
     
    10461068                if ( isset($r['headers']['User-Agent']) ) { 
    10471069                        $r['user-agent'] = $r['headers']['User-Agent']; 
    10481070                        unset($r['headers']['User-Agent']); 
    1049                 } else if( isset($r['headers']['user-agent']) ) { 
     1071                } elseif ( isset($r['headers']['user-agent']) ) { 
    10501072                        $r['user-agent'] = $r['headers']['user-agent']; 
    10511073                        unset($r['headers']['user-agent']); 
    10521074                } 
     
    10691091                $arrURL = parse_url($url); 
    10701092 
    10711093                if ( 'http' != $arrURL['scheme'] || 'https' != $arrURL['scheme'] ) 
    1072                         $url = str_replace($arrURL['scheme'], 'http', $url); 
     1094                        $url = preg_replace('|^' . preg_quote($arrURL['scheme'], '|') . '|', 'http', $url); 
    10731095 
     1096                $is_local = isset($args['local']) && $args['local']; 
     1097                $ssl_verify = isset($args['sslverify']) && $args['sslverify']; 
     1098                if ( $is_local ) 
     1099                        $ssl_verify = apply_filters('https_local_ssl_verify', $ssl_verify); 
     1100                elseif ( ! $is_local ) 
     1101                        $ssl_verify = apply_filters('https_ssl_verify', $ssl_verify); 
     1102 
    10741103                $options = array( 
    10751104                        'timeout' => $r['timeout'], 
    10761105                        'connecttimeout' => $r['timeout'], 
     
    10781107                        'useragent' => $r['user-agent'], 
    10791108                        'headers' => $r['headers'], 
    10801109                        'ssl' => array(  
    1081                                 'verifypeer' => apply_filters('https_ssl_verify', $r['sslverify']), 
    1082                                 'verifyhost' => apply_filters('https_ssl_verify', $r['sslverify']) 
     1110                                'verifypeer' => $ssl_verify, 
     1111                                'verifyhost' => $ssl_verify 
    10831112                        ) 
    10841113                ); 
    10851114 
     
    11391168         * @return boolean False means this class can not be used, true means it can. 
    11401169         */ 
    11411170        function test($args = array()) { 
    1142                 if ( function_exists('http_request') ) 
    1143                         return apply_filters('use_http_extension_transport', true); 
    1144  
    1145                 return false; 
     1171                return apply_filters('use_http_extension_transport', function_exists('http_request'), $args ); 
    11461172        } 
    11471173} 
    11481174 
     
    11801206                if ( isset($r['headers']['User-Agent']) ) { 
    11811207                        $r['user-agent'] = $r['headers']['User-Agent']; 
    11821208                        unset($r['headers']['User-Agent']); 
    1183                 } else if( isset($r['headers']['user-agent']) ) { 
     1209                } elseif ( isset($r['headers']['user-agent']) ) { 
    11841210                        $r['user-agent'] = $r['headers']['user-agent']; 
    11851211                        unset($r['headers']['user-agent']); 
    11861212                } 
     
    11991225                $proxy = new WP_HTTP_Proxy(); 
    12001226 
    12011227                if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) { 
    1202                         curl_setopt( $handle, CURLOPT_HTTPPROXYTUNNEL, true ); 
    12031228 
    12041229                        $isPHP5 = version_compare(PHP_VERSION, '5.0.0', '>='); 
    12051230 
     
    12181243                                curl_setopt( $handle, CURLOPT_PROXYUSERPWD, $proxy->authentication() ); 
    12191244                        } 
    12201245                } 
     1246                 
     1247                $is_local = isset($args['local']) && $args['local']; 
     1248                $ssl_verify = isset($args['sslverify']) && $args['sslverify']; 
     1249                if ( $is_local ) 
     1250                        $ssl_verify = apply_filters('https_local_ssl_verify', $ssl_verify); 
     1251                elseif ( ! $is_local ) 
     1252                        $ssl_verify = apply_filters('https_ssl_verify', $ssl_verify); 
    12211253 
    12221254                curl_setopt( $handle, CURLOPT_URL, $url); 
    12231255                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']) ); 
     1256                curl_setopt( $handle, CURLOPT_SSL_VERIFYHOST, $ssl_verify ); 
     1257                curl_setopt( $handle, CURLOPT_SSL_VERIFYPEER, $ssl_verify ); 
    12261258                curl_setopt( $handle, CURLOPT_USERAGENT, $r['user-agent'] ); 
    12271259                curl_setopt( $handle, CURLOPT_CONNECTTIMEOUT, $r['timeout'] ); 
    12281260                curl_setopt( $handle, CURLOPT_TIMEOUT, $r['timeout'] ); 
     
    12501282                if ( !empty( $r['headers'] ) ) { 
    12511283                        // cURL expects full header strings in each element 
    12521284                        $headers = array(); 
    1253                         foreach ( $r['headers'] as $name => $value ) { 
     1285                        foreach ( $r['headers'] as $name => $value ) 
    12541286                                $headers[] = "{$name}: $value"; 
    1255                         } 
    12561287                        curl_setopt( $handle, CURLOPT_HTTPHEADER, $headers ); 
    12571288                } 
    12581289 
     
    13171348         */ 
    13181349        function test($args = array()) { 
    13191350                if ( function_exists('curl_init') && function_exists('curl_exec') ) 
    1320                         return  apply_filters('use_curl_transport', true); 
     1351                        return apply_filters('use_curl_transport', true, $args); 
    13211352 
    13221353                return false; 
    13231354        } 
     
    13531384 */ 
    13541385class WP_HTTP_Proxy { 
    13551386 
    1356         function WP_HTTP_Proxy() { 
    1357                 $this->__construct(); 
    1358         } 
    1359  
    1360         function __construct() { 
    1361                  
    1362         } 
    1363  
    13641387        /** 
    13651388         * Whether proxy connection should be used. 
    13661389         * 
     
    13711394         * @return bool 
    13721395         */ 
    13731396        function is_enabled() { 
    1374                 return ( defined('WP_PROXY_HOST') && defined('WP_PROXY_PORT') ); 
     1397                return defined('WP_PROXY_HOST') && defined('WP_PROXY_PORT'); 
    13751398        } 
    13761399 
    13771400        /** 
     
    13841407         * @return bool 
    13851408         */ 
    13861409        function use_authentication() { 
    1387                 return ( defined('WP_PROXY_USERNAME') && defined('WP_PROXY_PASSWORD') ); 
     1410                return defined('WP_PROXY_USERNAME') && defined('WP_PROXY_PASSWORD'); 
    13881411        } 
    13891412 
    13901413        /** 
     
    13951418         * @return string 
    13961419         */ 
    13971420        function host() { 
    1398                 if( defined('WP_PROXY_HOST') ) 
     1421                if ( defined('WP_PROXY_HOST') ) 
    13991422                        return WP_PROXY_HOST; 
    14001423 
    14011424                return ''; 
     
    14091432         * @return string 
    14101433         */ 
    14111434        function port() { 
    1412                 if( defined('WP_PROXY_PORT') ) 
     1435                if ( defined('WP_PROXY_PORT') ) 
    14131436                        return WP_PROXY_PORT; 
    14141437 
    14151438                return ''; 
     
    14231446         * @return string 
    14241447         */ 
    14251448        function username() { 
    1426                 if( defined('WP_PROXY_USERNAME') ) 
     1449                if ( defined('WP_PROXY_USERNAME') ) 
    14271450                        return WP_PROXY_USERNAME; 
    14281451 
    14291452                return ''; 
     
    14371460         * @return string 
    14381461         */ 
    14391462        function password() { 
    1440                 if( defined('WP_PROXY_PASSWORD') ) 
     1463                if ( defined('WP_PROXY_PASSWORD') ) 
    14411464                        return WP_PROXY_PASSWORD; 
    14421465 
    14431466                return ''; 
     
    14511474         * @return string 
    14521475         */ 
    14531476        function authentication() { 
    1454                 return $this->username() .':'. $this->password(); 
     1477                return $this->username() . ':' . $this->password(); 
    14551478        } 
    14561479 
    14571480        /** 
     
    14621485         * @return string 
    14631486         */ 
    14641487        function authentication_header() { 
    1465                 return 'Proxy-Authentication: Basic '. base64_encode( $this->authentication() ); 
     1488                return 'Proxy-Authentication: Basic ' . base64_encode( $this->authentication() ); 
    14661489        } 
    14671490 
    14681491        /** 
     
    14841507                $check = @parse_url($uri); 
    14851508 
    14861509                // Malformed URL, can not process, but this could mean ssl, so let through anyway. 
    1487                 if( $check === false ) 
     1510                if ( $check === false ) 
    14881511                        return true; 
    14891512 
    14901513                $home = parse_url( get_bloginfo('site_url') ); 
     
    14921515                if ( $uri == 'localhost' || $uri == $home['host'] ) 
    14931516                        return false; 
    14941517 
    1495                 if ( defined('WP_PROXY_BYPASS_HOSTS') && is_array( WP_PROXY_BYPASS_HOSTS ) && in_array( $check['host'], WP_PROXY_BYPASS_HOSTS ) ) { 
     1518                if ( defined('WP_PROXY_BYPASS_HOSTS') && is_array( WP_PROXY_BYPASS_HOSTS ) && in_array( $check['host'], WP_PROXY_BYPASS_HOSTS ) ) 
    14961519                        return false; 
    1497                 } 
    14981520 
    14991521                return true; 
    15001522        } 
    15011523} 
    1502  
    1503  
    15041524/** 
    15051525 * Internal representation of a single cookie. 
    15061526 * 
     
    17441764        function decompress( $compressed, $length = null ) { 
    17451765                $decompressed = gzinflate( $compressed ); 
    17461766 
    1747                 if( false !== $decompressed ) 
     1767                if ( false !== $decompressed ) 
    17481768                        return $decompressed; 
    17491769 
    17501770                $decompressed = gzuncompress( $compressed ); 
    17511771 
    1752                 if( false !== $decompressed ) 
     1772                if ( false !== $decompressed ) 
    17531773                        return $decompressed; 
    17541774 
    17551775                $decompressed = gzdecode( $compressed ); 
    17561776 
    1757                 if( false !== $decompressed ) 
     1777                if ( false !== $decompressed ) 
    17581778                        return $decompressed; 
    17591779 
    17601780                return $compressed; 
     
    17691789         */ 
    17701790        function accept_encoding() { 
    17711791                $type = array(); 
    1772                 if( function_exists( 'gzinflate' ) ) 
     1792                if ( function_exists( 'gzinflate' ) ) 
    17731793                        $type[] = 'deflate;q=1.0'; 
    17741794 
    1775                 if( function_exists( 'gzuncompress' ) ) 
     1795                if ( function_exists( 'gzuncompress' ) ) 
    17761796                        $type[] = 'compress;q=0.5'; 
    17771797 
    1778                 if( function_exists( 'gzdecode' ) ) 
     1798                if ( function_exists( 'gzdecode' ) ) 
    17791799                        $type[] = 'gzip;q=0.5'; 
    17801800 
    17811801                return implode(', ', $type); 
     
    18011821         * @return bool 
    18021822         */ 
    18031823        function should_decode($headers) { 
    1804                 if( is_array( $headers ) ) { 
    1805                         if( array_key_exists('content-encoding', $headers) && ! empty( $headers['content-encoding'] ) ) 
     1824                if ( is_array( $headers ) ) { 
     1825                        if ( array_key_exists('content-encoding', $headers) && ! empty( $headers['content-encoding'] ) ) 
    18061826                                return true; 
    1807                 } else if( is_string( $headers ) ) { 
     1827                } elseif ( is_string( $headers ) ) { 
    18081828                        return ( stripos($headers, 'content-encoding:') !== false ); 
    18091829                } 
    18101830 
     
    18231843         * @return bool 
    18241844         */ 
    18251845        function is_available() { 
    1826                 return ( function_exists('gzuncompress') || function_exists('gzdeflate') || 
    1827                                  function_exists('gzinflate') ); 
     1846                return ( function_exists('gzuncompress') || function_exists('gzdeflate') || function_exists('gzinflate') ); 
    18281847        } 
    18291848} 
    18301849 
     
    18901909 */ 
    18911910function wp_remote_get($url, $args = array()) { 
    18921911        $objFetchSite = _wp_http_get_object(); 
    1893  
    18941912        return $objFetchSite->get($url, $args); 
    18951913} 
    18961914