1 <?php

     2 /**

     3  * Simple and uniform HTTP request API.

     4  *

     5  * Will eventually replace and standardize the WordPress HTTP requests made.

     6  *

     7  * @link http://trac.wordpress.org/ticket/4779 HTTP API Proposal

     8  *

     9  * @package WordPress

    10  * @subpackage HTTP

    11  * @since 2.7.0

    12  * @author Jacob Santos <wordpress@santosj.name>

    13  */

    14 

    15 /**

    16  * WordPress HTTP Class for managing HTTP Transports and making HTTP requests.

    17  *

    18  * This class is called for the functionality of making HTTP requests and should replace Snoopy

    19  * functionality, eventually. There is no available functionality to add HTTP transport

    20  * implementations, since most of the HTTP transports are added and available for use.

    21  *

    22  * The exception is that cURL is not available as a transport and lacking an implementation. It will

    23  * be added later and should be a patch on the WordPress Trac.

    24  *

    25  * There are no properties, because none are needed and for performance reasons. Some of the

    26  * functions are static and while they do have some overhead over functions in PHP4, the purpose is

    27  * maintainability. When PHP5 is finally the requirement, it will be easy to add the static keyword

    28  * to the code. It is not as easy to convert a function to a method after enough code uses the old

    29  * way.

    30  *

    31  * Debugging includes several actions, which pass different variables for debugging the HTTP API.

    32  *

    33  * <strong>http_transport_get_debug</strong> - gives working, nonblocking, and blocking transports.

    34  *

    35  * <strong>http_transport_post_debug</strong> - gives working, nonblocking, and blocking transports.

    36  *

    37  * @package WordPress

    38  * @subpackage HTTP

    39  * @since 2.7.0

    40  */

    41 class WP_Http {

    42 

    43 	/**

    44 	 * PHP4 style Constructor - Calls PHP5 Style Constructor

    45 	 *

    46 	 * @since 2.7.0

    47 	 * @return WP_Http

    48 	 */

    49 	function WP_Http() {

    50 		$this->__construct();

    51 	}

    52 

    53 	/**

    54 	 * PHP5 style Constructor - Setup available transport if not available.

    55 	 *

    56 	 * PHP4 does not have the 'self' keyword and since WordPress supports PHP4,

    57 	 * the class needs to be used for the static call.

    58 	 *

    59 	 * The transport are setup to save time. This should only be called once, so

    60 	 * the overhead should be fine.

    61 	 *

    62 	 * @since 2.7.0

    63 	 * @return WP_Http

    64 	 */

    65 	function __construct() {

    66 		WP_Http::_getTransport();

    67 		WP_Http::_postTransport();

    68 	}

    69 

    70 	/**

    71 	 * Tests the WordPress HTTP objects for an object to use and returns it.

    72 	 *

    73 	 * Tests all of the objects and returns the object that passes. Also caches

    74 	 * that object to be used later.

    75 	 *

    76 	 * The order for the GET/HEAD requests are Streams, HTTP Extension, Fopen,

    77 	 * and finally Fsockopen. fsockopen() is used last, because it has the most

    78 	 * overhead in its implementation. There isn't any real way around it, since

    79 	 * redirects have to be supported, much the same way the other transports

    80 	 * also handle redirects.

    81 	 *

    82 	 * There are currently issues with "localhost" not resolving correctly with

    83 	 * DNS. This may cause an error "failed to open stream: A connection attempt

    84 	 * failed because the connected party did not properly respond after a

    85 	 * period of time, or established connection failed because connected host

    86 	 * has failed to respond."

    87 	 *

    88 	 * @since 2.7.0

    89 	 * @access private

    90 	 *

    91 	 * @param array $args Request args, default us an empty array

    92 	 * @return object|null Null if no transports are available, HTTP transport object.

    93 	 */

    94 	function &_getTransport( $args = array() ) {

    95 		static $working_transport, $blocking_transport, $nonblocking_transport;

    96 

    97 		if ( is_null($working_transport) ) {

    98 			if ( true === WP_Http_ExtHttp::test($args) ) {

    99 				$working_transport['exthttp'] = new WP_Http_ExtHttp();

   100 				$blocking_transport[] = &$working_transport['exthttp'];

   101 			} else if ( true === WP_Http_Curl::test($args) ) {

   102 				$working_transport['curl'] = new WP_Http_Curl();

   103 				$blocking_transport[] = &$working_transport['curl'];

   104 			} else if ( true === WP_Http_Streams::test($args) ) {

   105 				$working_transport['streams'] = new WP_Http_Streams();

   106 				$blocking_transport[] = &$working_transport['streams'];

   107 			} else if ( true === WP_Http_Fopen::test($args) ) {

   108 				$working_transport['fopen'] = new WP_Http_Fopen();

   109 				$blocking_transport[] = &$working_transport['fopen'];

   110 			} else if ( true === WP_Http_Fsockopen::test($args) ) {

   111 				$working_transport['fsockopen'] = new WP_Http_Fsockopen();

   112 				$blocking_transport[] = &$working_transport['fsockopen'];

   113 			}

   114 

   115 			foreach ( array('curl', 'streams', 'fopen', 'fsockopen', 'exthttp') as $transport ) {

   116 				if ( isset($working_transport[$transport]) )

   117 					$nonblocking_transport[] = &$working_transport[$transport];

   118 			}

   119 		}

   120 

   121 		do_action( 'http_transport_get_debug', $working_transport, $blocking_transport, $nonblocking_transport );

   122 

   123 		if ( isset($args['blocking']) && !$args['blocking'] )

   124 			return $nonblocking_transport;

   125 		else

   126 			return $blocking_transport;

   127 	}

   128 

   129 	/**

   130 	 * Tests the WordPress HTTP objects for an object to use and returns it.

   131 	 *

   132 	 * Tests all of the objects and returns the object that passes. Also caches

   133 	 * that object to be used later. This is for posting content to a URL and

   134 	 * is used when there is a body. The plain Fopen Transport can not be used

   135 	 * to send content, but the streams transport can. This is a limitation that

   136 	 * is addressed here, by just not including that transport.

   137 	 *

   138 	 * @since 2.7.0

   139 	 * @access private

   140 	 *

   141 	 * @param array $args Request args, default us an empty array

   142 	 * @return object|null Null if no transports are available, HTTP transport object.

   143 	 */

   144 	function &_postTransport( $args = array() ) {

   145 		static $working_transport, $blocking_transport, $nonblocking_transport;

   146 

   147 		if ( is_null($working_transport) ) {

   148 			if ( true === WP_Http_ExtHttp::test($args) ) {

   149 				$working_transport['exthttp'] = new WP_Http_ExtHttp();

   150 				$blocking_transport[] = &$working_transport['exthttp'];

   151 			} else if ( true === WP_Http_Curl::test($args) ) {

   152 				$working_transport['curl'] = new WP_Http_Curl();

   153 				$blocking_transport[] = &$working_transport['curl'];

   154 			} else if ( true === WP_Http_Streams::test($args) ) {

   155 				$working_transport['streams'] = new WP_Http_Streams();

   156 				$blocking_transport[] = &$working_transport['streams'];

   157 			} else if ( true === WP_Http_Fsockopen::test($args) ) {

   158 				$working_transport['fsockopen'] = new WP_Http_Fsockopen();

   159 				$blocking_transport[] = &$working_transport['fsockopen'];

   160 			}

   161 

   162 			foreach ( array('curl', 'streams', 'fsockopen', 'exthttp') as $transport ) {

   163 				if ( isset($working_transport[$transport]) )

   164 					$nonblocking_transport[] = &$working_transport[$transport];

   165 			}

   166 		}

   167 

   168 		do_action( 'http_transport_post_debug', $working_transport, $blocking_transport, $nonblocking_transport );

   169 

   170 		if ( isset($args['blocking']) && !$args['blocking'] )

   171 			return $nonblocking_transport;

   172 		else

   173 			return $blocking_transport;

   174 	}

   175 

   176 	/**

   177 	 * Send a HTTP request to a URI.

   178 	 *

   179 	 * The body and headers are part of the arguments. The 'body' argument is for the body and will

   180 	 * accept either a string or an array. The 'headers' argument should be an array, but a string

   181 	 * is acceptable. If the 'body' argument is an array, then it will automatically be escaped

   182 	 * using http_build_query().

   183 	 *

   184 	 * The only URI that are supported in the HTTP Transport implementation are the HTTP and HTTPS

   185 	 * protocols. HTTP and HTTPS are assumed so the server might not know how to handle the send

   186 	 * headers. Other protocols are unsupported and most likely will fail.

   187 	 *

   188 	 * The defaults are 'method', 'timeout', 'redirection', 'httpversion', 'blocking' and

   189 	 * 'user-agent'.

   190 	 *

   191 	 * Accepted 'method' values are 'GET', 'POST', and 'HEAD', some transports technically allow

   192 	 * others, but should not be assumed. The 'timeout' is used to sent how long the connection

   193 	 * should stay open before failing when no response. 'redirection' is used to track how many

   194 	 * redirects were taken and used to sent the amount for other transports, but not all transports

   195 	 * accept setting that value.

   196 	 *

   197 	 * The 'httpversion' option is used to sent the HTTP version and accepted values are '1.0', and

   198 	 * '1.1' and should be a string. Version 1.1 is not supported, because of chunk response. The

   199 	 * 'user-agent' option is the user-agent and is used to replace the default user-agent, which is

   200 	 * 'WordPress/WP_Version', where WP_Version is the value from $wp_version.

   201 	 *

   202 	 * 'blocking' is the default, which is used to tell the transport, whether it should halt PHP

   203 	 * while it performs the request or continue regardless. Actually, that isn't entirely correct.

   204 	 * Blocking mode really just means whether the fread should just pull what it can whenever it

   205 	 * gets bytes or if it should wait until it has enough in the buffer to read or finishes reading

   206 	 * the entire content. It doesn't actually always mean that PHP will continue going after making

   207 	 * the request.

   208 	 *

   209 	 * @access public

   210 	 * @since 2.7.0

   211 	 * @todo Refactor this code. The code in this method extends the scope of its original purpose

   212 	 *		and should be refactored to allow for cleaner abstraction and reduce duplication of the

   213 	 *		code. One suggestion is to create a class specifically for the arguments, however

   214 	 *		preliminary refactoring to this affect has affect more than just the scope of the

   215 	 *		arguments. Something to ponder at least.

   216 	 *

   217 	 * @param string $url URI resource.

   218 	 * @param str|array $args Optional. Override the defaults.

   219 	 * @return array containing 'headers', 'body', 'response', 'cookies'

   220 	 */

   221 	function request( $url, $args = array() ) {

   222 		global $wp_version;

   223 

   224 		$defaults = array(

   225 			'method' => 'GET',

   226 			'timeout' => apply_filters( 'http_request_timeout', 5),

   227 			'redirection' => apply_filters( 'http_request_redirection_count', 5),

   228 			'httpversion' => apply_filters( 'http_request_version', '1.0'),

   229 			'user-agent' => apply_filters( 'http_headers_useragent', 'WordPress/' . $wp_version . '; ' . get_bloginfo( 'url' )  ),

   230 			'blocking' => true,

   231 			'headers' => array(),

   232 			'cookies' => array(),

   233 			'body' => null,

   234 			'compress' => false,

   235 			'decompress' => true,

   236 			'sslverify' => true

   237 		);

   238 

   239 		$r = wp_parse_args( $args, $defaults );

   240 		$r = apply_filters( 'http_request_args', $r, $url );

   241 

   242 		// Allow plugins to short-circuit the request

   243 		$pre = apply_filters( 'pre_http_request', false, $r, $url );

   244 		if ( false !== $pre )

   245 			return $pre;

   246 

   247 		$arrURL = parse_url($url);

   248 

   249 		if ( $this->block_request( $url ) )

   250 			return new WP_Error('http_request_failed', __('User has blocked requests through HTTP.'));

   251 

   252 		// Determine if this is a https call and pass that on to the transport functions

   253 		// so that we can blacklist the transports that do not support ssl verification

   254 		$r['ssl'] = $arrURL['scheme'] == 'https' || $arrURL['scheme'] == 'ssl';

   255 

   256 		// Determine if this request is to OUR install of WordPress

   257 		$homeURL = parse_url(get_bloginfo('url'));

   258 		$r['local'] = $homeURL['host'] == $arrURL['host'] || 'localhost' == $arrURL['host'];

   259 		unset($homeURL);

   260 

   261 		if ( is_null( $r['headers'] ) )

   262 			$r['headers'] = array();

   263 

   264 		if ( ! is_array($r['headers']) ) {

   265 			$processedHeaders = WP_Http::processHeaders($r['headers']);

   266 			$r['headers'] = $processedHeaders['headers'];

   267 		}

   268 

   269 		if ( isset($r['headers']['User-Agent']) ) {

   270 			$r['user-agent'] = $r['headers']['User-Agent'];

   271 			unset($r['headers']['User-Agent']);

   272 		}

   273 

   274 		if ( isset($r['headers']['user-agent']) ) {

   275 			$r['user-agent'] = $r['headers']['user-agent'];

   276 			unset($r['headers']['user-agent']);

   277 		}

   278 

   279 		// Construct Cookie: header if any cookies are set

   280 		WP_Http::buildCookieHeader( $r );

   281 

   282 		if ( WP_Http_Encoding::is_available() )

   283 			$r['headers']['Accept-Encoding'] = WP_Http_Encoding::accept_encoding();

   284 

   285 		if ( empty($r['body']) ) {

   286 			// Some servers fail when sending content without the content-length header being set.

   287 			// Also, to fix another bug, we only send when doing POST and PUT and the content-length

   288 			// header isn't already set.

   289 			if( ($r['method'] == 'POST' || $r['method'] == 'PUT') && ! isset($r['headers']['Content-Length']) )

   290 				$r['headers']['Content-Length'] = 0;

   291 

   292 			// The method is ambiguous, because we aren't talking about HTTP methods, the "get" in

   293 			// this case is simply that we aren't sending any bodies and to get the transports that

   294 			// don't support sending bodies along with those which do.

   295 			$transports = WP_Http::_getTransport($r);

   296 		} else {

   297 			if ( is_array( $r['body'] ) || is_object( $r['body'] ) ) {

   298 				if ( ! version_compare(phpversion(), '5.1.2', '>=') )

   299 					$r['body'] = _http_build_query($r['body'], null, '&');

   300 				else

   301 					$r['body'] = http_build_query($r['body'], null, '&');

   302 				$r['headers']['Content-Type'] = 'application/x-www-form-urlencoded; charset=' . get_option('blog_charset');

   303 				$r['headers']['Content-Length'] = strlen($r['body']);

   304 			}

   305 

   306 			if ( ! isset( $r['headers']['Content-Length'] ) && ! isset( $r['headers']['content-length'] ) )

   307 				$r['headers']['Content-Length'] = strlen($r['body']);

   308 

   309 			// The method is ambiguous, because we aren't talking about HTTP methods, the "post" in

   310 			// this case is simply that we are sending HTTP body and to get the transports that do

   311 			// support sending the body. Not all do, depending on the limitations of the PHP core

   312 			// limitations.

   313 			$transports = WP_Http::_postTransport($r);

   314 		}

   315 

   316 		do_action( 'http_api_debug', $transports, 'transports_list' );

   317 

   318 		$response = array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() );

   319 		foreach ( (array) $transports as $transport ) {

   320 			$response = $transport->request($url, $r);

   321 

   322 			do_action( 'http_api_debug', $response, 'response', get_class($transport) );

   323 

   324 			if ( ! is_wp_error($response) )

   325 				return apply_filters( 'http_response', $response, $r, $url );

   326 		}

   327 

   328 		return $response;

   329 	}

   330 

   331 	/**

   332 	 * Uses the POST HTTP method.

   333 	 *

   334 	 * Used for sending data that is expected to be in the body.

   335 	 *

   336 	 * @access public

   337 	 * @since 2.7.0

   338 	 *

   339 	 * @param string $url URI resource.

   340 	 * @param str|array $args Optional. Override the defaults.

   341 	 * @return boolean

   342 	 */

   343 	function post($url, $args = array()) {

   344 		$defaults = array('method' => 'POST');

   345 		$r = wp_parse_args( $args, $defaults );

   346 		return $this->request($url, $r);

   347 	}

   348 

   349 	/**

   350 	 * Uses the GET HTTP method.

   351 	 *

   352 	 * Used for sending data that is expected to be in the body.

   353 	 *

   354 	 * @access public

   355 	 * @since 2.7.0

   356 	 *

   357 	 * @param string $url URI resource.

   358 	 * @param str|array $args Optional. Override the defaults.

   359 	 * @return boolean

   360 	 */

   361 	function get($url, $args = array()) {

   362 		$defaults = array('method' => 'GET');

   363 		$r = wp_parse_args( $args, $defaults );

   364 		return $this->request($url, $r);

   365 	}

   366 

   367 	/**

   368 	 * Uses the HEAD HTTP method.

   369 	 *

   370 	 * Used for sending data that is expected to be in the body.

   371 	 *

   372 	 * @access public

   373 	 * @since 2.7.0

   374 	 *

   375 	 * @param string $url URI resource.

   376 	 * @param str|array $args Optional. Override the defaults.

   377 	 * @return boolean

   378 	 */

   379 	function head($url, $args = array()) {

   380 		$defaults = array('method' => 'HEAD');

   381 		$r = wp_parse_args( $args, $defaults );

   382 		return $this->request($url, $r);

   383 	}

   384 

   385 	/**

   386 	 * Parses the responses and splits the parts into headers and body.

   387 	 *

   388 	 * @access public

   389 	 * @static

   390 	 * @since 2.7.0

   391 	 *

   392 	 * @param string $strResponse The full response string

   393 	 * @return array Array with 'headers' and 'body' keys.

   394 	 */

   395 	function processResponse($strResponse) {

   396 		list($theHeaders, $theBody) = explode("\r\n\r\n", $strResponse, 2);

   397 		return array('headers' => $theHeaders, 'body' => $theBody);

   398 	}

   399 

   400 	/**

   401 	 * Transform header string into an array.

   402 	 *

   403 	 * If an array is given then it is assumed to be raw header data with numeric keys with the

   404 	 * headers as the values. No headers must be passed that were already processed.

   405 	 *

   406 	 * @access public

   407 	 * @static

   408 	 * @since 2.7.0

   409 	 *

   410 	 * @param string|array $headers

   411 	 * @return array Processed string headers. If duplicate headers are encountered,

   412 	 * 					Then a numbered array is returned as the value of that header-key.

   413 	 */

   414 	function processHeaders($headers) {

   415 		// split headers, one per array element

   416 		if ( is_string($headers) ) {

   417 			// tolerate line terminator: CRLF = LF (RFC 2616 19.3)

   418 			$headers = str_replace("\r\n", "\n", $headers);

   419 			// unfold folded header fields. LWS = [CRLF] 1*( SP | HT ) <US-ASCII SP, space (32)>, <US-ASCII HT, horizontal-tab (9)> (RFC 2616 2.2)

   420 			$headers = preg_replace('/\n[ \t]/', ' ', $headers);

   421 			// create the headers array

   422 			$headers = explode("\n", $headers);

   423 		}

   424 

   425 		$response = array('code' => 0, 'message' => '');

   426 

   427 		$cookies = array();

   428 		$newheaders = array();

   429 		foreach ( $headers as $tempheader ) {

   430 			if ( empty($tempheader) )

   431 				continue;

   432 

   433 			if ( false === strpos($tempheader, ':') ) {

   434 				list( , $iResponseCode, $strResponseMsg) = explode(' ', $tempheader, 3);

   435 				$response['code'] = $iResponseCode;

   436 				$response['message'] = $strResponseMsg;

   437 				continue;

   438 			}

   439 

   440 			list($key, $value) = explode(':', $tempheader, 2);

   441 

   442 			if ( !empty( $value ) ) {

   443 				$key = strtolower( $key );

   444 				if ( isset( $newheaders[$key] ) ) {

   445 					$newheaders[$key] = array( $newheaders[$key], trim( $value ) );

   446 				} else {

   447 					$newheaders[$key] = trim( $value );

   448 				}

   449 				if ( 'set-cookie' == strtolower( $key ) )

   450 					$cookies[] = new WP_Http_Cookie( $value );

   451 			}

   452 		}

   453 

   454 		return array('response' => $response, 'headers' => $newheaders, 'cookies' => $cookies);

   455 	}

   456 

   457 	/**

   458 	 * Takes the arguments for a ::request() and checks for the cookie array.

   459 	 *

   460 	 * If it's found, then it's assumed to contain WP_Http_Cookie objects, which are each parsed

   461 	 * into strings and added to the Cookie: header (within the arguments array). Edits the array by

   462 	 * reference.

   463 	 *

   464 	 * @access public

   465 	 * @version 2.8.0

   466 	 * @static

   467 	 *

   468 	 * @param array $r Full array of args passed into ::request()

   469 	 */

   470 	function buildCookieHeader( &$r ) {

   471 		if ( ! empty($r['cookies']) ) {

   472 			$cookies_header = '';

   473 			foreach ( (array) $r['cookies'] as $cookie ) {

   474 				$cookies_header .= $cookie->getHeaderValue() . '; ';

   475 			}

   476 			$cookies_header = substr( $cookies_header, 0, -2 );

   477 			$r['headers']['cookie'] = $cookies_header;

   478 		}

   479 	}

   480 

   481 	/**

   482 	 * Decodes chunk transfer-encoding, based off the HTTP 1.1 specification.

   483 	 *

   484 	 * Based off the HTTP http_encoding_dechunk function. Does not support UTF-8. Does not support

   485 	 * returning footer headers. Shouldn't be too difficult to support it though.

   486 	 *

   487 	 * @todo Add support for footer chunked headers.

   488 	 * @access public

   489 	 * @since 2.7.0

   490 	 * @static

   491 	 *

   492 	 * @param string $body Body content

   493 	 * @return string Chunked decoded body on success or raw body on failure.

   494 	 */

   495 	function chunkTransferDecode($body) {

   496 		$body = str_replace(array("\r\n", "\r"), "\n", $body);

   497 		// The body is not chunked encoding or is malformed.

   498 		if ( ! preg_match( '/^[0-9a-f]+(\s|\n)+/mi', trim($body) ) )

   499 			return $body;

   500 

   501 		$parsedBody = '';

   502 		//$parsedHeaders = array(); Unsupported

   503 

   504 		while ( true ) {

   505 			$hasChunk = (bool) preg_match( '/^([0-9a-f]+)(\s|\n)+/mi', $body, $match );

   506 

   507 			if ( $hasChunk ) {

   508 				if ( empty( $match[1] ) )

   509 					return $body;

   510 

   511 				$length = hexdec( $match[1] );

   512 				$chunkLength = strlen( $match[0] );

   513 

   514 				$strBody = substr($body, $chunkLength, $length);

   515 				$parsedBody .= $strBody;

   516 

   517 				$body = ltrim(str_replace(array($match[0], $strBody), '', $body), "\n");

   518 

   519 				if ( "0" == trim($body) )

   520 					return $parsedBody; // Ignore footer headers.

   521 			} else {

   522 				return $body;

   523 			}

   524 		}

   525 	}

   526 

   527 	/**

   528 	 * Block requests through the proxy.

   529 	 *

   530 	 * Those who are behind a proxy and want to prevent access to certain hosts may do so. This will

   531 	 * prevent plugins from working and core functionality, if you don't include api.wordpress.org.

   532 	 *

   533 	 * You block external URL requests by defining WP_HTTP_BLOCK_EXTERNAL in your wp-config.php file

   534 	 * and this will only allow localhost and your blog to make requests. The constant

   535 	 * WP_ACCESSIBLE_HOSTS will allow additional hosts to go through for requests. The format of the

   536 	 * WP_ACCESSIBLE_HOSTS constant is a comma separated list of hostnames to allow.

   537 	 *

   538 	 * @since 2.8.0

   539 	 * @link http://core.trac.wordpress.org/ticket/8927 Allow preventing external requests.

   540 	 *

   541 	 * @param string $uri URI of url.

   542 	 * @return bool True to block, false to allow.

   543 	 */

   544 	function block_request($uri) {

   545 		// We don't need to block requests, because nothing is blocked.

   546 		if ( ! defined('WP_HTTP_BLOCK_EXTERNAL') || ( defined('WP_HTTP_BLOCK_EXTERNAL') && WP_HTTP_BLOCK_EXTERNAL == false ) )

   547 			return false;

   548 

   549 		// parse_url() only handles http, https type URLs, and will emit E_WARNING on failure.

   550 		// This will be displayed on blogs, which is not reasonable.

   551 		$check = @parse_url($uri);

   552 

   553 		/* Malformed URL, can not process, but this could mean ssl, so let through anyway.

   554 		 *

   555 		 * This isn't very security sound. There are instances where a hacker might attempt

   556 		 * to bypass the proxy and this check. However, the reason for this behavior is that

   557 		 * WordPress does not do any checking currently for non-proxy requests, so it is keeps with

   558 		 * the default unsecure nature of the HTTP request.

   559 		 */

   560 		if ( $check === false )

   561 			return false;

   562 

   563 		$home = parse_url( get_option('siteurl') );

   564 

   565 		// Don't block requests back to ourselves by default

   566 		if ( $check['host'] == 'localhost' || $check['host'] == $home['host'] )

   567 			return apply_filters('block_local_requests', false);

   568 

   569 		if ( !defined('WP_ACCESSIBLE_HOSTS') )

   570 			return true;

   571 

   572 		static $accessible_hosts;

   573 		if ( null == $accessible_hosts )

   574 			$accessible_hosts = preg_split('|,\s*|', WP_ACCESSIBLE_HOSTS);

   575 

   576 		return !in_array( $check['host'], $accessible_hosts ); //Inverse logic, If its in the array, then we can't access it.

   577 	}

   578 }

   579 

   580 /**

   581  * HTTP request method uses fsockopen function to retrieve the url.

   582  *

   583  * This would be the preferred method, but the fsockopen implementation has the most overhead of all

   584  * the HTTP transport implementations.

   585  *

   586  * @package WordPress

   587  * @subpackage HTTP

   588  * @since 2.7.0

   589  */

   590 class WP_Http_Fsockopen {

   591 	/**

   592 	 * Send a HTTP request to a URI using fsockopen().

   593 	 *

   594 	 * Does not support non-blocking mode.

   595 	 *

   596 	 * @see WP_Http::request For default options descriptions.

   597 	 *

   598 	 * @since 2.7

   599 	 * @access public

   600 	 * @param string $url URI resource.

   601 	 * @param str|array $args Optional. Override the defaults.

   602 	 * @return array 'headers', 'body', 'cookies' and 'response' keys.

   603 	 */

   604 	function request($url, $args = array()) {

   605 		$defaults = array(

   606 			'method' => 'GET', 'timeout' => 5,

   607 			'redirection' => 5, 'httpversion' => '1.0',

   608 			'blocking' => true,

   609 			'headers' => array(), 'body' => null, 'cookies' => array()

   610 		);

   611 

   612 		$r = wp_parse_args( $args, $defaults );

   613 

   614 		if ( isset($r['headers']['User-Agent']) ) {

   615 			$r['user-agent'] = $r['headers']['User-Agent'];

   616 			unset($r['headers']['User-Agent']);

   617 		} else if( isset($r['headers']['user-agent']) ) {

   618 			$r['user-agent'] = $r['headers']['user-agent'];

   619 			unset($r['headers']['user-agent']);

   620 		}

   621 

   622 		// Construct Cookie: header if any cookies are set

   623 		WP_Http::buildCookieHeader( $r );

   624 

   625 		$iError = null; // Store error number

   626 		$strError = null; // Store error string

   627 

   628 		$arrURL = parse_url($url);

   629 

   630 		$fsockopen_host = $arrURL['host'];

   631 

   632 		$secure_transport = false;

   633 

   634 		if ( ! isset( $arrURL['port'] ) ) {

   635 			if ( ( $arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https' ) && extension_loaded('openssl') ) {

   636 				$fsockopen_host = "ssl://$fsockopen_host";

   637 				$arrURL['port'] = 443;

   638 				$secure_transport = true;

   639 			} else {

   640 				$arrURL['port'] = 80;

   641 			}

   642 		}

   643 

   644 		//fsockopen has issues with 'localhost' with IPv6 with certain versions of PHP, It attempts to connect to ::1,

   645 		// which fails when the server is not setup for it. For compatibility, always connect to the IPv4 address.

   646 		if ( 'localhost' == strtolower($fsockopen_host) )

   647 			$fsockopen_host = '127.0.0.1';

   648 

   649 		// There are issues with the HTTPS and SSL protocols that cause errors that can be safely

   650 		// ignored and should be ignored.

   651 		if ( true === $secure_transport )

   652 			$error_reporting = error_reporting(0);

   653 

   654 		$startDelay = time();

   655 

   656 		$proxy = new WP_HTTP_Proxy();

   657 

   658 		if ( !WP_DEBUG ) {

   659 			if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )

   660 				$handle = @fsockopen( $proxy->host(), $proxy->port(), $iError, $strError, $r['timeout'] );

   661 			else

   662 				$handle = @fsockopen( $fsockopen_host, $arrURL['port'], $iError, $strError, $r['timeout'] );

   663 		} else {

   664 			if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )

   665 				$handle = fsockopen( $proxy->host(), $proxy->port(), $iError, $strError, $r['timeout'] );

   666 			else

   667 				$handle = fsockopen( $fsockopen_host, $arrURL['port'], $iError, $strError, $r['timeout'] );

   668 		}

   669 

   670 		$endDelay = time();

   671 

   672 		// If the delay is greater than the timeout then fsockopen should't be used, because it will

   673 		// cause a long delay.

   674 		$elapseDelay = ($endDelay-$startDelay) > $r['timeout'];

   675 		if ( true === $elapseDelay )

   676 			add_option( 'disable_fsockopen', $endDelay, null, true );

   677 

   678 		if ( false === $handle )

   679 			return new WP_Error('http_request_failed', $iError . ': ' . $strError);

   680 

   681 		$timeout = (int) floor( $r['timeout'] );

   682 		$utimeout = $timeout == $r['timeout'] ? 0 : 1000000 * $r['timeout'] % 1000000;

   683 		stream_set_timeout( $handle, $timeout, $utimeout );

   684 

   685 		if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) //Some proxies require full URL in this field.

   686 			$requestPath = $url;

   687 		else

   688 			$requestPath = $arrURL['path'] . ( isset($arrURL['query']) ? '?' . $arrURL['query'] : '' );

   689 

   690 		if ( empty($requestPath) )

   691 			$requestPath .= '/';

   692 

   693 		$strHeaders = strtoupper($r['method']) . ' ' . $requestPath . ' HTTP/' . $r['httpversion'] . "\r\n";

   694 

   695 		if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )

   696 			$strHeaders .= 'Host: ' . $arrURL['host'] . ':' . $arrURL['port'] . "\r\n";

   697 		else

   698 			$strHeaders .= 'Host: ' . $arrURL['host'] . "\r\n";

   699 

   700 		if ( isset($r['user-agent']) )

   701 			$strHeaders .= 'User-agent: ' . $r['user-agent'] . "\r\n";

   702 

   703 		if ( is_array($r['headers']) ) {

   704 			foreach ( (array) $r['headers'] as $header => $headerValue )

   705 				$strHeaders .= $header . ': ' . $headerValue . "\r\n";

   706 		} else {

   707 			$strHeaders .= $r['headers'];

   708 		}

   709 

   710 		if ( $proxy->use_authentication() )

   711 			$strHeaders .= $proxy->authentication_header() . "\r\n";

   712 

   713 		$strHeaders .= "\r\n";

   714 

   715 		if ( ! is_null($r['body']) )

   716 			$strHeaders .= $r['body'];

   717 

   718 		fwrite($handle, $strHeaders);

   719 

   720 		if ( ! $r['blocking'] ) {

   721 			fclose($handle);

   722 			return array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() );

   723 		}

   724 

   725 		$strResponse = '';

   726 		while ( ! feof($handle) )

   727 			$strResponse .= fread($handle, 4096);

   728 

   729 		fclose($handle);

   730 

   731 		if ( true === $secure_transport )

   732 			error_reporting($error_reporting);

   733 

   734 		$process = WP_Http::processResponse($strResponse);

   735 		$arrHeaders = WP_Http::processHeaders($process['headers']);

   736 

   737 		// Is the response code within the 400 range?

   738 		if ( (int) $arrHeaders['response']['code'] >= 400 && (int) $arrHeaders['response']['code'] < 500 )

   739 			return new WP_Error('http_request_failed', $arrHeaders['response']['code'] . ': ' . $arrHeaders['response']['message']);

   740 

   741 		// If location is found, then assume redirect and redirect to location.

   742 		if ( isset($arrHeaders['headers']['location']) ) {

   743 			if ( $r['redirection']-- > 0 ) {

   744 				return $this->request($arrHeaders['headers']['location'], $r);

   745 			} else {

   746 				return new WP_Error('http_request_failed', __('Too many redirects.'));

   747 			}

   748 		}

   749 

   750 		// If the body was chunk encoded, then decode it.

   751 		if ( ! empty( $process['body'] ) && isset( $arrHeaders['headers']['transfer-encoding'] ) && 'chunked' == $arrHeaders['headers']['transfer-encoding'] )

   752 			$process['body'] = WP_Http::chunkTransferDecode($process['body']);

   753 

   754 		if ( true === $r['decompress'] && true === WP_Http_Encoding::should_decode($arrHeaders['headers']) )

   755 			$process['body'] = WP_Http_Encoding::decompress( $process['body'] );

   756 

   757 		return array('headers' => $arrHeaders['headers'], 'body' => $process['body'], 'response' => $arrHeaders['response'], 'cookies' => $arrHeaders['cookies']);

   758 	}

   759 

   760 	/**

   761 	 * Whether this class can be used for retrieving an URL.

   762 	 *

   763 	 * @since 2.7.0

   764 	 * @static

   765 	 * @return boolean False means this class can not be used, true means it can.

   766 	 */

   767 	function test( $args = array() ) {

   768 		if ( false !== ($option = get_option( 'disable_fsockopen' )) && time()-$option < 43200 ) // 12 hours

   769 			return false;

   770 

   771 		$is_ssl = isset($args['ssl']) && $args['ssl'];

   772 

   773 		if ( ! $is_ssl && function_exists( 'fsockopen' ) )

   774 			$use = true;

   775 		elseif ( $is_ssl && extension_loaded('openssl') && function_exists( 'fsockopen' ) )

   776 			$use = true;

   777 		else

   778 			$use = false;

   779 

   780 		return apply_filters('use_fsockopen_transport', $use, $args);

   781 	}

   782 }

   783 

   784 /**

   785  * HTTP request method uses fopen function to retrieve the url.

   786  *

   787  * Requires PHP version greater than 4.3.0 for stream support. Does not allow for $context support,

   788  * but should still be okay, to write the headers, before getting the response. Also requires that

   789  * 'allow_url_fopen' to be enabled.

   790  *

   791  * @package WordPress

   792  * @subpackage HTTP

   793  * @since 2.7.0

   794  */

   795 class WP_Http_Fopen {

   796 	/**

   797 	 * Send a HTTP request to a URI using fopen().

   798 	 *

   799 	 * This transport does not support sending of headers and body, therefore should not be used in

   800 	 * the instances, where there is a body and headers.

   801 	 *

   802 	 * Notes: Does not support non-blocking mode. Ignores 'redirection' option.

   803 	 *

   804 	 * @see WP_Http::retrieve For default options descriptions.

   805 	 *

   806 	 * @access public

   807 	 * @since 2.7.0

   808 	 *

   809 	 * @param string $url URI resource.

   810 	 * @param str|array $args Optional. Override the defaults.

   811 	 * @return array 'headers', 'body', 'cookies' and 'response' keys.

   812 	 */

   813 	function request($url, $args = array()) {

   814 		$defaults = array(

   815 			'method' => 'GET', 'timeout' => 5,

   816 			'redirection' => 5, 'httpversion' => '1.0',

   817 			'blocking' => true,

   818 			'headers' => array(), 'body' => null, 'cookies' => array()

   819 		);

   820 

   821 		$r = wp_parse_args( $args, $defaults );

   822 

   823 		$arrURL = parse_url($url);

   824 

   825 		if ( false === $arrURL )

   826 			return new WP_Error('http_request_failed', sprintf(__('Malformed URL: %s'), $url));

   827 

   828 		if ( 'http' != $arrURL['scheme'] && 'https' != $arrURL['scheme'] )

   829 			$url = str_replace($arrURL['scheme'], 'http', $url);

   830 

   831 		if ( !WP_DEBUG )

   832 			$handle = @fopen($url, 'r');

   833 		else

   834 			$handle = fopen($url, 'r');

   835 

   836 		if (! $handle)

   837 			return new WP_Error('http_request_failed', sprintf(__('Could not open handle for fopen() to %s'), $url));

   838 

   839 		$timeout = (int) floor( $r['timeout'] );

   840 		$utimeout = $timeout == $r['timeout'] ? 0 : 1000000 * $r['timeout'] % 1000000;

   841 		stream_set_timeout( $handle, $timeout, $utimeout );

   842 

   843 		if ( ! $r['blocking'] ) {

   844 			fclose($handle);

   845 			return array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() );

   846 		}

   847 

   848 		$strResponse = '';

   849 		while ( ! feof($handle) )

   850 			$strResponse .= fread($handle, 4096);

   851 

   852 		if ( function_exists('stream_get_meta_data') ) {

   853 			$meta = stream_get_meta_data($handle);

   854 			$theHeaders = $meta['wrapper_data'];

   855 			if ( isset( $meta['wrapper_data']['headers'] ) )

   856 				$theHeaders = $meta['wrapper_data']['headers'];

   857 		} else {

   858 			//$http_response_header is a PHP reserved variable which is set in the current-scope when using the HTTP Wrapper

   859 			//see http://php.oregonstate.edu/manual/en/reserved.variables.httpresponseheader.php

   860 			$theHeaders = $http_response_header;

   861 		}

   862 

   863 		fclose($handle);

   864 

   865 		$processedHeaders = WP_Http::processHeaders($theHeaders);

   866 

   867 		if ( ! empty( $strResponse ) && isset( $processedHeaders['headers']['transfer-encoding'] ) && 'chunked' == $processedHeaders['headers']['transfer-encoding'] )

   868 			$strResponse = WP_Http::chunkTransferDecode($strResponse);

   869 

   870 		if ( true === $r['decompress'] && true === WP_Http_Encoding::should_decode($processedHeaders['headers']) )

   871 			$strResponse = WP_Http_Encoding::decompress( $strResponse );

   872 

   873 		return array('headers' => $processedHeaders['headers'], 'body' => $strResponse, 'response' => $processedHeaders['response'], 'cookies' => $processedHeaders['cookies']);

   874 	}

   875 

   876 	/**

   877 	 * Whether this class can be used for retrieving an URL.

   878 	 *

   879 	 * @since 2.7.0

   880 	 * @static

   881 	 * @return boolean False means this class can not be used, true means it can.

   882 	 */

   883 	function test($args = array()) {

   884 		if ( ! function_exists('fopen') || (function_exists('ini_get') && true != ini_get('allow_url_fopen')) )

   885 			return false;

   886 

   887 		$use = true;

   888 

   889 		//PHP does not verify SSL certs, We can only make a request via this transports if SSL Verification is turned off.

   890 		$is_ssl = isset($args['ssl']) && $args['ssl'];

   891 		if ( $is_ssl ) {

   892 			$is_local = isset($args['local']) && $args['local'];

   893 			$ssl_verify = isset($args['sslverify']) && $args['sslverify'];

   894 			if ( $is_local && true != apply_filters('https_local_ssl_verify', true) )

   895 				$use = true;

   896 			elseif ( !$is_local && true != apply_filters('https_ssl_verify', true) )

   897 				$use = true;

   898 			elseif ( !$ssl_verify )

   899 				$use = true;

   900 			else

   901 				$use = false;

   902 		}

   903 

   904 		return apply_filters('use_fopen_transport', $use, $args);

   905 	}

   906 }

   907 

   908 /**

   909  * HTTP request method uses Streams to retrieve the url.

   910  *

   911  * Requires PHP 5.0+ and uses fopen with stream context. Requires that 'allow_url_fopen' PHP setting

   912  * to be enabled.

   913  *

   914  * Second preferred method for getting the URL, for PHP 5.

   915  *

   916  * @package WordPress

   917  * @subpackage HTTP

   918  * @since 2.7.0

   919  */

   920 class WP_Http_Streams {

   921 	/**

   922 	 * Send a HTTP request to a URI using streams with fopen().

   923 	 *

   924 	 * @access public

   925 	 * @since 2.7.0

   926 	 *

   927 	 * @param string $url

   928 	 * @param str|array $args Optional. Override the defaults.

   929 	 * @return array 'headers', 'body', 'cookies' and 'response' keys.

   930 	 */

   931 	function request($url, $args = array()) {

   932 		$defaults = array(

   933 			'method' => 'GET', 'timeout' => 5,

   934 			'redirection' => 5, 'httpversion' => '1.0',

   935 			'blocking' => true,

   936 			'headers' => array(), 'body' => null, 'cookies' => array()

   937 		);

   938 

   939 		$r = wp_parse_args( $args, $defaults );

   940 

   941 		if ( isset($r['headers']['User-Agent']) ) {

   942 			$r['user-agent'] = $r['headers']['User-Agent'];

   943 			unset($r['headers']['User-Agent']);

   944 		} else if( isset($r['headers']['user-agent']) ) {

   945 			$r['user-agent'] = $r['headers']['user-agent'];

   946 			unset($r['headers']['user-agent']);

   947 		}

   948 

   949 		// Construct Cookie: header if any cookies are set

   950 		WP_Http::buildCookieHeader( $r );

   951 

   952 		$arrURL = parse_url($url);

   953 

   954 		if ( false === $arrURL )

   955 			return new WP_Error('http_request_failed', sprintf(__('Malformed URL: %s'), $url));

   956 

   957 		if ( 'http' != $arrURL['scheme'] && 'https' != $arrURL['scheme'] )

   958 			$url = preg_replace('|^' . preg_quote($arrURL['scheme'], '|') . '|', 'http', $url);

   959 

   960 		// Convert Header array to string.

   961 		$strHeaders = '';

   962 		if ( is_array( $r['headers'] ) )

   963 			foreach ( $r['headers'] as $name => $value )

   964 				$strHeaders .= "{$name}: $value\r\n";

   965 		else if ( is_string( $r['headers'] ) )

   966 			$strHeaders = $r['headers'];

   967 

   968 		$is_local = isset($args['local']) && $args['local'];

   969 		$ssl_verify = isset($args['sslverify']) && $args['sslverify'];

   970 		if ( $is_local )

   971 			$ssl_verify = apply_filters('https_local_ssl_verify', $ssl_verify);

   972 		elseif ( ! $is_local )

   973 			$ssl_verify = apply_filters('https_ssl_verify', $ssl_verify);

   974 

   975 		$arrContext = array('http' =>

   976 			array(

   977 				'method' => strtoupper($r['method']),

   978 				'user_agent' => $r['user-agent'],

   979 				'max_redirects' => $r['redirection'],

   980 				'protocol_version' => (float) $r['httpversion'],

   981 				'header' => $strHeaders,

   982 				'timeout' => $r['timeout'],

   983 				'ssl' => array(

   984 						'verify_peer' => $ssl_verify,

   985 						'verify_host' => $ssl_verify

   986 				)

   987 			)

   988 		);

   989 

   990 		$proxy = new WP_HTTP_Proxy();

   991 

   992 		if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) {

   993 			$arrContext['http']['proxy'] = 'tcp://' . $proxy->host() . ':' . $proxy->port();

   994 			$arrContext['http']['request_fulluri'] = true;

   995 

   996 			// We only support Basic authentication so this will only work if that is what your proxy supports.

   997 			if ( $proxy->use_authentication() )

   998 				$arrContext['http']['header'] .= $proxy->authentication_header() . "\r\n";

   999 		}

  1000 

  1001 		if ( ! is_null($r['body']) && ! empty($r['body'] ) )

  1002 			$arrContext['http']['content'] = $r['body'];

  1003 

  1004 		$context = stream_context_create($arrContext);

  1005 

  1006 		if ( !WP_DEBUG )

  1007 			$handle = @fopen($url, 'r', false, $context);

  1008 		else

  1009 			$handle = fopen($url, 'r', false, $context);

  1010 

  1011 		if ( ! $handle)

  1012 			return new WP_Error('http_request_failed', sprintf(__('Could not open handle for fopen() to %s'), $url));

  1013 

  1014 		$timeout = (int) floor( $r['timeout'] );

  1015 		$utimeout = $timeout == $r['timeout'] ? 0 : 1000000 * $r['timeout'] % 1000000;

  1016 		stream_set_timeout( $handle, $timeout, $utimeout );

  1017 

  1018 		if ( ! $r['blocking'] ) {

  1019 			stream_set_blocking($handle, 0);

  1020 			fclose($handle);

  1021 			return array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() );

  1022 		}

  1023 

  1024 		$strResponse = stream_get_contents($handle);

  1025 		$meta = stream_get_meta_data($handle);

  1026 

  1027 		fclose($handle);

  1028 

  1029 		$processedHeaders = array();

  1030 		if ( isset( $meta['wrapper_data']['headers'] ) )

  1031 			$processedHeaders = WP_Http::processHeaders($meta['wrapper_data']['headers']);

  1032 		else

  1033 			$processedHeaders = WP_Http::processHeaders($meta['wrapper_data']);

  1034 

  1035 		if ( ! empty( $strResponse ) && isset( $processedHeaders['headers']['transfer-encoding'] ) && 'chunked' == $processedHeaders['headers']['transfer-encoding'] )

  1036 			$strResponse = WP_Http::chunkTransferDecode($strResponse);

  1037 

  1038 		if ( true === $r['decompress'] && true === WP_Http_Encoding::should_decode($processedHeaders['headers']) )

  1039 			$strResponse = WP_Http_Encoding::decompress( $strResponse );

  1040 

  1041 		return array('headers' => $processedHeaders['headers'], 'body' => $strResponse, 'response' => $processedHeaders['response'], 'cookies' => $processedHeaders['cookies']);

  1042 	}

  1043 

  1044 	/**

  1045 	 * Whether this class can be used for retrieving an URL.

  1046 	 *

  1047 	 * @static

  1048 	 * @access public

  1049 	 * @since 2.7.0

  1050 	 *

  1051 	 * @return boolean False means this class can not be used, true means it can.

  1052 	 */

  1053 	function test($args = array()) {

  1054 		if ( ! function_exists('fopen') || (function_exists('ini_get') && true != ini_get('allow_url_fopen')) )

  1055 			return false;

  1056 

  1057 		if ( version_compare(PHP_VERSION, '5.0', '<') )

  1058 			return false;

  1059 

  1060 		//HTTPS via Proxy was added in 5.1.0

  1061 		$is_ssl = isset($args['ssl']) && $args['ssl'];

  1062 		if ( $is_ssl && version_compare(PHP_VERSION, '5.1.0', '<') ) {

  1063 			$proxy = new WP_HTTP_Proxy();

  1064 			/**

  1065 			 * No URL check, as its not currently passed to the ::test() function

  1066 			 * In the case where a Proxy is in use, Just bypass this transport for HTTPS.

  1067 			 */

  1068 			if ( $proxy->is_enabled() )

  1069 				return false;

  1070 		}

  1071 

  1072 		return apply_filters('use_streams_transport', true, $args);

  1073 	}

  1074 }

  1075 

  1076 /**

  1077  * HTTP request method uses HTTP extension to retrieve the url.

  1078  *

  1079  * Requires the HTTP extension to be installed. This would be the preferred transport since it can

  1080  * handle a lot of the problems that forces the others to use the HTTP version 1.0. Even if PHP 5.2+

  1081  * is being used, it doesn't mean that the HTTP extension will be enabled.

  1082  *

  1083  * @package WordPress

  1084  * @subpackage HTTP

  1085  * @since 2.7.0

  1086  */

  1087 class WP_Http_ExtHTTP {

  1088 	/**

  1089 	 * Send a HTTP request to a URI using HTTP extension.

  1090 	 *

  1091 	 * Does not support non-blocking.

  1092 	 *

  1093 	 * @access public

  1094 	 * @since 2.7

  1095 	 *

  1096 	 * @param string $url

  1097 	 * @param str|array $args Optional. Override the defaults.

  1098 	 * @return array 'headers', 'body', 'cookies' and 'response' keys.

  1099 	 */

  1100 	function request($url, $args = array()) {

  1101 		$defaults = array(

  1102 			'method' => 'GET', 'timeout' => 5,

  1103 			'redirection' => 5, 'httpversion' => '1.0',

  1104 			'blocking' => true,

  1105 			'headers' => array(), 'body' => null, 'cookies' => array()

  1106 		);

  1107 

  1108 		$r = wp_parse_args( $args, $defaults );

  1109 

  1110 		if ( isset($r['headers']['User-Agent']) ) {

  1111 			$r['user-agent'] = $r['headers']['User-Agent'];

  1112 			unset($r['headers']['User-Agent']);

  1113 		} else if( isset($r['headers']['user-agent']) ) {

  1114 			$r['user-agent'] = $r['headers']['user-agent'];

  1115 			unset($r['headers']['user-agent']);

  1116 		}

  1117 

  1118 		// Construct Cookie: header if any cookies are set

  1119 		WP_Http::buildCookieHeader( $r );

  1120 

  1121 		switch ( $r['method'] ) {

  1122 			case 'POST':

  1123 				$r['method'] = HTTP_METH_POST;

  1124 				break;

  1125 			case 'HEAD':

  1126 				$r['method'] = HTTP_METH_HEAD;

  1127 				break;

  1128 			case 'PUT':

  1129 				$r['method'] =  HTTP_METH_PUT;

  1130 				break;

  1131 			case 'GET':

  1132 			default:

  1133 				$r['method'] = HTTP_METH_GET;

  1134 		}

  1135