<?php

/**

 * Simple and uniform HTTP request API.

 *

 * Standardizes the HTTP requests for WordPress. Handles cookies, gzip encoding and decoding, chunk

 * decoding, if HTTP 1.1 and various other difficult HTTP protocol implementations.

 *

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

 *

 * @package WordPress

 * @subpackage HTTP

 * @since 2.7.0

 */

/**

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

 *

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

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

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

 *

 * 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.

 *

 * @package WordPress

 * @subpackage HTTP

 * @since 2.7.0

 */

class WP_Http {

	/**

	 * 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|object Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error

	 */

	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,

			'stream' => false,

			'filename' => null

		);

		// Pre-parse for the HEAD checks.

		$args = wp_parse_args( $args );

		// By default, Head requests do not cause redirections.

		if ( isset($args['method']) && 'HEAD' == $args['method'] )

			$defaults['redirection'] = 0;

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

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

		// Certain classes decrement this, store a copy of the original value for loop purposes.

		$r['_redirection'] = $r['redirection'];

		// 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 ( empty( $url ) || empty( $arrURL['scheme'] ) )

			return new WP_Error('http_request_failed', __('A valid URL was not provided.'));

		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 we are streaming to a file but no filename was given drop it in the WP temp dir

		// and pick it's name using the basename of the $url

		if ( $r['stream']  && empty( $r['filename'] ) )

			$r['filename'] = get_temp_dir() . basename( $url );

		// Force some settings if we are streaming to a file and check for existence and perms of destination directory

		if ( $r['stream'] ) {

			$r['blocking'] = true;

			if ( ! is_writable( dirname( $r['filename'] ) ) )

				return new WP_Error( 'http_request_failed', __( 'Destination directory for file streaming does not exist or is not writable.' ) );

		}

		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 ( is_array( $r['body'] ) || is_object( $r['body'] ) ) {

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

				if ( ! isset( $r['headers']['Content-Type'] ) )

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

			}

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

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

		}

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

	}

	/**

	 * Tests which transports are capable of supporting the request.

	 *

	 * @since 3.2.0

	 * @access private

	 *

	 * @param array $args Request arguments

	 * @param string $url URL to Request

	 *

	 */

	public function _get_first_available_transport( $args, $url = null ) {

		$request_order = array( 'curl', 'streams', 'fsockopen' );

		// Loop over each transport on each HTTP request looking for one which will serve this request's needs

		foreach ( $request_order as $transport ) {

			$class = 'WP_HTTP_' . $transport;

			// Check to see if this transport is a possibility, calls the transport statically

			if ( !call_user_func( array( $class, 'test' ), $args, $url ) )

				continue;

			return $class;

		}

		return false;

	}

	/**

	 * Dispatches a HTTP request to a supporting transport.

	 *

	 * Tests each transport in order to find a transport which matches the request arguments.

	 * Also caches the transport instance to be used later.

	 *

	 * The order for blocking requests is cURL, Streams, and finally Fsockopen.

	 * The order for non-blocking requests is cURL, Streams and Fsockopen().

	 *

	 * 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 [the]

	 * connected host has failed to respond."

	 *

	 * @since 3.2.0

	 * @access private

	 *

	 * @param string $url URL to Request

	 * @param array $args Request arguments

	 * @return array|object Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error

	 */

	private function _dispatch_request( $url, $args ) {

		static $transports = array();

		$class = $this->_get_first_available_transport( $args, $url );

		if ( !$class )

			return new WP_Error( 'http_failure', __( 'There are no HTTP transports available which can complete the requested request.' ) );

		// Transport claims to support request, instantiate it and give it a whirl.

		if ( empty( $transports[$class] ) )

			$transports[$class] = new $class;

		$response = $transports[$class]->request( $url, $args );

		do_action( 'http_api_debug', $response, 'response', $class, $args, $url );

		if ( is_wp_error( $response ) )

			return $response;

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

	}

	/**

	 * 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 array|object Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error

	 */

	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 array|object Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error

	 */

	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 array|object Array containing 'headers', 'body', 'response', 'cookies', 'filename'. A WP_Error instance upon error

	 */

	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) {

		$res = explode("\r\n\r\n", $strResponse, 2);

		return array('headers' => $res[0], 'body' => isset($res[1]) ? $res[1] : '');

	}

	/**

	 * 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.

	 *

	 * @access public

	 * @static

	 * @since 2.7.0

	 *

	 * @param string|array $headers

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

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

	 */

	public static function processHeaders($headers) {

		// split headers, one per array element

		if ( is_string($headers) ) {

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

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

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

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

			// create the headers array

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

		}

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

		// If a redirection has taken place, The headers for each page request may have been passed.

		// In this case, determine the final HTTP header and parse from there.

		for ( $i = count($headers)-1; $i >= 0; $i-- ) {

			if ( !empty($headers[$i]) && false === strpos($headers[$i], ':') ) {

				$headers = array_splice($headers, $i);

				break;

			}

		}

		$cookies = array();

		$newheaders = array();

		foreach ( (array) $headers as $tempheader ) {

			if ( empty($tempheader) )

				continue;

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

				$stack = explode(' ', $tempheader, 3);

				$stack[] = '';

				list( , $response['code'], $response['message']) = $stack;

				continue;

			}

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

			}

		}

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

	}

	/**

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

	 *

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

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

	 * reference.

	 *

	 * @access public

	 * @version 2.8.0

	 * @static

	 *

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

	 */

	public static function buildCookieHeader( &$r ) {

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

			$cookies_header = '';

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

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

			}

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

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

		}

	}

	/**

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

	 *