<?php

/**

 * Simple and uniform HTTP request API.

 *

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

 *

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

 *

 * @package WordPress

 * @subpackage HTTP

 * @since 2.7.0

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

 */

/**

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

 *

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

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

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

 *

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

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

 *

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

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

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

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

 * way.

 *

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

 *

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

 *

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

 *

 * @package WordPress

 * @subpackage HTTP

 * @since 2.7.0

 */

class WP_Http {

	/**

	 * PHP4 style Constructor - Calls PHP5 Style Constructor

	 *

	 * @since 2.7.0

	 * @return WP_Http

	 */

	function WP_Http() {

		$this->__construct();

	}

	/**

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

	 *

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

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

	 *

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

	 * the overhead should be fine.

	 *

	 * @since 2.7.0

	 * @return WP_Http

	 */

	function __construct() {

		WP_Http::_getTransport();

		WP_Http::_postTransport();

	}

	/**

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

	 *

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

	 * that object to be used later.

	 *

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

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

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

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

	 * also handle redirects.

	 *

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

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

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

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

	 * has failed to respond."

	 *

	 * @since 2.7.0

	 * @access private

	 *

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

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

	 */

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

		static $working_transport, $blocking_transport, $nonblocking_transport;

		if ( is_null($working_transport) ) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			}

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

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

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

			}

		}

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

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

			return $nonblocking_transport;

		else

			return $blocking_transport;

	}

	/**

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

	 *

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

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

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

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

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

	 *

	 * @since 2.7.0

	 * @access private

	 *

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

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

	 */

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

		static $working_transport, $blocking_transport, $nonblocking_transport;

		if ( is_null($working_transport) ) {

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

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

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

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

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

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

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

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

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

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

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

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

			}

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

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

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

			}

		}

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

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

			return $nonblocking_transport;

		else

			return $blocking_transport;

	}

	/**

	 * Send a HTTP request to a URI.

	 *

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

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

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

	 * using http_build_query().

	 *

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

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

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

	 *

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

	 * 'user-agent'.

	 *

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

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

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

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

	 * accept setting that value.

	 *

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

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

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

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

	 *

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

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

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

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

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

	 * the request.

	 *

	 * @access public

	 * @since 2.7.0

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

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

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

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

	 *		arguments. Something to ponder at least.

	 *

	 * @param string $url URI resource.

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

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

	 */

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

		global $wp_version;

		$defaults = array(

			'method' => 'GET',

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

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

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

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

			'blocking' => true,

			'headers' => array(),

			'cookies' => array(),

			'body' => null,

			'compress' => false,

			'decompress' => true,

			'sslverify' => true

		);

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

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

		// Allow plugins to short-circuit the request

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

		if ( false !== $pre )

			return $pre;

		$arrURL = parse_url($url);

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

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

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

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

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

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

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

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

		unset($homeURL);

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

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

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

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

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

		}

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

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

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

		}

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

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

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

		}

		// Construct Cookie: header if any cookies are set

		WP_Http::buildCookieHeader( $r );

		if ( WP_Http_Encoding::is_available() )

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

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

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

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

			// header isn't already set.

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

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

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

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

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

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

		} else {

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

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

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

				else

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

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

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

			}

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

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

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

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

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

			// limitations.

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

		}

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

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

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

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

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

			if ( ! is_wp_error($response) )

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

		}

		return $response;

	}

	/**

	 * Uses the POST HTTP method.

	 *

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

	 *

	 * @access public

	 * @since 2.7.0

	 *

	 * @param string $url URI resource.

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

	 * @return boolean

	 */

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

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

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

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

	}

	/**

	 * Uses the GET HTTP method.

	 *

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

	 *

	 * @access public

	 * @since 2.7.0

	 *

	 * @param string $url URI resource.

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

	 * @return boolean

	 */

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

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

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

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

	}

	/**

	 * Uses the HEAD HTTP method.

	 *

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

	 *

	 * @access public

	 * @since 2.7.0

	 *

	 * @param string $url URI resource.

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

	 * @return boolean

	 */

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

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

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

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

	}

	/**

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

	 *

	 * @access public

	 * @static

	 * @since 2.7.0

	 *

	 * @param string $strResponse The full response string

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

	 */

	function processResponse($strResponse) {

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

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

	}

	/**

	 * Transform header string into an array.

	 *

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

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