WordPress.org

Make WordPress Core

Ticket #13777: 13777.patch

File 13777.patch, 23.5 KB (added by jacobsantos, 4 years ago)

Initial request for comment on argument processing class.

  • class-http.php

     
    170170        /** 
    171171         * Send a HTTP request to a URI. 
    172172         * 
    173          * The body and headers are part of the arguments. The 'body' argument is for the body and will 
    174          * accept either a string or an array. The 'headers' argument should be an array, but a string 
    175          * is acceptable. If the 'body' argument is an array, then it will automatically be escaped 
    176          * using http_build_query(). 
     173         * See {@link WP_Http_Config::process} for more on the arguments for requests. 
    177174         * 
    178          * The only URI that are supported in the HTTP Transport implementation are the HTTP and HTTPS 
    179          * protocols. HTTP and HTTPS are assumed so the server might not know how to handle the send 
    180          * headers. Other protocols are unsupported and most likely will fail. 
     175         * The only URI that should be used are those that are for the HTTP protocol. Any other URI 
     176         * scheme will fail. HTTPS is supported, provided that PHP supports SSL and has the extensions 
     177         * installed. 
    181178         * 
    182          * The defaults are 'method', 'timeout', 'redirection', 'httpversion', 'blocking' and 
    183          * 'user-agent'. 
    184          * 
    185          * Accepted 'method' values are 'GET', 'POST', and 'HEAD', some transports technically allow 
    186          * others, but should not be assumed. The 'timeout' is used to sent how long the connection 
    187          * should stay open before failing when no response. 'redirection' is used to track how many 
    188          * redirects were taken and used to sent the amount for other transports, but not all transports 
    189          * accept setting that value. 
    190          * 
    191          * The 'httpversion' option is used to sent the HTTP version and accepted values are '1.0', and 
    192          * '1.1' and should be a string. Version 1.1 is not supported, because of chunk response. The 
    193          * 'user-agent' option is the user-agent and is used to replace the default user-agent, which is 
    194          * 'WordPress/WP_Version', where WP_Version is the value from $wp_version. 
    195          * 
    196          * 'blocking' is the default, which is used to tell the transport, whether it should halt PHP 
    197          * while it performs the request or continue regardless. Actually, that isn't entirely correct. 
    198          * Blocking mode really just means whether the fread should just pull what it can whenever it 
    199          * gets bytes or if it should wait until it has enough in the buffer to read or finishes reading 
    200          * the entire content. It doesn't actually always mean that PHP will continue going after making 
    201          * the request. 
    202          * 
    203179         * @access public 
    204180         * @since 2.7.0 
    205          * @todo Refactor this code. The code in this method extends the scope of its original purpose 
    206          *              and should be refactored to allow for cleaner abstraction and reduce duplication of the 
    207          *              code. One suggestion is to create a class specifically for the arguments, however 
    208          *              preliminary refactoring to this affect has affect more than just the scope of the 
    209          *              arguments. Something to ponder at least. 
    210181         * 
    211182         * @param string $url URI resource. 
    212183         * @param str|array $args Optional. Override the defaults. 
    213184         * @return array containing 'headers', 'body', 'response', 'cookies' 
    214185         */ 
    215186        function request( $url, $args = array() ) { 
    216                 global $wp_version; 
     187                $config = new WP_Http_Config($url); 
     188                $config->process($args); 
    217189 
    218                 $defaults = array( 
    219                         'method' => 'GET', 
    220                         'timeout' => apply_filters( 'http_request_timeout', 5), 
    221                         'redirection' => apply_filters( 'http_request_redirection_count', 5), 
    222                         'httpversion' => apply_filters( 'http_request_version', '1.0'), 
    223                         'user-agent' => apply_filters( 'http_headers_useragent', 'WordPress/' . $wp_version . '; ' . get_bloginfo( 'url' )  ), 
    224                         'blocking' => true, 
    225                         'headers' => array(), 
    226                         'cookies' => array(), 
    227                         'body' => null, 
    228                         'compress' => false, 
    229                         'decompress' => true, 
    230                         'sslverify' => true 
    231                 ); 
     190                $transports = $config->get_transports(); 
     191                $r = $config->get_arguments(); 
    232192 
    233                 $r = wp_parse_args( $args, $defaults ); 
    234                 $r = apply_filters( 'http_request_args', $r, $url ); 
    235  
    236                 // Allow plugins to short-circuit the request 
    237                 $pre = apply_filters( 'pre_http_request', false, $r, $url ); 
    238                 if ( false !== $pre ) 
    239                         return $pre; 
    240  
    241                 $arrURL = parse_url($url); 
    242  
    243                 if ( empty( $url ) || empty($url['scheme'] ) ) 
    244                         return new WP_Error('http_request_failed', __('A valid URL was not provided.')); 
    245  
    246                 if ( $this->block_request( $url ) ) 
    247                         return new WP_Error('http_request_failed', __('User has blocked requests through HTTP.')); 
    248  
    249                 // Determine if this is a https call and pass that on to the transport functions 
    250                 // so that we can blacklist the transports that do not support ssl verification 
    251                 $r['ssl'] = $arrURL['scheme'] == 'https' || $arrURL['scheme'] == 'ssl'; 
    252  
    253                 // Determine if this request is to OUR install of WordPress 
    254                 $homeURL = parse_url( get_bloginfo('url') ); 
    255                 $r['local'] = $homeURL['host'] == $arrURL['host'] || 'localhost' == $arrURL['host']; 
    256                 unset($homeURL); 
    257  
    258                 if ( is_null( $r['headers'] ) ) 
    259                         $r['headers'] = array(); 
    260  
    261                 if ( ! is_array($r['headers']) ) { 
    262                         $processedHeaders = WP_Http::processHeaders($r['headers']); 
    263                         $r['headers'] = $processedHeaders['headers']; 
    264                 } 
    265  
    266                 if ( isset($r['headers']['User-Agent']) ) { 
    267                         $r['user-agent'] = $r['headers']['User-Agent']; 
    268                         unset($r['headers']['User-Agent']); 
    269                 } 
    270  
    271                 if ( isset($r['headers']['user-agent']) ) { 
    272                         $r['user-agent'] = $r['headers']['user-agent']; 
    273                         unset($r['headers']['user-agent']); 
    274                 } 
    275  
    276                 // Construct Cookie: header if any cookies are set 
    277                 WP_Http::buildCookieHeader( $r ); 
    278  
    279                 if ( WP_Http_Encoding::is_available() ) 
    280                         $r['headers']['Accept-Encoding'] = WP_Http_Encoding::accept_encoding(); 
    281  
    282                 if ( empty($r['body']) ) { 
    283                         // Some servers fail when sending content without the content-length header being set. 
    284                         // Also, to fix another bug, we only send when doing POST and PUT and the content-length 
    285                         // header isn't already set. 
    286                         if( ($r['method'] == 'POST' || $r['method'] == 'PUT') && ! isset($r['headers']['Content-Length']) ) 
    287                                 $r['headers']['Content-Length'] = 0; 
    288  
    289                         // The method is ambiguous, because we aren't talking about HTTP methods, the "get" in 
    290                         // this case is simply that we aren't sending any bodies and to get the transports that 
    291                         // don't support sending bodies along with those which do. 
    292                         $transports = WP_Http::_getTransport($r); 
    293                 } else { 
    294                         if ( is_array( $r['body'] ) || is_object( $r['body'] ) ) { 
    295                                 if ( ! version_compare(phpversion(), '5.1.2', '>=') ) 
    296                                         $r['body'] = _http_build_query($r['body'], null, '&'); 
    297                                 else 
    298                                         $r['body'] = http_build_query($r['body'], null, '&'); 
    299                                 $r['headers']['Content-Type'] = 'application/x-www-form-urlencoded; charset=' . get_option('blog_charset'); 
    300                                 $r['headers']['Content-Length'] = strlen($r['body']); 
    301                         } 
    302  
    303                         if ( ! isset( $r['headers']['Content-Length'] ) && ! isset( $r['headers']['content-length'] ) ) 
    304                                 $r['headers']['Content-Length'] = strlen($r['body']); 
    305  
    306                         // The method is ambiguous, because we aren't talking about HTTP methods, the "post" in 
    307                         // this case is simply that we are sending HTTP body and to get the transports that do 
    308                         // support sending the body. Not all do, depending on the limitations of the PHP core 
    309                         // limitations. 
    310                         $transports = WP_Http::_postTransport($r); 
    311                 } 
    312  
    313193                do_action( 'http_api_debug', $transports, 'transports_list' ); 
    314194 
    315195                $response = array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() ); 
     
    549429         * @return bool True to block, false to allow. 
    550430         */ 
    551431        function block_request($uri) { 
     432                $config = new WP_Http_Config($uri); 
     433                return $config->block_request(); 
     434        } 
     435} 
     436 
     437/** 
     438 * Consolidates the argument processing for all of the transports and main WP_Http class. 
     439 * 
     440 * Since the beginning the argument processing was handled in both {@link WP_Http::request()} and in 
     441 * the individual transports. As more arguments and features were added, it became that 
     442 * {@link WP_Http::request()} was getting all of the support and the rest of the transports were 
     443 * becoming stagnate with argument processing. 
     444 * 
     445 * The individual transports appear to be used more individually, which would cause problems with 
     446 * argument processing or require duplication of {@link WP_Http::request()} code. 
     447 * 
     448 * @since {unknown} 
     449 * @package WordPress 
     450 * @subpackage HTTP 
     451 */ 
     452class WP_Http_Config { 
     453 
     454        /** 
     455         * The request URL. 
     456         * 
     457         * @since {unknown} 
     458         * @var string 
     459         */ 
     460        var $uri = ''; 
     461 
     462        /** 
     463         * Processed arguments cache. 
     464         * 
     465         * @since {unknown} 
     466         * @var array 
     467         */ 
     468        var $args = array(); 
     469 
     470        /** 
     471         * PHP4 constructor calls PHP5 constructor. 
     472         * 
     473         * @since {unknown} 
     474         * 
     475         * @param String $uri Request URI. 
     476         */ 
     477        function WP_Http_Config( $uri = '' ) { 
     478                $this->__construct($uri); 
     479        } 
     480 
     481        /** 
     482         * PHP5 constructor - Initialize class properties. 
     483         * 
     484         * @since {unknown} 
     485         * 
     486         * @param String $uri Request URI. 
     487         */ 
     488        function __construct( $uri = '' ) { 
     489                $this->uri = $uri; 
     490        } 
     491 
     492        /** 
     493         * Process arguments for sending requests. 
     494         * 
     495         * The 'body' argument is for the body and will accept either a string or an array. If the 
     496         * 'body' argument is an array, then it will automatically be escaped using http_build_query(). 
     497         * The 'content-type' header will automatically be set as well as 'content-length' to the size 
     498         * of the body, if the 'body' argument is an array. 
     499         * 
     500         * The 'headers' argument should be an array, but a string will be accepted and then converted 
     501         * to an array. The recommendation for headers to be an array is for optimization purposes. The 
     502         * header array should have the header (or field) name as the array key (or indicies) and the 
     503         * header value as the array value. 
     504         * 
     505         * The defaults are 'method', 'timeout', 'redirection', 'httpversion', 'blocking' and 
     506         * 'user-agent'. 
     507         * 
     508         * Accepted 'method' values are 'GET', 'POST', and 'HEAD', some transports technically allow 
     509         * others, but should not be assumed. The 'timeout' is used to sent how long the connection 
     510         * should stay open before failing when no response. 'redirection' is used to track how many 
     511         * redirects were taken and used to sent the amount for other transports, but not all transports 
     512         * accept setting that value. 
     513         * 
     514         * The 'httpversion' option is used to sent the HTTP version and accepted values are '1.0', and 
     515         * '1.1' and should be a string. Version 1.1 is supported, since chunked responses are 
     516         * supported. The 'user-agent' option is the user-agent and is used to replace the default 
     517         * user-agent, which is 'WordPress/WP_Version', where WP_Version is the value from $wp_version. 
     518         * 
     519         * 'blocking' is the default, which is used to tell the transport, whether it should halt PHP 
     520         * while it performs the request or continue regardless. Actually, that isn't entirely correct. 
     521         * Blocking mode really just means whether the fread should just pull what it can whenever it 
     522         * gets bytes or if it should wait until it has enough in the buffer to read or finishes reading 
     523         * the entire content. It doesn't actually always mean that PHP will continue going after making 
     524         * the request. 
     525         * 
     526         * @access public 
     527         * @since {unknown} 
     528         * 
     529         * @param str|array $args Optional. Override the defaults. 
     530         * @return array Transports for either sending body or for get requests. 
     531         */ 
     532        function process( $args = array() ) { 
     533                global $wp_version; 
     534 
     535                $defaults = array( 
     536                        'method' => 'GET', 
     537                        'timeout' => apply_filters( 'http_request_timeout', 5), 
     538                        'redirection' => apply_filters( 'http_request_redirection_count', 5), 
     539                        'httpversion' => apply_filters( 'http_request_version', '1.0'), 
     540                        'user-agent' => apply_filters( 'http_headers_useragent', 'WordPress/' . $wp_version . '; ' . get_bloginfo( 'url' )  ), 
     541                        'blocking' => true, 
     542                        'headers' => array(), 
     543                        'cookies' => array(), 
     544                        'body' => null, 
     545                        'compress' => false, 
     546                        'decompress' => true, 
     547                        'sslverify' => true 
     548                ); 
     549 
     550                $r = wp_parse_args( $args, $defaults ); 
     551                $r = apply_filters( 'http_request_args', $r, $this->uri ); 
     552 
     553                // Allow plugins to short-circuit the request 
     554                $pre = apply_filters( 'pre_http_request', false, $r, $this->uri ); 
     555                if ( false !== $pre ) 
     556                        return $pre; 
     557 
     558                $arrURL = parse_url($this->uri); 
     559 
     560                if ( empty( $arrURL ) || empty($arrURL['scheme'] ) ) 
     561                        return new WP_Error('http_request_failed', __('A valid URL was not provided.')); 
     562 
     563                if ( $this->block_request() ) 
     564                        return new WP_Error('http_request_failed', __('User has blocked requests through HTTP.')); 
     565 
     566                // Determine if this is a https call and pass that on to the transport functions 
     567                // so that we can blacklist the transports that do not support ssl verification 
     568                $r['ssl'] = $arrURL['scheme'] == 'https' || $arrURL['scheme'] == 'ssl'; 
     569 
     570                // Determine if this request is to OUR install of WordPress 
     571                $homeURL = parse_url( get_bloginfo('url') ); 
     572                $r['local'] = $homeURL['host'] == $arrURL['host'] || 'localhost' == $arrURL['host']; 
     573                unset($homeURL); 
     574 
     575                if ( is_null( $r['headers'] ) ) 
     576                        $r['headers'] = array(); 
     577 
     578                // Convert string to an array, if needed. 
     579                if ( ! is_array($r['headers']) ) { 
     580                        $processedHeaders = WP_Http::processHeaders($r['headers']); 
     581                        $r['headers'] = $processedHeaders['headers']; 
     582                } 
     583 
     584                // Change all headers to lowercase to standardize header checks. 
     585                // RFC 1945 section 4.2 states that "Field names are case-insensitive." 
     586                $r['headers'] = array_change_key_case($r['headers']); 
     587 
     588                // Most transports do not support setting user-agent by header value alone. Therefore, 
     589                // to prevent possible problems, we change it to an argument 
     590                if ( isset($r['headers']['user-agent']) ) { 
     591                        $r['user-agent'] = $r['headers']['user-agent']; 
     592                        unset($r['headers']['user-agent']); 
     593                } 
     594 
     595                // Construct Cookie: header if any cookies are set 
     596                WP_Http::buildCookieHeader( $r ); 
     597 
     598                if ( WP_Http_Encoding::is_available() ) 
     599                        $r['headers']['accept-encoding'] = WP_Http_Encoding::accept_encoding(); 
     600 
     601                if ( empty($r['body']) ) { 
     602                        // Some servers fail when sending content without the content-length header being set. 
     603                        // Also, to fix another bug, we only send when doing POST and PUT and the content-length 
     604                        // header isn't already set. 
     605                        if( ($r['method'] == 'POST' || $r['method'] == 'PUT') && ! isset($r['headers']['content-length']) ) 
     606                                $r['headers']['content-length'] = 0; 
     607                } else { 
     608                        if ( is_array( $r['body'] ) || is_object( $r['body'] ) ) { 
     609                                if ( ! version_compare(phpversion(), '5.1.2', '>=') ) 
     610                                        $r['body'] = _http_build_query($r['body'], null, '&'); 
     611                                else 
     612                                        $r['body'] = http_build_query($r['body'], null, '&'); 
     613                                $r['headers']['content-type'] = 'application/x-www-form-urlencoded; charset=' . get_option('blog_charset'); 
     614                                $r['headers']['content-length'] = strlen($r['body']); 
     615                        } 
     616 
     617                        if ( ! isset( $r['headers']['content-length'] ) && ! isset( $r['headers']['content-length'] ) ) 
     618                                $r['headers']['content-length'] = strlen($r['body']); 
     619                } 
     620 
     621                $r['processed'] = true; 
     622 
     623                $this->args = $r; 
     624        } 
     625 
     626        /** 
     627         * Retrieve transports based on whether body is sent with the request. 
     628         * 
     629         * There used to be a note in the methods used that they both are ambiguous. The note was given 
     630         * to prevent future coders from incorrectly assuming that the 'get' in 
     631         * {@link WP_Http::_getTransport()} was for HTTP GET method requests and that the 'post' in 
     632         * {@link WP_Http::_postTransport()} was for HTTP POST method requests. This is not the case, 
     633         * the two methods were created because there is a transport for PHP4 that does not support 
     634         * sending the request body and must be ignored for those requests. 
     635         * 
     636         * The above note are part of the methods, but the note was duplicated for clarity sake to 
     637         * prevent questions on why they are that way. 
     638         * 
     639         * @since {unknown} 
     640         * 
     641         * @return array Transports for sending requests. 
     642         */ 
     643        function get_transports() { 
     644                return ( empty($this->args['body']) ) ? WP_Http::_getTransport($r) : WP_Http::_postTransport($r); 
     645        } 
     646 
     647        /** 
     648         * Retrieve processed arguments. 
     649         * 
     650         * The {@link WP_Http_Config::process()} needs to be called first or this method will only 
     651         * return an empty array. 
     652         * 
     653         * @since {unknown} 
     654         * 
     655         * @return array Processed Arguments for requests. 
     656         */ 
     657        function get_arguments() { 
     658                return $this->args; 
     659        } 
     660 
     661        /** 
     662         * Block requests through the proxy. 
     663         * 
     664         * Those who are behind a proxy and want to prevent access to certain hosts may do so. This will 
     665         * prevent plugins from working and core functionality, if you don't include api.wordpress.org. 
     666         * 
     667         * You block external URL requests by defining WP_HTTP_BLOCK_EXTERNAL as true in your wp-config.php 
     668         * file and this will only allow localhost and your blog to make requests. The constant 
     669         * WP_ACCESSIBLE_HOSTS will allow additional hosts to go through for requests. The format of the 
     670         * WP_ACCESSIBLE_HOSTS constant is a comma separated list of hostnames to allow. 
     671         * 
     672         * @since 2.8.0 
     673         * @link http://core.trac.wordpress.org/ticket/8927 Allow preventing external requests. 
     674         * 
     675         * @param string $uri URI of url. 
     676         * @return bool True to block, false to allow. 
     677         */ 
     678        function block_request() { 
    552679                // We don't need to block requests, because nothing is blocked. 
    553680                if ( ! defined( 'WP_HTTP_BLOCK_EXTERNAL' ) || ! WP_HTTP_BLOCK_EXTERNAL ) 
    554681                        return false; 
    555682 
    556683                // parse_url() only handles http, https type URLs, and will emit E_WARNING on failure. 
    557684                // This will be displayed on blogs, which is not reasonable. 
    558                 $check = @parse_url($uri); 
     685                $check = @parse_url($this->uri); 
    559686 
    560687                /* Malformed URL, can not process, but this could mean ssl, so let through anyway. 
    561688                 * 
     
    609736         * @return array 'headers', 'body', 'cookies' and 'response' keys. 
    610737         */ 
    611738        function request($url, $args = array()) { 
    612                 $defaults = array( 
    613                         'method' => 'GET', 'timeout' => 5, 
    614                         'redirection' => 5, 'httpversion' => '1.0', 
    615                         'blocking' => true, 
    616                         'headers' => array(), 'body' => null, 'cookies' => array() 
    617                 ); 
     739                $config = new WP_Http_Config($url); 
    618740 
    619                 $r = wp_parse_args( $args, $defaults ); 
    620  
    621                 if ( isset($r['headers']['User-Agent']) ) { 
    622                         $r['user-agent'] = $r['headers']['User-Agent']; 
    623                         unset($r['headers']['User-Agent']); 
    624                 } else if( isset($r['headers']['user-agent']) ) { 
    625                         $r['user-agent'] = $r['headers']['user-agent']; 
    626                         unset($r['headers']['user-agent']); 
     741                $r = $args; 
     742                if( ! isset($args['processed']) && ! $args['processed'] ) { 
     743                        $config->process($args); 
     744                        $r = $config->get_arguments(); 
    627745                } 
    628746 
    629                 // Construct Cookie: header if any cookies are set 
    630                 WP_Http::buildCookieHeader( $r ); 
    631  
    632747                $iError = null; // Store error number 
    633748                $strError = null; // Store error string 
    634749 
     
    729844                        return array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() ); 
    730845                } 
    731846 
    732                 $strResponse = ''; 
    733                 while ( ! feof($handle) ) 
    734                         $strResponse .= fread($handle, 4096); 
    735  
     847                $strResponse = $this->_get_response(&$handle); 
    736848                fclose($handle); 
    737849 
    738850                if ( true === $secure_transport ) 
     
    765877        } 
    766878 
    767879        /** 
     880         * Retrieves the response message using resource handle. 
     881         * 
     882         * This should allow for others to inherit and extend the class to implement their own resource 
     883         * handling. A request was made a long time ago for handling long streams which will exhaust 
     884         * memory, but is not a feature that majority of developers will need. 
     885         * 
     886         * @param resource $handle Fsockopen resource 
     887         * @return string Response message (includes header and body). 
     888         */ 
     889        function _get_response(&$handle) { 
     890                $strResponse = ''; 
     891                while ( ! feof($handle) ) 
     892                        $strResponse .= fread($handle, 4096); 
     893 
     894                return $strResponse; 
     895        } 
     896 
     897        /** 
    768898         * Whether this class can be used for retrieving an URL. 
    769899         * 
    770900         * @since 2.7.0 
     
    818948         * @return array 'headers', 'body', 'cookies' and 'response' keys. 
    819949         */ 
    820950        function request($url, $args = array()) { 
    821                 $defaults = array( 
    822                         'method' => 'GET', 'timeout' => 5, 
    823                         'redirection' => 5, 'httpversion' => '1.0', 
    824                         'blocking' => true, 
    825                         'headers' => array(), 'body' => null, 'cookies' => array() 
    826                 ); 
     951                $config = new WP_Http_Config($url); 
    827952 
    828                 $r = wp_parse_args( $args, $defaults ); 
     953                $r = $args; 
     954                if( ! isset($args['processed']) && ! $args['processed'] ) { 
     955                        $config->process($args); 
     956                        $r = $config->get_arguments(); 
     957                } 
    829958 
    830959                $arrURL = parse_url($url); 
    831960 
     
    9611090         * @return array 'headers', 'body', 'cookies' and 'response' keys. 
    9621091         */ 
    9631092        function request($url, $args = array()) { 
    964                 $defaults = array( 
    965                         'method' => 'GET', 'timeout' => 5, 
    966                         'redirection' => 5, 'httpversion' => '1.0', 
    967                         'blocking' => true, 
    968                         'headers' => array(), 'body' => null, 'cookies' => array() 
    969                 ); 
     1093                $config = new WP_Http_Config($url); 
    9701094 
    971                 $r = wp_parse_args( $args, $defaults ); 
    972  
    973                 if ( isset($r['headers']['User-Agent']) ) { 
    974                         $r['user-agent'] = $r['headers']['User-Agent']; 
    975                         unset($r['headers']['User-Agent']); 
    976                 } else if( isset($r['headers']['user-agent']) ) { 
    977                         $r['user-agent'] = $r['headers']['user-agent']; 
    978                         unset($r['headers']['user-agent']); 
     1095                $r = $args; 
     1096                if( ! isset($args['processed']) && ! $args['processed'] ) { 
     1097                        $config->process($args); 
     1098                        $r = $config->get_arguments(); 
    9791099                } 
    9801100 
    981                 // Construct Cookie: header if any cookies are set 
    982                 WP_Http::buildCookieHeader( $r ); 
    983  
    9841101                $arrURL = parse_url($url); 
    9851102 
    9861103                if ( false === $arrURL ) 
     
    11341251         * @return array 'headers', 'body', 'cookies' and 'response' keys. 
    11351252         */ 
    11361253        function request($url, $args = array()) { 
    1137                 $defaults = array( 
    1138                         'method' => 'GET', 'timeout' => 5, 
    1139                         'redirection' => 5, 'httpversion' => '1.0', 
    1140                         'blocking' => true, 
    1141                         'headers' => array(), 'body' => null, 'cookies' => array() 
    1142                 ); 
     1254                $config = new WP_Http_Config($url); 
    11431255 
    1144                 $r = wp_parse_args( $args, $defaults ); 
    1145  
    1146                 if ( isset($r['headers']['User-Agent']) ) { 
    1147                         $r['user-agent'] = $r['headers']['User-Agent']; 
    1148                         unset($r['headers']['User-Agent']); 
    1149                 } else if( isset($r['headers']['user-agent']) ) { 
    1150                         $r['user-agent'] = $r['headers']['user-agent']; 
    1151                         unset($r['headers']['user-agent']); 
     1256                $r = $args; 
     1257                if( ! isset($args['processed']) && ! $args['processed'] ) { 
     1258                        $config->process($args); 
     1259                        $r = $config->get_arguments(); 
    11521260                } 
    11531261 
    1154                 // Construct Cookie: header if any cookies are set 
    1155                 WP_Http::buildCookieHeader( $r ); 
    1156  
    11571262                switch ( $r['method'] ) { 
    11581263                        case 'POST': 
    11591264                                $r['method'] = HTTP_METH_POST; 
     
    12251330                if ( ! $r['blocking'] ) 
    12261331                        return array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() ); 
    12271332 
    1228                 $headers_body = WP_HTTP::processResponse($strResponse); 
     1333                $headers_body = WP_Http::processResponse($strResponse); 
    12291334                $theHeaders = $headers_body['headers']; 
    12301335                $theBody = $headers_body['body']; 
    12311336                unset($headers_body); 
     
    12841389         * @return array 'headers', 'body', 'cookies' and 'response' keys. 
    12851390         */ 
    12861391        function request($url, $args = array()) { 
    1287                 $defaults = array( 
    1288                         'method' => 'GET', 'timeout' => 5, 
    1289                         'redirection' => 5, 'httpversion' => '1.0', 
    1290                         'blocking' => true, 
    1291                         'headers' => array(), 'body' => null, 'cookies' => array() 
    1292                 ); 
     1392                $config = new WP_Http_Config($url); 
    12931393 
    1294                 $r = wp_parse_args( $args, $defaults ); 
    1295  
    1296                 if ( isset($r['headers']['User-Agent']) ) { 
    1297                         $r['user-agent'] = $r['headers']['User-Agent']; 
    1298                         unset($r['headers']['User-Agent']); 
    1299                 } else if( isset($r['headers']['user-agent']) ) { 
    1300                         $r['user-agent'] = $r['headers']['user-agent']; 
    1301                         unset($r['headers']['user-agent']); 
     1394                $r = $args; 
     1395                if( ! isset($args['processed']) && ! $args['processed'] ) { 
     1396                        $config->process($args); 
     1397                        $r = $config->get_arguments(); 
    13021398                } 
    13031399 
    1304                 // Construct Cookie: header if any cookies are set. 
    1305                 WP_Http::buildCookieHeader( $r ); 
    1306  
    13071400                $handle = curl_init(); 
    13081401 
    13091402                // cURL offers really easy proxy support.